create-ishvexa-app 1.0.0

package/index.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+
+const inquirer = require("inquirer");
+const path = require("path");
+const fs = require("fs-extra");
+const chalk = require("chalk");
+const ora = require("ora");
+
+const templates = {
+  "EPMS - Employee Payroll Management System": "epms-app",
+  "IMS - Inventory Management System": "lms-app",
+  "SCMS - Supply Chain Management System": "scms-app",
+  "SFMS - School Fees Management System": "sfms-app",
+  "SIMS - Stock Inventory Management System": "sims-app",
+  "SmartShop": "smartshop-app",
+  "SRMS - Sales Records Management System": "srms-app",
+  "StockHub SMS": "stockhub-sms-app",
+};
+
+async function run() {
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "project",
+      message: "Select project to create:",
+      choices: Object.keys(templates),
+    },
+    {
+      type: "input",
+      name: "name",
+      message: "Enter project folder name:",
+      default: "my-app",
+    },
+  ]);
+
+  const spinner = ora("Creating project...").start();
+
+  const templateFolder = templates[answers.project];
+  const source = path.join(__dirname, "templates", templateFolder);
+  const target = path.join(process.cwd(), answers.name);
+
+  if (fs.existsSync(target)) {
+    spinner.fail("Folder already exists!");
+    return;
+  }
+
+  try {
+    fs.copySync(source, target);
+    spinner.succeed("Project created successfully!");
+
+    console.log(
+      chalk.green("\nNext steps:\n"),
+      `  cd ${answers.name}\n`,
+      "  npm install\n",
+      "  npm run dev"
+    );
+  } catch (err) {
+    spinner.fail("Failed to create project: " + err.message);
+  }
+}
+
+run();

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "create-ishvexa-app",
+  "version": "1.0.0",
+  "description": "CLI scaffolding tool for ishvexa apps",
+  "bin": {
+    "create-ishvexa-app": "./index.js"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "fs-extra": "^11.1.1",
+    "inquirer": "^8.2.5",
+    "ora": "^5.4.1"
+  }
+}

package/templates/epms-app/.env

@@ -0,0 +1,7 @@
+PORT=5555
+JWT_SECRET=exam_jwt_secret_change_in_production
+DB_HOST=localhost
+DB_USER=student
+DB_PASSWORD=
+DB_NAME=EPMS
+DB_PORT=3306

package/templates/epms-app/README.md

