alpe-temp 1.0.2 → 1.0.4

package/backend-project/src/modules/auth/user.model.js

@@ -1,41 +1,18 @@
-const { Schema, model } = require('mongoose');
+const mongoose = require('mongoose');
 
-const userSchema = new Schema(
-  {
-    name: {
-      type: String,
-      required: true,
-      trim: true,
-    },
-    email: {
-      type: String,
-      required: true,
-      unique: true,
-      lowercase: true,
-      trim: true,
-    },
-    password: {
-      type: String,
-      required: true,
-    },
-    role: {
-      type: String,
-      enum: ['user', 'admin'],
-      default: 'user',
-    },
-  },
-  { timestamps: true }
-);
+const userSchema = new mongoose.Schema({
+  userName: { type: String, required: true, unique: true, trim: true },
+  password: { type: String, required: true },
+  employee: { type: mongoose.Schema.Types.ObjectId, ref: 'Employee' },
+}, { timestamps: true });
 
-// Never expose the password hash in query results
 userSchema.methods.toSafeObject = function () {
   return {
-    id:        this._id,
-    name:      this.name,
-    email:     this.email,
-    role:      this.role,
+    id: this._id,
+    userName: this.userName,
+    employee: this.employee,
     createdAt: this.createdAt,
   };
 };
 
-module.exports = model('User', userSchema);
+module.exports = mongoose.model('User', userSchema);

package/backend-project/src/modules/department/department.controller.js

@@ -10,7 +10,6 @@ const DepartmentController = {
       return res_.error(res, err.message, err.statusCode || 500);
     }
   },
