create-jinmankn-app 1.0.12 → 1.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-jinmankn-app",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "type": "module",
   "bin": {
     "create-jinmankn-app": "./bin/index.js"

package/templates/EPMS(Employee Payroll Managment System)/package-lock.json

@@ -0,0 +1,13 @@
+{
+  "name": "jinman-blueprint",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "jinman-blueprint",
+      "version": "1.0.0",
+      "license": "ISC"
+    }
+  }
+}

package/templates/HRMS (reba kuri iyi bro)/README.md

@@ -0,0 +1 @@
+umvax mbaye nshyizeho iyi reka mbanze nkore test numona i dakora fresh uze gusubiroho after 10min ndaba naya updatinze

package/templates/HRMS (reba kuri iyi bro)/backend/config/db.js

@@ -0,0 +1,12 @@
+const mongoose = require('mongoose');
+
+const connectDB = async () => {
+  try {
+    await mongoose.connect('mongodb://localhost:27017/HRMS');
+    console.log('MongoDB connected');
+  } catch (error) {
+    console.error('MongoDB connection error:', error);
+  }
+};
+
+module.exports = connectDB;

package/templates/HRMS (reba kuri iyi bro)/backend/controllers/authController.js

@@ -0,0 +1,138 @@
+const bcrypt = require('bcrypt');
+const User = require('../models/User');
+const Employee = require('../models/Employee');
+
+function formatUser(user) {
+  return {
+    id: user._id,
+    name: user.name,
+    email: user.email,
+    role: user.role || 'user',
+    employee: user.employee || null,
+  };
+}
+
+exports.register = async (req, res) => {
+  try {
+    const { name, email, password } = req.body;
+
+    if (!name || !email || !password) {
+      return res.status(400).json({ message: 'Name, email, and password are required' });
+    }
+
+    if (password.length < 6) {
+      return res.status(400).json({ message: 'Password must be at least 6 characters' });
+    }
+
+    const existing = await User.findOne({ email: email.trim().toLowerCase() });
+    if (existing) {
+      return res.status(409).json({ message: 'Email already registered' });
+    }
+
+    const userCount = await User.countDocuments();
+    if (userCount > 0) {
+      return res.status(403).json({ message: 'Registration closed. Ask an admin to create an account.' });
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+    const user = await User.create({
+      name: name.trim(),
+      email: email.trim().toLowerCase(),
+      password: hashedPassword,
+      role: 'admin',
+    });
+
+    req.session.userId = user._id;
+
+    res.status(201).json({
+      user: formatUser(user),
+    });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.createUser = async (req, res) => {
+  try {
+    const { employeeId, password } = req.body;
+
+    if (!employeeId || !password) {
+      return res.status(400).json({ message: 'Employee and password are required' });
+    }
+
+    const employee = await Employee.findById(employeeId);
+    if (!employee) {
+      return res.status(404).json({ message: 'Employee not found' });
+    }
+
+    const existing = await User.findOne({ email: employee.email });
+    if (existing) {
+      return res.status(409).json({ message: 'A user already exists for this employee' });
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+    const user = await User.create({
+      name: `${employee.firstName} ${employee.lastName}`.trim(),
+      email: employee.email,
+      password: hashedPassword,
+      role: 'user',
+      employee: employee._id,
+    });
+
+    res.status(201).json({
+      user: formatUser(user),
+    });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.login = async (req, res) => {
+  try {
+    const { email, password } = req.body;
+
+    if (!email || !password) {
+      return res.status(400).json({ message: 'Email and password are required' });
+    }
+
+    const user = await User.findOne({ email: email.trim().toLowerCase() });
+    if (!user) {
+      return res.status(401).json({ message: 'Invalid email or password' });
+    }
+
+    const match = await bcrypt.compare(password, user.password);
+    if (!match) {
+      return res.status(401).json({ message: 'Invalid email or password' });
+    }
+
+    req.session.userId = user._id;
+
+    res.json({
+      user: formatUser(user),
+    });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.getMe = async (req, res) => {
+  try {
+    res.json({ user: formatUser(req.user) });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.logout = async (req, res) => {
+  try {
+    req.session.destroy((err) => {
+      if (err) {
+        return res.status(500).json({ message: 'Logout failed' });
+      }
+      res.clearCookie('connect.sid');
+      res.json({ message: 'Logged out successfully' });
+    });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};

package/templates/HRMS (reba kuri iyi bro)/backend/controllers/departmentController.js

@@ -0,0 +1,74 @@
+const Department = require('../models/Department');
+
+exports.addDepartment = async (req, res) => {
+  try {
+    const { departmentName } = req.body;
+
+    if (!departmentName) {
+      return res.status(400).json({ message: 'Department name is required' });
+    }
+
+    const existing = await Department.findOne({ departmentName: departmentName.trim() });
+    if (existing) {
+      return res.status(409).json({ message: 'Department already exists' });
+    }
+
+    const dept = await Department.create({ departmentName: departmentName.trim() });
+    res.status(201).json(dept);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.getDepartments = async (req, res) => {
+  try {
+    const departments = await Department.find();
+    res.json(departments);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.updateDepartment = async (req, res) => {
+  try {
+    const { departmentName } = req.body;
+
+    if (!departmentName) {
+      return res.status(400).json({ message: 'Department name is required' });
+    }
+
+    const department = await Department.findById(req.params.id);
+    if (!department) {
+      return res.status(404).json({ message: 'Department not found' });
+    }
+
+    const existing = await Department.findOne({
+      departmentName: departmentName.trim(),
+      _id: { $ne: req.params.id },
+    });
+    if (existing) {
+      return res.status(409).json({ message: 'Department already exists' });
+    }
+
+    department.departmentName = departmentName.trim();
+    await department.save();
+
+    res.json(department);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.deleteDepartment = async (req, res) => {
+  try {
+    const department = await Department.findById(req.params.id);
+    if (!department) {
+      return res.status(404).json({ message: 'Department not found' });
+    }
+
+    await Department.findByIdAndDelete(req.params.id);
+    res.json({ message: 'Department deleted successfully' });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};

package/templates/HRMS (reba kuri iyi bro)/backend/controllers/employeeController.js

@@ -0,0 +1,204 @@
+const Employee = require('../models/Employee');
+const Department = require('../models/Department');
+const Position = require('../models/Position');
+const User = require('../models/User');
+
+exports.addEmployee = async (req, res) => {
+  try {
+    const {
+      userName,
+      firstName,
+      lastName,
+      email,
+      gender,
+      dateOfBirth,
+      telephone,
+      address,
+      hireDate,
+      status,
+      department,
+      position,
+    } = req.body;
+
+    if (
+      !firstName ||
+      !lastName ||
+      !email ||
+      !gender ||
+      !dateOfBirth ||
+      !telephone ||
+      !address ||
+      !hireDate ||
+      !status ||
+      !department ||
+      !position
+    ) {
+      return res.status(400).json({ message: 'All employee fields are required' });
+    }
+
+    const existing = await Employee.findOne({ email: email.toLowerCase() });
+    if (existing) {
+      return res.status(409).json({ message: 'Employee email already exists' });
+    }
+
+    const departmentExists = await Department.findById(department);
+    if (!departmentExists) {
+      return res.status(404).json({ message: 'Department not found' });
+    }
+
+    const positionExists = await Position.findById(position);
+    if (!positionExists) {
+      return res.status(404).json({ message: 'Position not found' });
+    }
+
+    const employee = await Employee.create({
+      userName,
+      firstName: firstName.trim(),
+      lastName: lastName.trim(),
+      email: email.toLowerCase(),
+      gender,
+      dateOfBirth,
+      telephone: telephone.trim(),
+      address: address.trim(),
+      hireDate,
+      status,
+      department,
+      position,
+    });
+
+    if (email) {
+      const user = await User.findOne({ email: email.toLowerCase() });
+      if (user) {
+        user.employee = employee._id;
+        await user.save();
+      }
+    }
+
+    res.status(201).json(employee);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.getEmployees = async (req, res) => {
+  try {
+    const employees = await Employee.find().populate('department position');
+    res.json(employees);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.getEmployee = async (req, res) => {
+  try {
+    const employee = await Employee.findById(req.params.id).populate('department position');
+    if (!employee) {
+      return res.status(404).json({ message: 'Employee not found' });
+    }
+    res.json(employee);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.updateEmployee = async (req, res) => {
+  try {
+    const employee = await Employee.findById(req.params.id);
+    if (!employee) {
+      return res.status(404).json({ message: 'Employee not found' });
+    }
+
+    const {
+      userName,
+      firstName,
+      lastName,
+      email,
+      gender,
+      dateOfBirth,
+      telephone,
+      address,
+      hireDate,
+      status,
+      department,
+      position,
+    } = req.body;
+
+    if (
+      !firstName ||
+      !lastName ||
+      !email ||
+      !gender ||
+      !dateOfBirth ||
+      !telephone ||
+      !address ||
+      !hireDate ||
+      !status ||
+      !department ||
+      !position
+    ) {
+      return res.status(400).json({ message: 'All employee fields are required' });
+    }
+
+    const existing = await Employee.findOne({
+      email: email.toLowerCase(),
+      _id: { $ne: req.params.id },
+    });
+    if (existing) {
+      return res.status(409).json({ message: 'Employee email already exists' });
+    }
+
+    const departmentExists = await Department.findById(department);
+    if (!departmentExists) {
+      return res.status(404).json({ message: 'Department not found' });
+    }
+
+    const positionExists = await Position.findById(position);
+    if (!positionExists) {
+      return res.status(404).json({ message: 'Position not found' });
+    }
+
+    const oldEmail = employee.email;
+
+    employee.userName = userName;
+    employee.firstName = firstName.trim();
+    employee.lastName = lastName.trim();
+    employee.email = email.toLowerCase();
+    employee.gender = gender;
+    employee.dateOfBirth = dateOfBirth;
+    employee.telephone = telephone.trim();
+    employee.address = address.trim();
+    employee.hireDate = hireDate;
+    employee.status = status;
+    employee.department = department;
+    employee.position = position;
+
+    await employee.save();
+
+    if (oldEmail !== email.toLowerCase()) {
+      const user = await User.findOne({ email: oldEmail });
+      if (user) {
+        user.email = email.toLowerCase();
+        await user.save();
+      }
+    }
+
+    const updatedEmployee = await Employee.findById(req.params.id).populate('department position');
+    res.json(updatedEmployee);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.deleteEmployee = async (req, res) => {
+  try {
+    const employee = await Employee.findById(req.params.id);
+    if (!employee) {
+      return res.status(404).json({ message: 'Employee not found' });
+    }
+
+    await Employee.findByIdAndDelete(req.params.id);
+    res.json({ message: 'Employee deleted successfully' });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};

package/templates/HRMS (reba kuri iyi bro)/backend/controllers/positionController.js

@@ -0,0 +1,78 @@
+const Position = require('../models/Position');
+
+exports.addPosition = async (req, res) => {
+  try {
+    const { posName, requiredQualification } = req.body;
+
+    if (!posName || !requiredQualification) {
+      return res.status(400).json({ message: 'Position name and qualification are required' });
+    }
+
+    const existing = await Position.findOne({ posName: posName.trim() });
+    if (existing) {
+      return res.status(409).json({ message: 'Position already exists' });
+    }
+
+    const position = await Position.create({
+      posName: posName.trim(),
+      requiredQualification: requiredQualification.trim(),
+    });
+    res.status(201).json(position);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.getPositions = async (req, res) => {
+  try {
+    const positions = await Position.find();
+    res.json(positions);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.updatePosition = async (req, res) => {
+  try {
+    const { posName, requiredQualification } = req.body;
+
+    if (!posName || !requiredQualification) {
+      return res.status(400).json({ message: 'Position name and qualification are required' });
+    }
+
+    const position = await Position.findById(req.params.id);
+    if (!position) {
+      return res.status(404).json({ message: 'Position not found' });
+    }
+
+    const existing = await Position.findOne({
+      posName: posName.trim(),
+      _id: { $ne: req.params.id },
+    });
+    if (existing) {
+      return res.status(409).json({ message: 'Position already exists' });
+    }
+
+    position.posName = posName.trim();
+    position.requiredQualification = requiredQualification.trim();
+    await position.save();
+
+    res.json(position);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.deletePosition = async (req, res) => {
+  try {
+    const position = await Position.findById(req.params.id);
+    if (!position) {
+      return res.status(404).json({ message: 'Position not found' });
+    }
+
+    await Position.findByIdAndDelete(req.params.id);
+    res.json({ message: 'Position deleted successfully' });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};

package/templates/HRMS (reba kuri iyi bro)/backend/controllers/reportController.js

@@ -0,0 +1,45 @@
+const Employee = require('../models/Employee');
+
+const ON_LEAVE_STATUS = 'on leave';
+
+exports.getOnLeaveByDepartment = async (req, res) => {
+  try {
+    const onLeaveEmployees = await Employee.find({ status: ON_LEAVE_STATUS })
+      .populate('department position')
+      .sort({ lastName: 1, firstName: 1 });
+
+    const byDepartment = {};
+
+    onLeaveEmployees.forEach((employee) => {
+      const deptName = employee.department?.departmentName || 'Unassigned';
+      if (!byDepartment[deptName]) {
+        byDepartment[deptName] = [];
+      }
+      byDepartment[deptName].push({
+        id: employee._id,
+        firstName: employee.firstName,
+        lastName: employee.lastName,
+        email: employee.email,
+        telephone: employee.telephone,
+        position: employee.position?.posName || 'N/A',
+        status: employee.status,
+      });
+    });
+
+    const departments = Object.keys(byDepartment)
+      .sort()
+      .map((departmentName) => ({
+        departmentName,
+        employees: byDepartment[departmentName],
+        count: byDepartment[departmentName].length,
+      }));
+
+    res.json({
+      reportTitle: 'Employee Status Report — On Leave',
+      totalOnLeave: onLeaveEmployees.length,
+      departments,
+    });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};

package/templates/HRMS (reba kuri iyi bro)/backend/middleware/auth.js

@@ -0,0 +1,28 @@
+
+const User = require('../models/User');
+
+exports.protect = async (req, res, next) => {
+  try {
+    if (!req.session || !req.session.userId) {
+      return res.status(401).json({ message: 'Not authorized' });
+    }
+
+    const user = await User.findById(req.session.userId).select('-password');
+
+    if (!user) {
+      return res.status(401).json({ message: 'Not authorized' });
+    } 
+
+    req.user = user;
+    next();
+  } catch (err) {
+    return res.status(401).json({ message: 'Not authorized' });
+  }
+};
+
+exports.admin = (req, res, next) => {
+  if (!req.user || req.user.role !== 'admin') {
+    return res.status(403).json({ message: 'Admin access required' });
+  }
+  next();
+};

package/templates/HRMS (reba kuri iyi bro)/backend/models/Department.js

@@ -0,0 +1,15 @@
+const mongoose = require('mongoose');
+
+const departmentSchema = new mongoose.Schema(
+  {
+    departmentName: {
+      type: String,
+      required: true,
+      unique: true,
+      trim: true,
+    },
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model('Department', departmentSchema);

package/templates/HRMS (reba kuri iyi bro)/backend/models/Employee.js

@@ -0,0 +1,73 @@
+const mongoose = require('mongoose');
+
+const EMPLOYEE_STATUSES = ['on leave', 'left', 'blacklisted', 'deceased', 'on mission'];
+
+const employeeSchema = new mongoose.Schema(
+  {
+    userName: {
+      type: String,
+      trim: true,
+    },
+    firstName: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    lastName: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+      lowercase: true,
+      trim: true,
+    },
+    gender: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    dateOfBirth: {
+      type: Date,
+      required: true,
+    },
+    telephone: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    address: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    hireDate: {
+      type: Date,
+      required: true,
+    },
+    status: {
+      type: String,
+      required: true,
+      enum: EMPLOYEE_STATUSES,
+      default: 'on mission',
+    },
+    department: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Department',
+      required: true,
+    },
+    position: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Position',
+      required: true,
+    },
+  },
+  { timestamps: true }
+);
+
+employeeSchema.statics.STATUSES = EMPLOYEE_STATUSES;
+
+module.exports = mongoose.model('Employee', employeeSchema);