@@ -0,0 +1,113 @@
+# Employee Payroll Management System (EPMS)
+
+National Practical Exam template — Software Development (TSS).
+
+## ERD
+
+| Entity | Primary Key | Attributes |
+|--------|-------------|------------|
+| **Department** | `departmentCode` | departmentName |
+| **Employee** | `employeeNumber` | firstName, lastName, address, position, telephone, gender, hiredDate, departmentCode (FK) |
+| **Salary** | `salary_id` | grossSalary, totalDeduction, netSalary, monthOfPayment, employeeNumber (FK) |
+
+Relationships:
+- Department (1) — (M) Employee
+- Employee (1) — (M) Salary
+
+## Exam rules implemented
+
+| Form | Insert | Update / Delete / List |
+|------|--------|-------------------------|
+| Employee | Yes | List only |
+| Department | Yes | List only |
+| Salary | Yes | Full CRUD |
+
+- Menu: **Employee**, **Department**, **Salary**, **Reports**, **Logout**
+- Auth: username + password (JWT)
+- Reports: daily (date picker), weekly (start/end date), monthly (month picker)
+- Stack: React + Tailwind + Axios + Express + MySQL or MongoDB
+
+## Installation
+
+```bash
+cd backend-mysql && npm install
+cd ../backend-mongodb && npm install
+cd ../frontend && npm install
+```
+
+## Database setup (MySQL)
+
+```bash
+cd backend-mysql
+cp .env.example .env
+npm run db:init
+```
+
+Database name: **EPMS**
+
+## Run development server
+
+MySQL API (port 5555):
+
+```bash
+cd backend-mysql && npm run dev
+```
+
+MongoDB API (port 5555 — run one backend at a time):
+
+```bash
+cd backend-mongodb && npm run dev
+```
+
+Frontend (port 5173):
+
+```bash
+cd frontend && npm run dev
+```
+
+Default login: `admin` / `admin123`
+
+## Environment variables
+
+### backend-mysql
+
+| Variable | Description |
+|----------|-------------|
+| PORT | API port (5555) |
+| JWT_SECRET | JWT secret |
+| DB_HOST | MySQL host |
+| DB_USER | MySQL user |
+| DB_PASSWORD | MySQL password |
+| DB_NAME | EPMS |
+| DB_PORT | MySQL port |
+
+### backend-mongodb
+
+| Variable | Description |
+|----------|-------------|
+| PORT | API port (5555) |
+| JWT_SECRET | JWT secret |
+| MONGO_URI | MongoDB URI (database: EPMS) |
+
+## API endpoints
+
+- POST /api/auth/register
+- POST /api/auth/login
+- GET/POST /api/departments
+- GET/POST /api/employees
+- GET/POST/PUT/DELETE /api/salaries
+- GET /api/reports?period=daily&date=YYYY-MM-DD
+- GET /api/reports?period=weekly&startDate=YYYY-MM-DD&endDate=YYYY-MM-DD
+- GET /api/reports?period=monthly&month=YYYY-MM
+
+## Folder structure
+
+```
+epms/
+├── README.md
+├── frontend/
+├── backend-mysql/
+└── backend-mongodb/
+```
+
+Save your exam folder as: `FirstName_LastName_National_Practical_Exam_2026`

package/templates/epms-app/backend-mongodb/.env

@@ -0,0 +1,3 @@
+PORT=5555
+JWT_SECRET=exam_jwt_secret_change_in_production
+MONGO_URI=mongodb://localhost:27017/EPMS

package/templates/epms-app/backend-mongodb/.env.example

@@ -0,0 +1,3 @@
+PORT=5555
+JWT_SECRET=exam_jwt_secret_change_in_production
+MONGO_URI=mongodb://localhost:27017/EPMS

package/templates/epms-app/backend-mongodb/config/db.js

@@ -0,0 +1,29 @@
+import mongoose from "mongoose";
+import dotenv from "dotenv";
+import User from "../models/User.js";
+
+dotenv.config();
+
+const ADMIN_HASH = "$2b$10$aULsUjp9bb9lf5CZZyY.7./KhwsocVO0duyPlqu0Qnte75xHBdG5C";
+
+export const connectDatabase = async () => {
+  try {
+    await mongoose.connect(process.env.MONGO_URI || "mongodb://localhost:27017/EPMS");
+    console.log("Database Connected Successfully");
+    const count = await User.countDocuments();
+    if (count === 0) {
+      await User.create({
+        username: "admin",
+        email: "admin@exam.local",
+        password: ADMIN_HASH,
+      });
+    }
+    return true;
+  } catch (error) {
+    console.log("Database Connection Failed");
+    console.error(error.message);
+    return false;
+  }
+};
+
+export default mongoose;

package/templates/epms-app/backend-mongodb/controllers/authController.js