-
   async list(req, res) {
     try {
       const departments = await DepartmentService.list();
@@ -19,7 +18,6 @@ const DepartmentController = {
       return res_.error(res, err.message, 500);
     }
   },
-
   async getById(req, res) {
     try {
       const dept = await DepartmentService.getById(req.params.id);
@@ -29,7 +27,6 @@ const DepartmentController = {
       return res_.error(res, err.message, 500);
     }
   },
-
   async update(req, res) {
     try {
       const dept = await DepartmentService.update(req.params.id, req.body);
@@ -39,7 +36,6 @@ const DepartmentController = {
       return res_.error(res, err.message, 500);
     }
   },
-
   async remove(req, res) {
     try {
       const dept = await DepartmentService.remove(req.params.id);

package/backend-project/src/modules/department/department.model.js

@@ -1,10 +1,7 @@
 const mongoose = require('mongoose');
 
 const departmentSchema = new mongoose.Schema({
-  departmentCode: { type: String, required: true, unique: true, trim: true },
-  departmentName: { type: String, required: true, trim: true },
-  grossSalary:    { type: Number, required: true },
-  totalDeduction: { type: Number, required: true, default: 0 },
+  departName: { type: String, required: true, unique: true, trim: true },
 }, { timestamps: true });
 
 module.exports = mongoose.model('Department', departmentSchema);

package/backend-project/src/modules/department/department.routes.js

@@ -3,7 +3,6 @@ const DepartmentController = require('./department.controller');
 const { authenticate } = require('../../middleware/auth.middleware');
 
 const router = Router();
-
 router.use(authenticate);
 
 router.post('/',    DepartmentController.create);

package/backend-project/src/modules/department/department.service.js

@@ -4,23 +4,15 @@ const DepartmentService = {
   async create(data) {
     return Department.create(data);
   },
-
   async list() {
-    return Department.find().sort({ departmentCode: 1 });
-  },
-
-  async getByCode(code) {
-    return Department.findOne({ departmentCode: code });
+    return Department.find().sort({ departName: 1 });
   },
-
   async getById(id) {
     return Department.findById(id);
   },
-
   async update(id, data) {
     return Department.findByIdAndUpdate(id, data, { new: true });
   },
-
   async remove(id) {
     return Department.findByIdAndDelete(id);
   },

package/backend-project/src/modules/employee/employee.controller.js

@@ -13,7 +13,8 @@ const EmployeeController = {
 
   async list(req, res) {
     try {
-      const employees = await EmployeeService.list();
+      const { search } = req.query;
+      const employees = await EmployeeService.list(search);
       return res_.success(res, { employees });
     } catch (err) {
       return res_.error(res, err.message, 500);
@@ -49,15 +50,6 @@ const EmployeeController = {
       return res_.error(res, err.message, 500);
     }
   },
-
-  async count(req, res) {
-    try {
-      const count = await EmployeeService.count();
-      return res_.success(res, { count });
-    } catch (err) {
-      return res_.error(res, err.message, 500);
-    }
-  },
 };
 
 module.exports = EmployeeController;

package/backend-project/src/modules/employee/employee.model.js

@@ -1,15 +1,21 @@
 const mongoose = require('mongoose');
 
 const employeeSchema = new mongoose.Schema({
-  employeeNumber: { type: String, required: true, unique: true, trim: true },
-  firstName:      { type: String, required: true, trim: true },
-  lastName:       { type: String, required: true, trim: true },
-  position:       { type: String, required: true, trim: true },
-  address:        { type: String, trim: true },
-  telephone:      { type: String, trim: true },
-  gender:         { type: String, enum: ['male', 'female'], required: true },
-  hiredDate:      { type: Date, required: true },
-  department:     { type: mongoose.Schema.Types.ObjectId, ref: 'Department' },
+  empFirstName: { type: String, required: true, trim: true },
+  empLastName: { type: String, required: true, trim: true },
+  empGender: { type: String, enum: ['male', 'female'], required: true },
+  empDateOfBirth: { type: Date },
+  empEmail: { type: String, trim: true, lowercase: true },
+  empTelephone: { type: String, trim: true },
+  empAddress: { type: String, trim: true },
+  empHireDate: { type: Date, required: true },
+  empStatus: {
+    type: String,
+    enum: ['on leave', 'left', 'blacklisted', 'deceased', 'on mission'],
+    default: 'on mission',
+  },
+  department: { type: mongoose.Schema.Types.ObjectId, ref: 'Department' },
+  position: { type: mongoose.Schema.Types.ObjectId, ref: 'Position' },
 }, { timestamps: true });
 
 module.exports = mongoose.model('Employee', employeeSchema);

package/backend-project/src/modules/employee/employee.routes.js

@@ -3,14 +3,12 @@ const EmployeeController = require('./employee.controller');
 const { authenticate } = require('../../middleware/auth.middleware');
 
 const router = Router();
-
 router.use(authenticate);
 
-router.post('/',    EmployeeController.create);
-router.get('/',     EmployeeController.list);
-router.get('/count', EmployeeController.count);
-router.get('/:id',  EmployeeController.getById);
-router.put('/:id',  EmployeeController.update);
+router.post('/',   EmployeeController.create);
+router.get('/',    EmployeeController.list);
+router.get('/:id', EmployeeController.getById);
+router.put('/:id', EmployeeController.update);
 router.delete('/:id', EmployeeController.remove);
 
 module.exports = router;

package/backend-project/src/modules/employee/employee.service.js

@@ -3,19 +3,34 @@ const Employee = require('./employee.model');
 const EmployeeService = {
   async create(data) {
     const emp = await Employee.create(data);
-    return Employee.populate(emp, { path: 'department' });
+    return Employee.populate(emp, [{ path: 'department' }, { path: 'position' }]);
   },
 
-  async list() {
-    return Employee.find().populate('department').sort({ createdAt: -1 });
+  async list(search) {
+    const filter = {};
+    if (search) {
+      const regex = new RegExp(search, 'i');
+      filter.$or = [
+        { empFirstName: regex },
+        { empLastName: regex },
+        { empEmail: regex },
+        { empTelephone: regex },
+      ];
+    }
+    return Employee.find(filter)
+      .populate('department')
+      .populate('position')
+      .sort({ createdAt: -1 });
   },
 
   async getById(id) {
-    return Employee.findById(id).populate('department');
+    return Employee.findById(id).populate('department').populate('position');
   },
 
   async update(id, data) {
-    return Employee.findByIdAndUpdate(id, data, { new: true }).populate('department');
+    return Employee.findByIdAndUpdate(id, data, { new: true })
+      .populate('department')
+      .populate('position');
   },
 
   async remove(id) {

package/backend-project/src/modules/position/position.controller.js

@@ -0,0 +1,50 @@
+const PositionService = require('./position.service');
+const res_ = require('../../utils/response');
+
+const PositionController = {
+  async create(req, res) {
+    try {
+      const pos = await PositionService.create(req.body);
+      return res_.created(res, pos, 'Position created');
+    } catch (err) {
+      return res_.error(res, err.message, err.statusCode || 500);
+    }
+  },
+  async list(req, res) {
+    try {
+      const positions = await PositionService.list();
+      return res_.success(res, { positions });
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+  async getById(req, res) {
+    try {
+      const pos = await PositionService.getById(req.params.id);
+      if (!pos) return res_.notFound(res, 'Position not found');
+      return res_.success(res, pos);
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+  async update(req, res) {
+    try {
+      const pos = await PositionService.update(req.params.id, req.body);
+      if (!pos) return res_.notFound(res, 'Position not found');
+      return res_.success(res, pos, 'Position updated');
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+  async remove(req, res) {
+    try {
+      const pos = await PositionService.remove(req.params.id);
+      if (!pos) return res_.notFound(res, 'Position not found');
+      return res_.success(res, null, 'Position deleted');
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+};
+
+module.exports = PositionController;

package/backend-project/src/modules/position/position.model.js

@@ -0,0 +1,8 @@
+const mongoose = require('mongoose');
+
+const positionSchema = new mongoose.Schema({
+  posName: { type: String, required: true, unique: true, trim: true },
+  requiredQualification: { type: String, trim: true },
+}, { timestamps: true });
+
+module.exports = mongoose.model('Position', positionSchema);

package/backend-project/src/modules/position/position.routes.js

@@ -0,0 +1,14 @@
+const { Router } = require('express');
+const PositionController = require('./position.controller');
+const { authenticate } = require('../../middleware/auth.middleware');
+
+const router = Router();
+router.use(authenticate);
+
+router.post('/',    PositionController.create);
+router.get('/',     PositionController.list);
+router.get('/:id',  PositionController.getById);
+router.put('/:id',  PositionController.update);
+router.delete('/:id', PositionController.remove);
+
+module.exports = router;

package/backend-project/src/modules/position/position.service.js

@@ -0,0 +1,21 @@
+const Position = require('./position.model');
+
+const PositionService = {
+  async create(data) {
+    return Position.create(data);
+  },
+  async list() {
+    return Position.find().sort({ posName: 1 });
+  },
+  async getById(id) {
+    return Position.findById(id);
+  },
+  async update(id, data) {
+    return Position.findByIdAndUpdate(id, data, { new: true });
+  },
+  async remove(id) {
+    return Position.findByIdAndDelete(id);
+  },
+};
+
+module.exports = PositionService;

package/backend-project/src/modules/reports/reports.controller.js

@@ -1,37 +1,172 @@
-const SalaryService = require('../salary/salary.service');
+const ExcelJS = require('exceljs');
+const Employee = require('../employee/employee.model');
 const res_ = require('../../utils/response');
 
 const ReportsController = {
-  async monthlyPayroll(req, res) {
+  async employeesOnLeave(req, res) {
     try {
-      const { month } = req.query;
-      const salaries = await SalaryService.getMonthlyReport(month);
-
-      const payroll = salaries
-        .filter(s => s.employee)
-        .map(s => ({
-          _id: s._id,
-          firstName: s.employee.firstName,
-          lastName: s.employee.lastName,
-          position: s.employee.position,
-          departmentName: s.employee.department?.departmentName || '—',
-          grossSalary: s.grossSalary,
-          totalDeduction: s.totalDeduction,
-          netSalary: s.netSalary,
-          month: s.month,
-        }));
-
-      return res_.success(res, { payroll });
+      const employees = await Employee.find({ empStatus: 'on leave' })
+        .populate('department')
+        .populate('position')
+        .sort({ 'department.departName': 1, empFirstName: 1 });
+
+      const grouped = {};
+      for (const emp of employees) {
+        const deptName = emp.department ? emp.department.departName : 'Unassigned';
+        if (!grouped[deptName]) grouped[deptName] = [];
+        grouped[deptName].push(emp);
+      }
+
+      return res_.success(res, {
+        departments: grouped,
+        total: employees.length,
+      });
     } catch (err) {
       return res_.error(res, err.message, 500);
     }
   },
 
-  async departments(req, res) {
+  async employeesOnLeaveExcel(req, res) {
     try {
-      const Department = require('../department/department.model');
-      const departments = await Department.find().sort({ departmentCode: 1 });
-      return res_.success(res, { departments });
+      const employees = await Employee.find({ empStatus: 'on leave' })
+        .populate('department')
+        .populate('position')
+        .sort({ 'department.departName': 1, empFirstName: 1 });
+
+      const workbook = new ExcelJS.Workbook();
+      workbook.creator = 'DAB Enterprise HRMS';
+      workbook.created = new Date();
+
+      const ws = workbook.addWorksheet('Employees on Leave', {
+        pageSetup: { orientation: 'landscape', fitToPage: true },
+      });
+
+      const primaryColor = '1F4E79';
+      const accentColor = 'D6E4F0';
+      const borderStyle = {
+        style: 'thin',
+        color: { argb: 'B0B0B0' },
+      };
+      const allBorders = {
+        top: borderStyle,
+        bottom: borderStyle,
+        left: borderStyle,
+        right: borderStyle,
+      };
+
+      const mergeAndStyle = (ws, rowNum, colStart, colEnd, value, opts = {}) => {
+        const cell = ws.getCell(`${colStart}${rowNum}`);
+        if (colStart !== colEnd) ws.mergeCells(`${colStart}${rowNum}:${colEnd}${rowNum}`);
+        cell.value = value;
+        cell.font = { name: 'Calibri', size: opts.fontSize || 11, bold: opts.bold || false, color: opts.color ? { argb: opts.color } : undefined };
+        cell.alignment = { vertical: 'middle', horizontal: opts.align || 'left', wrapText: opts.wrap || false };
+        if (opts.fill) cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: opts.fill } };
+        if (opts.border !== false) cell.border = allBorders;
+        return cell;
+      };
+
+      ws.getColumn(1).width = 5;
+      ws.getColumn(2).width = 16;
+      ws.getColumn(3).width = 16;
+      ws.getColumn(4).width = 12;
+      ws.getColumn(5).width = 14;
+      ws.getColumn(6).width = 20;
+      ws.getColumn(7).width = 16;
+      ws.getColumn(8).width = 20;
+
+      const row1 = ws.getRow(1);
+      row1.height = 36;
+      mergeAndStyle(ws, 1, 'A', 'H', 'DAB Enterprise LTD — Employee Status Report', {
+        fontSize: 16, bold: true, color: 'FFFFFF', fill: primaryColor, align: 'center',
+      });
+
+      ws.getRow(2).height = 22;
+      mergeAndStyle(ws, 2, 'A', 'H', `Employees currently on leave — Generated: ${new Date().toLocaleDateString('en-GB', { day: 'numeric', month: 'long', yyyy: 'numeric' })} at ${new Date().toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' })}`, {
+        fontSize: 10, color: primaryColor, fill: accentColor, align: 'center',
+      });
+
+      let rowNum = 4;
+
+      const grouped = {};
+      for (const emp of employees) {
+        const deptName = emp.department ? emp.department.departName : 'Unassigned';
+        if (!grouped[deptName]) grouped[deptName] = [];
+        grouped[deptName].push(emp);
+      }
+
+      const deptNames = Object.keys(grouped);
+      if (deptNames.length === 0) {
+        mergeAndStyle(ws, rowNum, 'A', 'H', 'No employees are currently on leave.', {
+          fontSize: 11, align: 'center', border: true,
+        });
+      } else {
+        deptNames.forEach((deptName, di) => {
+          const emps = grouped[deptName];
+
+          if (di > 0) rowNum += 1;
+
+          ws.getRow(rowNum).height = 24;
+          mergeAndStyle(ws, rowNum, 'A', 'E', deptName, {
+            fontSize: 12, bold: true, color: 'FFFFFF', fill: primaryColor, align: 'left',
+          });
+          mergeAndStyle(ws, rowNum, 'F', 'H', `${emps.length} employee${emps.length > 1 ? 's' : ''}`, {
+            fontSize: 12, bold: true, color: 'FFFFFF', fill: primaryColor, align: 'right',
+          });
+
+          rowNum += 1;
+          ws.getRow(rowNum).height = 20;
+
+          const headers = ['#', 'First Name', 'Last Name', 'Gender', 'Position', 'Email', 'Phone', 'Department'];
+          const cols = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'];
+          const headerFill = '2E75B6';
+          headers.forEach((h, i) => {
+            mergeAndStyle(ws, rowNum, cols[i], cols[i], h, {
+              fontSize: 10, bold: true, color: 'FFFFFF', fill: headerFill, align: 'center',
+            });
+          });
+
+          emps.forEach((emp, idx) => {
+            rowNum += 1;
+            ws.getRow(rowNum).height = 20;
+            const rowFill = idx % 2 === 0 ? 'F2F7FB' : undefined;
+
+            const data = [
+              (idx + 1).toString(),
+              emp.empFirstName || '',
+              emp.empLastName || '',
+              emp.empGender ? emp.empGender.charAt(0).toUpperCase() + emp.empGender.slice(1) : '',
+              emp.position ? emp.position.posName : '\u2014',
+              emp.empEmail || '\u2014',
+              emp.empTelephone || '\u2014',
+              emp.department ? emp.department.departName : 'Unassigned',
+            ];
+
+            data.forEach((val, i) => {
+              mergeAndStyle(ws, rowNum, cols[i], cols[i], val, {
+                fontSize: 10, fill: rowFill, align: i === 0 ? 'center' : 'left',
+              });
+            });
+          });
+        });
+
+        rowNum += 2;
+        ws.getRow(rowNum).height = 22;
+        mergeAndStyle(ws, rowNum, 'A', 'H', `Total employees on leave: ${employees.length}`, {
+          fontSize: 11, bold: true, color: primaryColor, fill: accentColor, align: 'right',
+        });
+
+        rowNum += 2;
+        ws.getRow(rowNum).height = 18;
+        mergeAndStyle(ws, rowNum, 'A', 'H', 'Report generated by DAB Enterprise HRMS System', {
+          fontSize: 9, color: '808080', align: 'center', border: false,
+        });
+      }
+
+      res.setHeader('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
+      res.setHeader('Content-Disposition', `attachment; filename=employees-on-leave-report-${new Date().toISOString().slice(0, 10)}.xlsx`);
+
+      await workbook.xlsx.write(res);
+      res.end();
     } catch (err) {
       return res_.error(res, err.message, 500);
     }

package/backend-project/src/modules/reports/reports.routes.js

@@ -3,8 +3,9 @@ const ReportsController = require('./reports.controller');
 const { authenticate } = require('../../middleware/auth.middleware');
 
 const router = Router();
-
 router.use(authenticate);
-router.get('/payroll', ReportsController.monthlyPayroll);
+
+router.get('/employees-on-leave', ReportsController.employeesOnLeave);
+router.get('/employees-on-leave/excel', ReportsController.employeesOnLeaveExcel);
 
 module.exports = router;

package/backend-project/src/seed.js

@@ -1,29 +1,83 @@
 require('dotenv').config();
 const mongoose = require('mongoose');
+const bcrypt = require('bcryptjs');
 const db = require('./config/db');
+const env = require('./config/env');
 const Department = require('./modules/department/department.model');
-
-const departments = [
-  { departmentCode: 'CW',   departmentName: 'Carwash',             grossSalary: 300000, totalDeduction: 30000 },
-  { departmentCode: 'ST',   departmentName: 'Stock',               grossSalary: 200000, totalDeduction: 20000 },
-  { departmentCode: 'MC',   departmentName: 'Mechanic',            grossSalary: 450000, totalDeduction: 45000 },
-  { departmentCode: 'ADMS', departmentName: 'Administration Staff', grossSalary: 600000, totalDeduction: 60000 },
-];
+const Position = require('./modules/position/position.model');
+const Employee = require('./modules/employee/employee.model');
+const User = require('./modules/auth/user.model');
 
 async function seed() {
   try {
     await db.connect();
     console.log('Connected to MongoDB');
 
-    for (const dept of departments) {
-      const existing = await Department.findOne({ departmentCode: dept.departmentCode });
-      if (!existing) {
-        await Department.create(dept);
-        console.log(`Created department: ${dept.departmentCode} - ${dept.departmentName}`);
-      } else {
-        console.log(`Department ${dept.departmentCode} already exists`);
-      }
+    const departments = await Department.insertMany([
+      { departName: 'Sales' },
+      { departName: 'Warehouse' },
+      { departName: 'Administration' },
+      { departName: 'Human Resources' },
+    ]);
+    console.log(`Created ${departments.length} departments`);
+
+    const positions = await Position.insertMany([
+      { posName: 'Sales Representative', requiredQualification: 'Bachelor in Business' },
+      { posName: 'Warehouse Manager', requiredQualification: 'Diploma in Logistics' },
+      { posName: 'HR Officer', requiredQualification: 'Bachelor in HRM' },
+      { posName: 'Accountant', requiredQualification: 'Bachelor in Accounting' },
+      { posName: 'Cashier', requiredQualification: 'High School Diploma' },
+    ]);
+    console.log(`Created ${positions.length} positions`);
+
+    const employees = await Employee.insertMany([
+      {
+        empFirstName: 'Alice', empLastName: 'Mukamana',
+        empGender: 'female', empDateOfBirth: new Date('1990-05-12'),
+        empEmail: 'alice@dabenterprise.rw', empTelephone: '0788123456',
+        empAddress: 'Kigali', empHireDate: new Date('2022-01-15'),
+        empStatus: 'on mission', department: departments[0]._id, position: positions[0]._id,
+      },
+      {
+        empFirstName: 'Bob', empLastName: 'Habimana',
+        empGender: 'male', empDateOfBirth: new Date('1985-08-22'),
+        empEmail: 'bob@dabenterprise.rw', empTelephone: '0788123457',
+        empAddress: 'Kicukiro', empHireDate: new Date('2021-03-01'),
+        empStatus: 'on leave', department: departments[0]._id, position: positions[0]._id,
+      },
+      {
+        empFirstName: 'Claire', empLastName: 'Uwimana',
+        empGender: 'female', empDateOfBirth: new Date('1992-11-03'),
+        empEmail: 'claire@dabenterprise.rw', empTelephone: '0788123458',
+        empAddress: 'Remera', empHireDate: new Date('2023-06-10'),
+        empStatus: 'on leave', department: departments[1]._id, position: positions[1]._id,
+      },
+      {
+        empFirstName: 'David', empLastName: 'Niyonzima',
+        empGender: 'male', empDateOfBirth: new Date('1988-02-14'),
+        empEmail: 'david@dabenterprise.rw', empTelephone: '0788123459',
+        empAddress: 'Nyamirambo', empHireDate: new Date('2020-09-20'),
+        empStatus: 'on leave', department: departments[2]._id, position: positions[3]._id,
+      },
+      {
+        empFirstName: 'Grace', empLastName: 'Uwase',
+        empGender: 'female', empDateOfBirth: new Date('1995-07-30'),
+        empEmail: 'grace@dabenterprise.rw', empTelephone: '0788123460',
+        empAddress: 'Kanombe', empHireDate: new Date('2024-01-05'),
+        empStatus: 'on mission', department: departments[3]._id, position: positions[2]._id,
+      },
+    ]);
+    console.log(`Created ${employees.length} employees`);
+
+    const existingUser = await User.findOne({ userName: 'admin' });
+    if (!existingUser) {
+      const hashed = await bcrypt.hash('admin123', env.BCRYPT_ROUNDS);
+      await User.create({ userName: 'admin', password: hashed, employee: employees[0]._id });
+      console.log('Created user: admin / admin123');
+    } else {
+      console.log('User admin already exists');
     }
+
     console.log('Seed complete!');
   } catch (err) {
     console.error('Seed failed:', err.message);