alpe-temp 1.0.0

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

@@ -0,0 +1,57 @@
+const bcrypt = require('bcryptjs');
+const User = require('./user.model');
+const env = require('../../config/env');
+const { generateTokens, verifyRefreshToken } = require('../../utils/token');
+
+const fail = (message, statusCode) => {
+  const err = new Error(message);
+  err.statusCode = statusCode;
+  throw err;
+};
+
+const AuthService = {
+  async signup({ name, email, password }) {
+    const existing = await User.findOne({ email: email.toLowerCase() });
+    if (existing) fail('Email is already registered', 409);
+
+    const hashed = await bcrypt.hash(password, env.BCRYPT_ROUNDS);
+    const user = await User.create({ name, email, password: hashed });
+    const tokens = generateTokens(user.toSafeObject());
+
+    return { user: user.toSafeObject(), ...tokens };
+  },
+
+  async login({ email, password }) {
+    const user = await User.findOne({ email: email.toLowerCase() });
+    if (!user) fail('Invalid credentials', 401);
+
+    const valid = await bcrypt.compare(password, user.password);
+    if (!valid) fail('Invalid credentials', 401);
+
+    const tokens = generateTokens(user.toSafeObject());
+    return { user: user.toSafeObject(), ...tokens };
+  },
+
+  async refresh(refreshToken) {
+    let payload;
+    try {
+      payload = verifyRefreshToken(refreshToken);
+    } catch {
+      fail('Invalid or expired refresh token', 401);
+    }
+
+    const user = await User.findById(payload.id);
+    if (!user) fail('User not found', 401);
+
+    const tokens = generateTokens(user.toSafeObject());
+    return { user: user.toSafeObject(), ...tokens };
+  },
+
+  async me(userId) {
+    const user = await User.findById(userId);
+    if (!user) fail('User not found', 404);
+    return user.toSafeObject();
+  },
+};
+
+module.exports = AuthService;

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

@@ -0,0 +1,41 @@
+const { Schema, model } = 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 }
+);
+
+// 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,
+    createdAt: this.createdAt,
+  };
+};
+
+module.exports = model('User', userSchema);

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

@@ -0,0 +1,54 @@
+const DepartmentService = require('./department.service');
+const res_ = require('../../utils/response');
+
+const DepartmentController = {
+  async create(req, res) {
+    try {
+      const dept = await DepartmentService.create(req.body);
+      return res_.created(res, dept, 'Department created');
+    } catch (err) {
+      return res_.error(res, err.message, err.statusCode || 500);
+    }
+  },
+
+  async list(req, res) {
+    try {
+      const departments = await DepartmentService.list();
+      return res_.success(res, { departments });
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+
+  async getById(req, res) {
+    try {
+      const dept = await DepartmentService.getById(req.params.id);
+      if (!dept) return res_.notFound(res, 'Department not found');
+      return res_.success(res, dept);
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+
+  async update(req, res) {
+    try {
+      const dept = await DepartmentService.update(req.params.id, req.body);
+      if (!dept) return res_.notFound(res, 'Department not found');
+      return res_.success(res, dept, 'Department updated');
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+
+  async remove(req, res) {
+    try {
+      const dept = await DepartmentService.remove(req.params.id);
+      if (!dept) return res_.notFound(res, 'Department not found');
+      return res_.success(res, null, 'Department deleted');
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+};
+
+module.exports = DepartmentController;

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

@@ -0,0 +1,10 @@
+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 },
+}, { timestamps: true });
+
+module.exports = mongoose.model('Department', departmentSchema);

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

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

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

@@ -0,0 +1,29 @@
+const Department = require('./department.model');
+
+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 });
+  },
+
+  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);
+  },
+};
+
+module.exports = DepartmentService;

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