@@ -0,0 +1,93 @@
+import bcrypt from "bcryptjs";
+import jwt from "jsonwebtoken";
+import User from "../models/User.js";
+
+const signToken = (user) =>
+  jwt.sign(
+    { id: user._id, username: user.username },
+    process.env.JWT_SECRET || "exam_secret",
+    { expiresIn: "8h" }
+  );
+
+const normalizeEmail = (email) => String(email || "").trim().toLowerCase();
+
+export const register = async (req, res) => {
+  try {
+    const { username, email, password } = req.body;
+    if (!username || !email || !password) {
+      return res.status(400).json({ message: "Username, email and password are required." });
+    }
+    const emailNorm = normalizeEmail(email);
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(emailNorm)) {
+      return res.status(400).json({ message: "Enter a valid email address." });
+    }
+    const existingUser = await User.findOne({ username: username.trim() });
+    if (existingUser) {
+      return res.status(409).json({ message: "Username already exists." });
+    }
+    const existingEmail = await User.findOne({ email: emailNorm });
+    if (existingEmail) {
+      return res.status(409).json({ message: "Email already registered." });
+    }
+    const hash = await bcrypt.hash(password, 10);
+    await User.create({ username: username.trim(), email: emailNorm, password: hash });
+    return res.status(201).json({ message: "Account created successfully." });
+  } catch {
+    return res.status(500).json({ message: "Server error during registration." });
+  }
+};
+
+export 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(401).json({ message: "Invalid credentials." });
+    }
+    const match = await bcrypt.compare(password, user.password);
+    if (!match) {
+      return res.status(401).json({ message: "Invalid credentials." });
+    }
+    return res.json({
+      message: "Login successful.",
+      token: signToken(user),
+      user: { id: user._id, username: user.username, email: user.email },
+    });
+  } catch {
+    return res.status(500).json({ message: "Server error during login." });
+  }
+};
+
+export const forgotPassword = async (req, res) => {
+  try {
+    const { email, newPassword, confirmPassword } = req.body;
+    if (!email) {
+      return res.status(400).json({ success: false, message: "Email is required." });
+    }
+    if (!newPassword) {
+      return res.status(400).json({ success: false, message: "New password is required." });
+    }
+    if (!confirmPassword) {
+      return res.status(400).json({ success: false, message: "Confirm password is required." });
+    }
+    if (newPassword !== confirmPassword) {
+      return res.status(400).json({
+        success: false,
+        message: "New password and confirm password must match.",
+      });
+    }
+    const emailNorm = normalizeEmail(email);
+    const user = await User.findOne({ email: emailNorm });
+    if (!user) {
+      return res.status(404).json({ success: false, message: "User not found" });
+    }
+    user.password = await bcrypt.hash(newPassword, 10);
+    await user.save();
+    return res.json({ success: true, message: "Password reset successfully" });
+  } catch {
+    return res.status(500).json({ success: false, message: "Server error." });
+  }
+};

package/templates/epms-app/backend-mongodb/controllers/departmentController.js

@@ -0,0 +1,24 @@
+import Department from "../models/Department.js";
+
+export const create = async (req, res) => {
+  try {
+    if (req.body.departmentCode === undefined || req.body.departmentCode === "") return res.status(400).json({ message: "Department Code is required." });
+    if (req.body.departmentName === undefined || req.body.departmentName === "") return res.status(400).json({ message: "Department Name is required." });
+    await Department.create({ department_code: req.body.departmentCode, department_name: req.body.departmentName });
+    return res.status(201).json({ message: "Department added successfully." });
+  } catch (error) {
+    if (error.code === 11000) {
+      return res.status(409).json({ message: "Department already exists." });
+    }
+    return res.status(500).json({ message: "Failed to add department." });
+  }
+};
+
+export const getAll = async (_req, res) => {
+  try {
+    const rows = await Department.find().sort({ department_code: -1 }).lean();
+    return res.json(rows.map((r) => { const { _id, __v, ...rest } = r; return rest; }));
+  } catch {
+    return res.status(500).json({ message: "Failed to fetch department records." });
+  }
+};

package/templates/epms-app/backend-mongodb/controllers/employeeController.js

