create-myexam-app 1.0.21 → 1.0.22

package/index.js

@@ -11,31 +11,39 @@ const rl = readline.createInterface({
 })
 console.log('\n[1] Car Repair Parking Managemnt System')
 console.log('[2]Employee Payroll Management System')
-console.log('[3]middleware')
-console.log('[4] Parking Management System')
-console.log('[5]Supply Chain Managemnt System')
- console.log('[6] School fee Management System')
- console.log('[7]Stock Invetory Management System')
- console.log('[8]Stock Management System')
- console.log('[9]Stock Record Management System')
- console.log('[10]userController.js')
+console.log('[3]Employee Payroll Management System Elysee')
+console.log('[4]middleware')
+console.log('[5] Parking Management System')
+console.log('[6]Supply Chain Managemnt System')
+console.log('[7]Supply Chain Management System Elysee')
+ console.log('[8] School fee Management System')
+ console.log('[9]Stock Hub Management System')
+ console.log('[10]Stock Invetory Management System')
+ console.log('[11]Stock Management System')
+ console.log('[12]Sales Record Management System')
+ console.log('[13]Sales Record Management System Elysee')
+ console.log('[14]userController.js')
  
 
 
 
-rl.question('Pick (1-10): ', (answer) => {
+rl.question('Pick (1-14): ', (answer) => {
 
   const projects = {
     '1':'crpms',
     '2':'EPMS',
-    '3':'middleware',
-    '4': 'parking managementt system',
-    '5':'SCMS',
-    '6': 'sfms-app',
-    '7':'sims',
-    '8': 'SMS-',
-    '9':'SRMS',
-    '10':'user',
+    '3':'EPMS(Ely)',
+    '4':'middleware',
+    '5': 'parking managementt system',
+    '6':'SCMS',
+    '7':'SCMS(Ely)',
+    '8': 'sfms-app',
+    '9':'SHMS(Ely)',
+    '10':'sims',
+    '11': 'SMS-',
+    '12':'SRMS',
+    '13':'SRMS(Ely)',
+    '14':'user',
     
      
   }

package/package.json

@@ -2,7 +2,7 @@
   
   "name": "create-myexam-app",
   
-  "version": "1.0.21",
+  "version": "1.0.22",
   
   "description": "My exam projects",
   

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/README.md

@@ -0,0 +1,84 @@
+# KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026
+
+## Project Name
+
+Stock Management System for StockHub Ltd.
+
+## Technologies Used
+
+Frontend:
+- React.js
+- React Router DOM
+- Axios
+- Tailwind CSS
+
+Backend:
+- Node.js
+- Express.js
+- MongoDB
+- Mongoose
+- bcryptjs
+- express-session
+
+## Installation Steps
+
+1. Open the project folder:
+
+```bash
+cd KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026
+```
+
+2. Install backend dependencies:
+
+```bash
+cd backend-project
+npm install
+```
+
+3. Install frontend dependencies:
+
+```bash
+cd ../frontend-project
+npm install
+```
+
+4. Make sure MongoDB is running locally.
+
+The backend uses this MongoDB database:
+
+```bash
+mongodb://127.0.0.1:27017/SMS
+```
+
+## Backend Startup
+
+```bash
+cd backend-project
+npm run dev
+```
+
+Backend URL:
+
+```bash
+http://localhost:5000
+```
+
+Default login account:
+
+```bash
+Username: manager
+Password: manager123
+```
+
+## Frontend Startup
+
+```bash
+cd frontend-project
+npm run dev
+```
+
+Frontend URL:
+
+```bash
+http://localhost:5173
+```

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/backend-project/.env

@@ -0,0 +1,3 @@
+PORT=5000
+MONGO_URI=mongodb://127.0.0.1:27017/epms
+SESSION_SECRET=epms_exam_secret

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/backend-project/config/db.js

@@ -0,0 +1,13 @@
+const mongoose = require("mongoose");
+
+const connectDB = async () => {
+  try {
+    await mongoose.connect(process.env.MONGO_URI || "mongodb://127.0.0.1:27017/epms");
+    console.log("MongoDB connected to EPMS database");
+  } catch (error) {
+    console.error("MongoDB connection failed:", error.message);
+    process.exit(1);
+  }
+};
+
+module.exports = connectDB;

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/backend-project/controllers/authController.js

@@ -0,0 +1,115 @@
+const bcrypt = require("bcryptjs");
+const User = require("../models/User");
+
+const saveSession = (req, res, message, user) => {
+  req.session.user = {
+    id: user._id,
+    username: user.username
+  };
+
+  req.session.save((error) => {
+    if (error) {
+      return res.status(500).json({ message: "Session could not be saved" });
+    }
+
+    res.json({ message, user: req.session.user });
+  });
+};
+
+const register = async (req, res) => {
+  try {
+    const { username, password } = req.body;
+
+    if (!username || !password) {
+      return res.status(400).json({ message: "Username and password are required" });
+    }
+
+    const existingUser = await User.findOne({ username: username.trim() });
+    if (existingUser) {
+      return res.status(400).json({ message: "Username already exists" });
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+    const user = await User.create({
+      username: username.trim(),
+      password: hashedPassword
+    });
+
+    saveSession(req, res, "Account created successfully", user);
+  } catch (error) {
+    res.status(500).json({ message: "Registration failed", error: error.message });
+  }
+};
+
+const login = async (req, res) => {
+  try {
+    const { username, password } = req.body;
+
+    if (!username || !password) {
+      return res.status(400).json({ message: "Username and password are required" });
+    }
+
+    const user = await User.findOne({ username: username.trim() });
+    if (!user) {
+      return res.status(400).json({ message: "Invalid username or password" });
+    }
+
+    const isPasswordCorrect = await bcrypt.compare(password, user.password);
+    if (!isPasswordCorrect) {
+      return res.status(400).json({ message: "Invalid username or password" });
+    }
+
+    saveSession(req, res, "Login successful", user);
+  } catch (error) {
+    res.status(500).json({ message: "Login failed", error: error.message });
+  }
+};
+
+const logout = (req, res) => {
+  req.session.destroy((error) => {
+    if (error) {
+      return res.status(500).json({ message: "Logout failed" });
+    }
+
+    res.clearCookie("connect.sid");
+    res.json({ message: "Logout successful" });
+  });
+};
+
+const getSession = (req, res) => {
+  if (!req.session || !req.session.user) {
+    return res.status(401).json({ message: "No active session" });
+  }
+
+  res.json({ user: req.session.user });
+};
+
+const recoverPassword = async (req, res) => {
+  try {
+    const { username, newPassword } = req.body;
+
+    if (!username || !newPassword) {
+      return res.status(400).json({ message: "Username and new password are required" });
+    }
+
+    const user = await User.findOne({ username: username.trim() });
+    if (!user) {
+      return res.status(404).json({ message: "User account was not found" });
+    }
+
+    user.password = await bcrypt.hash(newPassword, 10);
+    await user.save();
+
+    res.json({ message: "Password changed successfully" });
+  } catch (error) {
+    res.status(500).json({ message: "Password recovery failed", error: error.message });
+  }
+};
+
+module.exports = {
+  register,
+  login,
+  logout,
+  getSession,
+  recoverPassword
+};

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/backend-project/controllers/employeeController.js

@@ -0,0 +1,97 @@
+const Employee = require("../models/Employee");
+
+const createEmployee = async (req, res) => {
+  try {
+    const { employeeCode, firstName, lastName, department, position, baseSalary, hireDate, email, phone } = req.body;
+
+    if (!employeeCode || !firstName || !lastName || !department || !position || !baseSalary || !hireDate) {
+      return res.status(400).json({ message: "All required fields must be filled" });
+    }
+
+    const existingEmployee = await Employee.findOne({ employeeCode });
+    if (existingEmployee) {
+      return res.status(400).json({ message: "Employee code already exists" });
+    }
+
+    const employee = await Employee.create({
+      employeeCode,
+      firstName: firstName.trim(),
+      lastName: lastName.trim(),
+      department: department.trim(),
+      position: position.trim(),
+      baseSalary,
+      hireDate,
+      email,
+      phone
+    });
+
+    res.status(201).json({ message: "Employee added successfully", employee });
+  } catch (error) {
+    res.status(500).json({ message: "Employee could not be created", error: error.message });
+  }
+};
+
+const getEmployees = async (req, res) => {
+  try {
+    const employees = await Employee.find().sort({ lastName: 1 });
+    res.json(employees);
+  } catch (error) {
+    res.status(500).json({ message: "Employees could not be retrieved", error: error.message });
+  }
+};
+
+const getEmployee = async (req, res) => {
+  try {
+    const employee = await Employee.findById(req.params.id);
+
+    if (!employee) {
+      return res.status(404).json({ message: "Employee not found" });
+    }
+
+    res.json(employee);
+  } catch (error) {
+    res.status(500).json({ message: "Employee could not be retrieved", error: error.message });
+  }
+};
+
+const updateEmployee = async (req, res) => {
+  try {
+    const { firstName, lastName, department, position, baseSalary, hireDate, email, phone } = req.body;
+
+    const employee = await Employee.findByIdAndUpdate(
+      req.params.id,
+      { firstName, lastName, department, position, baseSalary, hireDate, email, phone },
+      { new: true, runValidators: true }
+    );
+
+    if (!employee) {
+      return res.status(404).json({ message: "Employee not found" });
+    }
+
+    res.json({ message: "Employee updated successfully", employee });
+  } catch (error) {
+    res.status(500).json({ message: "Employee could not be updated", error: error.message });
+  }
+};
+
+const deleteEmployee = async (req, res) => {
+  try {
+    const employee = await Employee.findByIdAndDelete(req.params.id);
+
+    if (!employee) {
+      return res.status(404).json({ message: "Employee not found" });
+    }
+
+    res.json({ message: "Employee deleted successfully" });
+  } catch (error) {
+    res.status(500).json({ message: "Employee could not be deleted", error: error.message });
+  }
+};
+
+module.exports = {
+  createEmployee,
+  getEmployees,
+  getEmployee,
+  updateEmployee,
+  deleteEmployee
+};

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/backend-project/controllers/payrollController.js

@@ -0,0 +1,113 @@
+const Payroll = require("../models/Payroll");
+const Employee = require("../models/Employee");
+
+const createPayroll = async (req, res) => {
+  try {
+    const { employee, month, year, basicPay, allowances, deductions, netPay, paymentDate } = req.body;
+
+    if (!employee || !month || !year || basicPay === undefined || netPay === undefined) {
+      return res.status(400).json({ message: "Employee, month, year, basic pay and net pay are required" });
+    }
+
+    const employeeExists = await Employee.findById(employee);
+    if (!employeeExists) {
+      return res.status(404).json({ message: "Employee not found" });
+    }
+
+    const existingPayroll = await Payroll.findOne({ employee, month, year });
+    if (existingPayroll) {
+      return res.status(400).json({ message: "Payroll already exists for this employee for the given period" });
+    }
+
+    const payroll = await Payroll.create({
+      employee,
+      month,
+      year,
+      basicPay,
+      allowances: allowances || 0,
+      deductions: deductions || 0,
+      netPay,
+      paymentDate: paymentDate || Date.now()
+    });
+
+    const populatedPayroll = await Payroll.findById(payroll._id).populate("employee");
+
+    res.status(201).json({ message: "Payroll processed successfully", payroll: populatedPayroll });
+  } catch (error) {
+    res.status(500).json({ message: "Payroll could not be created", error: error.message });
+  }
+};
+
+const getPayrolls = async (req, res) => {
+  try {
+    const filter = {};
+
+    if (req.query.month) filter.month = parseInt(req.query.month);
+    if (req.query.year) filter.year = parseInt(req.query.year);
+    if (req.query.employee) filter.employee = req.query.employee;
+
+    const payrolls = await Payroll.find(filter)
+      .populate("employee")
+      .sort({ year: -1, month: -1 });
+
+    res.json(payrolls);
+  } catch (error) {
+    res.status(500).json({ message: "Payrolls could not be retrieved", error: error.message });
+  }
+};
+
+const getPayroll = async (req, res) => {
+  try {
+    const payroll = await Payroll.findById(req.params.id).populate("employee");
+
+    if (!payroll) {
+      return res.status(404).json({ message: "Payroll record not found" });
+    }
+
+    res.json(payroll);
+  } catch (error) {
+    res.status(500).json({ message: "Payroll could not be retrieved", error: error.message });
+  }
+};
+
+const updatePayroll = async (req, res) => {
+  try {
+    const { basicPay, allowances, deductions, netPay, paymentDate } = req.body;
+
+    const payroll = await Payroll.findByIdAndUpdate(
+      req.params.id,
+      { basicPay, allowances, deductions, netPay, paymentDate },
+      { new: true, runValidators: true }
+    ).populate("employee");
+
+    if (!payroll) {
+      return res.status(404).json({ message: "Payroll record not found" });
+    }
+
+    res.json({ message: "Payroll updated successfully", payroll });
+  } catch (error) {
+    res.status(500).json({ message: "Payroll could not be updated", error: error.message });
+  }
+};
+
+const deletePayroll = async (req, res) => {
+  try {
+    const payroll = await Payroll.findByIdAndDelete(req.params.id);
+
+    if (!payroll) {
+      return res.status(404).json({ message: "Payroll record not found" });
+    }
+
+    res.json({ message: "Payroll record deleted successfully" });
+  } catch (error) {
+    res.status(500).json({ message: "Payroll could not be deleted", error: error.message });
+  }
+};
+
+module.exports = {
+  createPayroll,
+  getPayrolls,
+  getPayroll,
+  updatePayroll,
+  deletePayroll
+};

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/backend-project/controllers/reportController.js

@@ -0,0 +1,35 @@
+const Payroll = require("../models/Payroll");
+const Employee = require("../models/Employee");
+
+const getReports = async (req, res) => {
+  try {
+    const month = parseInt(req.query.month) || new Date().getMonth() + 1;
+    const year = parseInt(req.query.year) || new Date().getFullYear();
+
+    const payrolls = await Payroll.find({ month, year })
+      .populate("employee")
+      .sort({ "employee.lastName": 1 });
+
+    const totalEmployees = await Employee.countDocuments();
+    const totalPayrollAmount = payrolls.reduce((sum, p) => sum + p.netPay, 0);
+    const totalAllowances = payrolls.reduce((sum, p) => sum + (p.allowances || 0), 0);
+    const totalDeductions = payrolls.reduce((sum, p) => sum + (p.deductions || 0), 0);
+
+    res.json({
+      month,
+      year,
+      totalEmployees,
+      payrollRecords: payrolls,
+      totalPayrollAmount,
+      totalAllowances,
+      totalDeductions,
+      recordCount: payrolls.length
+    });
+  } catch (error) {
+    res.status(500).json({ message: "Report could not be generated", error: error.message });
+  }
+};
+
+module.exports = {
+  getReports
+};

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/backend-project/middleware/authMiddleware.js

@@ -0,0 +1,9 @@
+const requireAuth = (req, res, next) => {
+  if (!req.session || !req.session.user) {
+    return res.status(401).json({ message: "Please login first" });
+  }
+
+  next();
+};
+
+module.exports = requireAuth;

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/backend-project/models/Employee.js

@@ -0,0 +1,52 @@
+const mongoose = require("mongoose");
+
+const employeeSchema = new mongoose.Schema(
+  {
+    employeeCode: {
+      type: String,
+      required: [true, "Employee code is required"],
+      unique: true,
+      trim: true
+    },
+    firstName: {
+      type: String,
+      required: [true, "First name is required"],
+      trim: true
+    },
+    lastName: {
+      type: String,
+      required: [true, "Last name is required"],
+      trim: true
+    },
+    department: {
+      type: String,
+      required: [true, "Department is required"],
+      trim: true
+    },
+    position: {
+      type: String,
+      required: [true, "Position is required"],
+      trim: true
+    },
+    baseSalary: {
+      type: Number,
+      required: [true, "Base salary is required"],
+      min: [0, "Salary cannot be negative"]
+    },
+    hireDate: {
+      type: Date,
+      required: [true, "Hire date is required"]
+    },
+    email: {
+      type: String,
+      trim: true
+    },
+    phone: {
+      type: String,
+      trim: true
+    }
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model("Employee", employeeSchema);

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/backend-project/models/Payroll.js

@@ -0,0 +1,50 @@
+const mongoose = require("mongoose");
+
+const payrollSchema = new mongoose.Schema(
+  {
+    employee: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "Employee",
+      required: [true, "Employee is required"]
+    },
+    month: {
+      type: Number,
+      required: [true, "Month is required"],
+      min: 1,
+      max: 12
+    },
+    year: {
+      type: Number,
+      required: [true, "Year is required"]
+    },
+    basicPay: {
+      type: Number,
+      required: [true, "Basic pay is required"],
+      min: 0
+    },
+    allowances: {
+      type: Number,
+      default: 0,
+      min: 0
+    },
+    deductions: {
+      type: Number,
+      default: 0,
+      min: 0
+    },
+    netPay: {
+      type: Number,
+      required: [true, "Net pay is required"],
+      min: 0
+    },
+    paymentDate: {
+      type: Date,
+      default: Date.now
+    }
+  },
+  { timestamps: true }
+);
+
+payrollSchema.index({ employee: 1, month: 1, year: 1 }, { unique: true });
+
+module.exports = mongoose.model("Payroll", payrollSchema);

package/projects/EPMS(Ely)/KALIWABO_SHEMA_ELYSEE_National_Practical_Examination_2026/backend-project/models/User.js

@@ -0,0 +1,19 @@
+const mongoose = require("mongoose");
+
+const userSchema = new mongoose.Schema(
+  {
+    username: {
+      type: String,
+      required: [true, "Username is required"],
+      unique: true,
+      trim: true
+    },
+    password: {
+      type: String,
+      required: [true, "Password is required"]
+    }
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model("User", userSchema);