@@ -0,0 +1,63 @@
+const EmployeeService = require('./employee.service');
+const res_ = require('../../utils/response');
+
+const EmployeeController = {
+  async create(req, res) {
+    try {
+      const emp = await EmployeeService.create(req.body);
+      return res_.created(res, emp, 'Employee created');
+    } catch (err) {
+      return res_.error(res, err.message, err.statusCode || 500);
+    }
+  },
+
+  async list(req, res) {
+    try {
+      const employees = await EmployeeService.list();
+      return res_.success(res, { employees });
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+
+  async getById(req, res) {
+    try {
+      const emp = await EmployeeService.getById(req.params.id);
+      if (!emp) return res_.notFound(res, 'Employee not found');
+      return res_.success(res, emp);
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+
+  async update(req, res) {
+    try {
+      const emp = await EmployeeService.update(req.params.id, req.body);
+      if (!emp) return res_.notFound(res, 'Employee not found');
+      return res_.success(res, emp, 'Employee updated');
+    } catch (err) {
+      return res_.error(res, err.message, 500);
+    }
+  },
+
+  async remove(req, res) {
+    try {
+      const emp = await EmployeeService.remove(req.params.id);
+      if (!emp) return res_.notFound(res, 'Employee not found');
+      return res_.success(res, null, 'Employee deleted');
+    } catch (err) {
+      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

@@ -0,0 +1,15 @@
+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' },
+}, { timestamps: true });
+
+module.exports = mongoose.model('Employee', employeeSchema);

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

@@ -0,0 +1,16 @@
+const { Router } = require('express');
+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.delete('/:id', EmployeeController.remove);
+
+module.exports = router;

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

@@ -0,0 +1,30 @@
+const Employee = require('./employee.model');
+
+const EmployeeService = {
+  async create(data) {
+    const emp = await Employee.create(data);
+    return Employee.populate(emp, { path: 'department' });
+  },
+
+  async list() {
+    return Employee.find().populate('department').sort({ createdAt: -1 });
+  },
+
+  async getById(id) {
+    return Employee.findById(id).populate('department');
+  },
+
+  async update(id, data) {
+    return Employee.findByIdAndUpdate(id, data, { new: true }).populate('department');
+  },
+
+  async remove(id) {
+    return Employee.findByIdAndDelete(id);
+  },
+
+  async count() {
+    return Employee.countDocuments();
+  },
+};
+
+module.exports = EmployeeService;

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

@@ -0,0 +1,61 @@
+const ExcelService = require('./excel.service');
+const res_ = require('../../utils/response');
+
+const ExcelController = {
+  /**
+   * GET /api/excel/export/users
+   * Demo: exports a users sheet directly to the browser.
+   * Replace `sampleData` with a real DB query.
+   */
+  async exportUsers(req, res) {
+    try {
+      const sampleData = [
+        { id: 'u-001', name: 'Alice Martin',  email: 'alice@example.com',  role: 'admin', joined: new Date('2024-01-15'), revenue: 4800 },
+        { id: 'u-002', name: 'Bob Karenzi',   email: 'bob@example.com',    role: 'user',  joined: new Date('2024-03-22'), revenue: 1200 },
+        { id: 'u-003', name: 'Claire Umutesi', email: 'claire@example.com', role: 'user',  joined: new Date('2024-07-09'), revenue: 2500 },
+      ];
+
+      const sheets = [
+        {
+          name: 'Users',
+          columns: [
+            { header: 'ID',       key: 'id',      width: 10 },
+            { header: 'Name',     key: 'name',    width: 25 },
+            { header: 'Email',    key: 'email',   width: 35 },
+            { header: 'Role',     key: 'role',    width: 12 },
+            { header: 'Joined',   key: 'joined',  width: 14, type: 'date' },
+            { header: 'Revenue',  key: 'revenue', width: 15, type: 'currency' },
+          ],
+          rows: sampleData,
+          totals: { revenue: `=SUM(F2:F${sampleData.length + 1})` },
+        },
+      ];
+
+      await ExcelService.exportToResponse(res, 'users-report', sheets);
+    } catch (err) {
+      return res_.error(res, err.message);
+    }
+  },
+
+  /**
+   * GET /api/excel/export/custom
+   * Generic export: pass `sheetName` + `data` as JSON body or query params.
+   * Useful for ad-hoc client-driven exports.
+   */
+  async exportCustom(req, res) {
+    try {
+      const { sheetName = 'Export', data = [] } = req.body;
+
+      if (!Array.isArray(data) || !data.length) {
+        return res_.badRequest(res, '`data` must be a non-empty array');
+      }
+
+      const sheet = ExcelService.buildSheetDef(sheetName, data);
+      await ExcelService.exportToResponse(res, sheetName, [sheet]);
+    } catch (err) {
+      return res_.error(res, err.message);
+    }
+  },
+};
+
+module.exports = ExcelController;

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

@@ -0,0 +1,13 @@
+const { Router } = require('express');
+const ExcelController = require('./excel.controller');
+const { authenticate } = require('../../middleware/auth.middleware');
+
+const router = Router();
+
+// All export routes require authentication
+router.use(authenticate);
+
+router.get('/export/users',  ExcelController.exportUsers);
+router.post('/export/custom', ExcelController.exportCustom);
+
+module.exports = router;