@@ -0,0 +1,39 @@
+import Employee from "../models/Employee.js";
+import Department from "../models/Department.js";
+
+const ALLOWED_GENDERS = ["Male", "Female"];
+
+export const create = async (req, res) => {
+  try {
+    if (req.body.employeeNumber === undefined || req.body.employeeNumber === "") return res.status(400).json({ message: "Employee Number is required." });
+    if (req.body.firstName === undefined || req.body.firstName === "") return res.status(400).json({ message: "First Name is required." });
+    if (req.body.lastName === undefined || req.body.lastName === "") return res.status(400).json({ message: "Last Name is required." });
+    if (req.body.address === undefined || req.body.address === "") return res.status(400).json({ message: "Address is required." });
+    if (req.body.position === undefined || req.body.position === "") return res.status(400).json({ message: "Position is required." });
+    if (req.body.telephone === undefined || req.body.telephone === "") return res.status(400).json({ message: "Telephone is required." });
+    if (req.body.gender === undefined || req.body.gender === "") return res.status(400).json({ message: "Gender is required." });
+    if (!ALLOWED_GENDERS.includes(req.body.gender)) {
+      return res.status(400).json({ message: "Select a valid gender (Male or Female)." });
+    }
+    if (req.body.hiredDate === undefined || req.body.hiredDate === "") return res.status(400).json({ message: "Hired Date is required." });
+    if (req.body.departmentCode === undefined || req.body.departmentCode === "") return res.status(400).json({ message: "Select a department from the list." });
+    const dept = await Department.findOne({ department_code: req.body.departmentCode });
+    if (!dept) return res.status(400).json({ message: "Selected department does not exist." });
+    await Employee.create({ employee_number: req.body.employeeNumber, first_name: req.body.firstName, last_name: req.body.lastName, address: req.body.address, position: req.body.position, telephone: req.body.telephone, gender: req.body.gender, hired_date: req.body.hiredDate, department_code: req.body.departmentCode });
+    return res.status(201).json({ message: "Employee added successfully." });
+  } catch (error) {
+    if (error.code === 11000) {
+      return res.status(409).json({ message: "Employee already exists." });
+    }
+    return res.status(500).json({ message: "Failed to add employee." });
+  }
+};
+
+export const getAll = async (_req, res) => {
+  try {
+    const rows = await Employee.find().sort({ employee_number: -1 }).lean();
+    return res.json(rows.map((r) => { const { _id, __v, ...rest } = r; return rest; }));
+  } catch {
+    return res.status(500).json({ message: "Failed to fetch employee records." });
+  }
+};

package/templates/epms-app/backend-mongodb/controllers/reportController.js

@@ -0,0 +1,57 @@
+import Department from "../models/Department.js";
+import Employee from "../models/Employee.js";
+import Salary from "../models/Salary.js";
+
+const clean = (rows) => rows.map((r) => {
+  const copy = { ...r };
+  delete copy._id;
+  delete copy.__v;
+  return copy;
+});
+
+const monthBounds = (month) => {
+  const start = new Date(`${month}-01T00:00:00`);
+  const end = new Date(start.getFullYear(), start.getMonth() + 1, 0, 23, 59, 59, 999);
+  return { start, end };
+};
+
+export const getReports = async (req, res) => {
+  try {
+    const period = req.query.period || "daily";
+    const date = req.query.date || new Date().toISOString().slice(0, 10);
+    const startDate = req.query.startDate;
+    const endDate = req.query.endDate;
+    const month = req.query.month || date.slice(0, 7);
+
+    let employees;
+    let salaries;
+
+    if (period === "daily") {
+      const start = new Date(`${date}T00:00:00`);
+      const end = new Date(`${date}T23:59:59`);
+      employees = clean(await Employee.find({ hired_date: { $gte: start, $lte: end } }).lean());
+      salaries = clean(await Salary.find({ month_of_payment: month }).lean());
+    } else if (period === "weekly") {
+      if (!startDate || !endDate) {
+        return res.status(400).json({ message: "Start date and end date are required for weekly reports." });
+      }
+      const start = new Date(`${startDate}T00:00:00`);
+      const end = new Date(`${endDate}T23:59:59`);
+      employees = clean(await Employee.find({ hired_date: { $gte: start, $lte: end } }).lean());
+      salaries = clean(
+        await Salary.find({
+          month_of_payment: { $gte: startDate.slice(0, 7), $lte: endDate.slice(0, 7) },
+        }).lean()
+      );
+    } else {
+      const { start, end } = monthBounds(month);
+      employees = clean(await Employee.find({ hired_date: { $gte: start, $lte: end } }).lean());
+      salaries = clean(await Salary.find({ month_of_payment: month }).lean());
+    }
+
+    const departments = clean(await Department.find().lean());
+    return res.json({ period, reports: { employees, departments, salaries } });
+  } catch {
+    return res.status(500).json({ message: "Failed to generate reports." });
+  }
+};

package/templates/epms-app/backend-mongodb/controllers/salaryController.js

@@ -0,0 +1,101 @@
+import Salary from "../models/Salary.js";
+
+const calcNet = (gross, deduction) => {
+  const g = Number(gross);
+  const d = Number(deduction);
+  if (Number.isNaN(g) || Number.isNaN(d)) return null;
+  return Math.round((g - d) * 100) / 100;
+};
+
+export const create = async (req, res) => {
+  try {
+    if (req.body.grossSalary === undefined || req.body.grossSalary === "") {
+      return res.status(400).json({ message: "Gross Salary is required." });
+    }
+    if (req.body.totalDeduction === undefined || req.body.totalDeduction === "") {
+      return res.status(400).json({ message: "Total Deduction is required." });
+    }
+    if (!req.body.monthOfPayment) {
+      return res.status(400).json({ message: "Month of Payment is required." });
+    }
+    if (!req.body.employeeNumber) {
+      return res.status(400).json({ message: "Employee is required." });
+    }
+    const netSalary = calcNet(req.body.grossSalary, req.body.totalDeduction);
+    if (netSalary === null) {
+      return res.status(400).json({ message: "Invalid salary amounts." });
+    }
+    await Salary.create({
+      gross_salary: req.body.grossSalary,
+      total_deduction: req.body.totalDeduction,
+      net_salary: netSalary,
+      month_of_payment: req.body.monthOfPayment,
+      employee_number: req.body.employeeNumber,
+    });
+    return res.status(201).json({ message: "Salary added successfully." });
+  } catch (error) {
+    if (error.code === 11000) {
+      return res.status(409).json({ message: "Salary already exists." });
+    }
+    return res.status(500).json({ message: "Failed to add salary." });
+  }
+};
+
+export const getAll = async (_req, res) => {
+  try {
+    const rows = await Salary.find().sort({ salary_id: -1 }).lean();
+    return res.json(rows.map((r) => { const { _id, __v, ...rest } = r; return rest; }));
+  } catch {
+    return res.status(500).json({ message: "Failed to fetch salary records." });
+  }
+};
+
+export const update = async (req, res) => {
+  try {
+    if (req.body.grossSalary === undefined || req.body.grossSalary === "") {
+      return res.status(400).json({ message: "Gross Salary is required." });
+    }
+    if (req.body.totalDeduction === undefined || req.body.totalDeduction === "") {
+      return res.status(400).json({ message: "Total Deduction is required." });
+    }
+    if (!req.body.monthOfPayment) {
+      return res.status(400).json({ message: "Month of Payment is required." });
+    }
+    if (!req.body.employeeNumber) {
+      return res.status(400).json({ message: "Employee is required." });
+    }
+    const netSalary = calcNet(req.body.grossSalary, req.body.totalDeduction);
+    if (netSalary === null) {
+      return res.status(400).json({ message: "Invalid salary amounts." });
+    }
+    const updated = await Salary.findOneAndUpdate(
+      { salary_id: Number(req.params.id) },
+      {
+        gross_salary: req.body.grossSalary,
+        total_deduction: req.body.totalDeduction,
+        net_salary: netSalary,
+        month_of_payment: req.body.monthOfPayment,
+        employee_number: req.body.employeeNumber,
+      },
+      { new: true }
+    );
+    if (!updated) {
+      return res.status(404).json({ message: "Salary not found." });
+    }
+    return res.json({ message: "Salary updated successfully." });
+  } catch {
+    return res.status(500).json({ message: "Failed to update salary." });
+  }
+};
+
+export const remove = async (req, res) => {
+  try {
+    const deleted = await Salary.findOneAndDelete({ salary_id: Number(req.params.id) });
+    if (!deleted) {
+      return res.status(404).json({ message: "Salary not found." });
+    }
+    return res.json({ message: "Salary deleted successfully." });
+  } catch {
+    return res.status(500).json({ message: "Failed to delete salary." });
+  }
+};

package/templates/epms-app/backend-mongodb/middleware/auth.js

@@ -0,0 +1,16 @@
+import jwt from "jsonwebtoken";
+
+const auth = (req, res, next) => {
+  const header = req.headers.authorization;
+  if (!header || !header.startsWith("Bearer ")) {
+    return res.status(401).json({ message: "Authentication required." });
+  }
+  try {
+    req.user = jwt.verify(header.split(" ")[1], process.env.JWT_SECRET || "exam_secret");
+    next();
+  } catch {
+    return res.status(401).json({ message: "Invalid or expired token." });
+  }
+};
+
+export default auth;

package/templates/epms-app/backend-mongodb/models/Counter.js

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+
+const counterSchema = new mongoose.Schema({
+  _id: { type: String, required: true },
+  seq: { type: Number, default: 0 },
+});
+
+counterSchema.statics.getNext = async function (name) {
+  const doc = await this.findByIdAndUpdate(name, { $inc: { seq: 1 } }, { new: true, upsert: true });
+  return doc.seq;
+};
+
+export default mongoose.model("Counter", counterSchema);

package/templates/epms-app/backend-mongodb/models/Department.js

@@ -0,0 +1,11 @@
+import mongoose from "mongoose";
+
+
+const schema = new mongoose.Schema({
+  department_code: { type: String, required: true, unique: true },
+  department_name: { type: String, required: true }
+}, { collection: "departments" });
+
+
+
+export default mongoose.model("Department", schema);

package/templates/epms-app/backend-mongodb/models/Employee.js

@@ -0,0 +1,18 @@
+import mongoose from "mongoose";
+
+
+const schema = new mongoose.Schema({
+  employee_number: { type: String, required: true, unique: true },
+  first_name: { type: String, required: true },
+  last_name: { type: String, required: true },
+  address: { type: String, required: true },
+  position: { type: String, required: true },
+  telephone: { type: String, required: true },
+  gender: { type: String, required: true },
+  hired_date: { type: Date, required: true },
+  department_code: { type: String, required: true }
+}, { collection: "employees" });
+
+
+
+export default mongoose.model("Employee", schema);

package/templates/epms-app/backend-mongodb/models/Salary.js

@@ -0,0 +1,19 @@
+import mongoose from "mongoose";
+import Counter from "./Counter.js";
+
+const schema = new mongoose.Schema({
+  salary_id: { type: Number, unique: true },
+  gross_salary: { type: Number, required: true },
+  total_deduction: { type: Number, required: true },
+  net_salary: { type: Number, required: true },
+  month_of_payment: { type: String, required: true },
+  employee_number: { type: String, required: true }
+}, { collection: "salaries" });
+
+schema.pre("save", async function () {
+  if (this.isNew && (this.salary_id === undefined || this.salary_id === null)) {
+    this.salary_id = await Counter.getNext("salary_id");
+  }
+});
+
+export default mongoose.model("Salary", schema);

package/templates/epms-app/backend-mongodb/models/User.js

@@ -0,0 +1,9 @@
+import mongoose from "mongoose";
+
+const userSchema = new mongoose.Schema({
+  username: { type: String, required: true, unique: true, trim: true },
+  email: { type: String, required: true, unique: true, lowercase: true, trim: true },
+  password: { type: String, required: true },
+});
+
+export default mongoose.model("User", userSchema);