mangoose-xempp 1.0.0

package/templates/sfms/server/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "school-payroll-server",
+  "version": "1.0.0",
+  "description": "School Payroll Management API",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node src/index.js",
+    "dev": "node --watch-path=./src --watch src/index.js",
+    "seed": "node src/seed.js"
+  },
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.5",
+    "express": "^4.21.0",
+    "express-validator": "^7.2.0",
+    "jsonwebtoken": "^9.0.2",
+    "mongoose": "^8.7.0",
+    "school-payroll": "file:.."
+  }
+}

package/templates/sfms/server/src/bootstrap.js

@@ -0,0 +1,16 @@
+import User from './models/User.js';
+
+/** Create demo admin when the database has no users (local dev). */
+export async function ensureDefaultAdmin() {
+  const count = await User.countDocuments();
+  if (count > 0) return;
+
+  await User.create({
+    name: 'Admin User',
+    email: 'admin@school.edu',
+    password: 'admin123',
+    role: 'admin',
+  });
+  console.log('Default admin created: admin@school.edu / admin123');
+  console.log('Run "npm run seed" from the project root for full demo data.');
+}

package/templates/sfms/server/src/config/db.js

@@ -0,0 +1,7 @@
+import mongoose from 'mongoose';
+
+export const connectDB = async () => {
+  const uri = process.env.MONGODB_URI || 'mongodb://127.0.0.1:27017/school_payroll';
+  await mongoose.connect(uri);
+  console.log(`MongoDB connected: ${mongoose.connection.host}`);
+};

package/templates/sfms/server/src/index.js

@@ -0,0 +1,46 @@
+import 'dotenv/config';
+import express from 'express';
+import cors from 'cors';
+import { connectDB } from './config/db.js';
+import { ensureDefaultAdmin } from './bootstrap.js';
+import { errorHandler } from './middleware/errorHandler.js';
+import authRoutes from './routes/authRoutes.js';
+import departmentRoutes from './routes/departmentRoutes.js';
+import employeeRoutes from './routes/employeeRoutes.js';
+import payrollRoutes from './routes/payrollRoutes.js';
+import dashboardRoutes from './routes/dashboardRoutes.js';
+import studentRoutes from './routes/studentRoutes.js';
+import studentPaymentRoutes from './routes/studentPaymentRoutes.js';
+
+const app = express();
+const PORT = process.env.PORT || 5000;
+
+app.use(
+  cors({
+    origin: process.env.CLIENT_URL || 'http://localhost:5173',
+    credentials: true,
+  })
+);
+app.use(express.json());
+
+app.get('/api/health', (_, res) => res.json({ status: 'ok', app: 'School Payroll API' }));
+
+app.use('/api/auth', authRoutes);
+app.use('/api/departments', departmentRoutes);
+app.use('/api/employees', employeeRoutes);
+app.use('/api/payrolls', payrollRoutes);
+app.use('/api/dashboard', dashboardRoutes);
+app.use('/api/students', studentRoutes);
+app.use('/api/student-payments', studentPaymentRoutes);
+
+app.use(errorHandler);
+
+connectDB()
+  .then(async () => {
+    await ensureDefaultAdmin();
+    app.listen(PORT, () => console.log(`Server running on port ${PORT}`));
+  })
+  .catch((err) => {
+    console.error('DB connection failed:', err.message);
+    process.exit(1);
+  });

package/templates/sfms/server/src/middleware/auth.js

@@ -0,0 +1,25 @@
+import jwt from 'jsonwebtoken';
+import User from '../models/User.js';
+
+export const protect = async (req, res, next) => {
+  let token;
+  if (req.headers.authorization?.startsWith('Bearer')) {
+    token = req.headers.authorization.split(' ')[1];
+  }
+  if (!token) {
+    return res.status(401).json({ message: 'Not authorized' });
+  }
+  try {
+    const decoded = jwt.verify(token, process.env.JWT_SECRET || 'dev_secret');
+    req.user = await User.findById(decoded.id).select('-password');
+    if (!req.user) return res.status(401).json({ message: 'User not found' });
+    next();
+  } catch {
+    return res.status(401).json({ message: 'Invalid token' });
+  }
+};
+
+export const generateToken = (id) =>
+  jwt.sign({ id }, process.env.JWT_SECRET || 'dev_secret', {
+    expiresIn: process.env.JWT_EXPIRE || '7d',
+  });

package/templates/sfms/server/src/middleware/errorHandler.js

@@ -0,0 +1,9 @@
+export const errorHandler = (err, req, res, next) => {
+  const status = err.statusCode || 500;
+  const message = err.message || 'Server Error';
+  if (err.code === 11000) {
+    const field = Object.keys(err.keyValue || {})[0] || 'field';
+    return res.status(400).json({ message: `${field} already exists` });
+  }
+  res.status(status).json({ message });
+};

package/templates/sfms/server/src/models/Department.js

@@ -0,0 +1,14 @@
+import mongoose from 'mongoose';
+
+const departmentSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true, unique: true, trim: true },
+    code: { type: String, required: true, unique: true, uppercase: true },
+    description: { type: String, default: '' },
+    headName: { type: String, default: '' },
+    budget: { type: Number, default: 0 },
+  },
+  { timestamps: true }
+);
+
+export default mongoose.model('Department', departmentSchema);

package/templates/sfms/server/src/models/Employee.js

@@ -0,0 +1,59 @@
+import mongoose from 'mongoose';
+
+const employeeSchema = new mongoose.Schema(
+  {
+    employeeId: { type: String, required: true, unique: true },
+    firstName: { type: String, required: true, trim: true },
+    lastName: { type: String, required: true, trim: true },
+    email: { type: String, required: true, unique: true, lowercase: true },
+    phone: { type: String, default: '' },
+    role: {
+      type: String,
+      enum: ['teacher', 'admin_staff', 'principal', 'support', 'librarian', 'counselor'],
+      default: 'teacher',
+    },
+    department: { type: mongoose.Schema.Types.ObjectId, ref: 'Department', required: true },
+    joinDate: { type: Date, required: true },
+    status: { type: String, enum: ['active', 'on_leave', 'terminated'], default: 'active' },
+    bankAccount: { type: String, default: '' },
+    address: { type: String, default: '' },
+    photo: { type: String, default: '' },
+    salary: {
+      basic: { type: Number, required: true, default: 0 },
+      housing: { type: Number, default: 0 },
+      transport: { type: Number, default: 0 },
+      medical: { type: Number, default: 0 },
+      bonus: { type: Number, default: 0 },
+    },
+    deductions: {
+      tax: { type: Number, default: 0 },
+      pension: { type: Number, default: 0 },
+      insurance: { type: Number, default: 0 },
+      loan: { type: Number, default: 0 },
+    },
+  },
+  { timestamps: true }
+);
+
+employeeSchema.virtual('fullName').get(function () {
+  return `${this.firstName} ${this.lastName}`;
+});
+
+employeeSchema.virtual('grossSalary').get(function () {
+  const s = this.salary;
+  return (s.basic || 0) + (s.housing || 0) + (s.transport || 0) + (s.medical || 0) + (s.bonus || 0);
+});
+
+employeeSchema.virtual('totalDeductions').get(function () {
+  const d = this.deductions;
+  return (d.tax || 0) + (d.pension || 0) + (d.insurance || 0) + (d.loan || 0);
+});
+
+employeeSchema.virtual('netSalary').get(function () {
+  return this.grossSalary - this.totalDeductions;
+});
+
+employeeSchema.set('toJSON', { virtuals: true });
+employeeSchema.set('toObject', { virtuals: true });
+
+export default mongoose.model('Employee', employeeSchema);

package/templates/sfms/server/src/models/Payroll.js

@@ -0,0 +1,38 @@
+import mongoose from 'mongoose';
+
+const payrollSchema = new mongoose.Schema(
+  {
+    employee: { type: mongoose.Schema.Types.ObjectId, ref: 'Employee', required: true },
+    month: { type: Number, required: true, min: 1, max: 12 },
+    year: { type: Number, required: true },
+    periodLabel: { type: String, required: true },
+    basic: { type: Number, default: 0 },
+    allowances: { type: Number, default: 0 },
+    grossPay: { type: Number, default: 0 },
+    deductions: { type: Number, default: 0 },
+    netPay: { type: Number, default: 0 },
+    status: {
+      type: String,
+      enum: ['draft', 'processed', 'paid'],
+      default: 'draft',
+    },
+    paidAt: { type: Date },
+    notes: { type: String, default: '' },
+    breakdown: {
+      housing: Number,
+      transport: Number,
+      medical: Number,
+      bonus: Number,
+      tax: Number,
+      pension: Number,
+      insurance: Number,
+      loan: Number,
+    },
+    processedBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
+  },
+  { timestamps: true }
+);
+
+payrollSchema.index({ employee: 1, month: 1, year: 1 }, { unique: true });
+
+export default mongoose.model('Payroll', payrollSchema);

package/templates/sfms/server/src/models/Student.js

@@ -0,0 +1,28 @@
+import mongoose from 'mongoose';
+
+const studentSchema = new mongoose.Schema(
+  {
+    studentId: { type: String, required: true, unique: true },
+    firstName: { type: String, required: true, trim: true },
+    lastName: { type: String, required: true, trim: true },
+    email: { type: String, lowercase: true, default: '' },
+    phone: { type: String, default: '' },
+    grade: { type: String, required: true },
+    section: { type: String, default: 'A' },
+    parentName: { type: String, default: '' },
+    parentPhone: { type: String, default: '' },
+    enrollmentDate: { type: Date, required: true },
+    status: { type: String, enum: ['active', 'graduated', 'withdrawn'], default: 'active' },
+    tuitionFee: { type: Number, required: true, default: 0 },
+  },
+  { timestamps: true }
+);
+
+studentSchema.virtual('fullName').get(function () {
+  return `${this.firstName} ${this.lastName}`;
+});
+
+studentSchema.set('toJSON', { virtuals: true });
+studentSchema.set('toObject', { virtuals: true });
+
+export default mongoose.model('Student', studentSchema);

package/templates/sfms/server/src/models/StudentPayment.js

@@ -0,0 +1,40 @@
+import mongoose from 'mongoose';
+
+const studentPaymentSchema = new mongoose.Schema(
+  {
+    student: { type: mongoose.Schema.Types.ObjectId, ref: 'Student', required: true },
+    amount: { type: Number, required: true, min: 0 },
+    paymentType: {
+      type: String,
+      enum: ['tuition', 'transport', 'library', 'exam', 'uniform', 'other'],
+      default: 'tuition',
+    },
+    paymentMethod: {
+      type: String,
+      enum: ['cash', 'card', 'bank_transfer', 'online'],
+      default: 'cash',
+    },
+    status: {
+      type: String,
+      enum: ['pending', 'completed', 'failed', 'refunded'],
+      default: 'completed',
+    },
+    receiptNumber: { type: String, unique: true, sparse: true },
+    paidAt: { type: Date, default: Date.now },
+    term: { type: String, default: 'Term 1' },
+    academicYear: { type: String, default: '' },
+    notes: { type: String, default: '' },
+    recordedBy: { type: mongoose.Schema.Types.ObjectId, ref: 'User' },
+  },
+  { timestamps: true }
+);
+
+studentPaymentSchema.pre('save', async function (next) {
+  if (!this.receiptNumber) {
+    const count = await mongoose.model('StudentPayment').countDocuments();
+    this.receiptNumber = `RCP-${Date.now().toString(36).toUpperCase()}-${String(count + 1).padStart(4, '0')}`;
+  }
+  next();
+});
+
+export default mongoose.model('StudentPayment', studentPaymentSchema);

package/templates/sfms/server/src/models/User.js

@@ -0,0 +1,25 @@
+import mongoose from 'mongoose';
+import bcrypt from 'bcryptjs';
+
+const userSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true, trim: true },
+    email: { type: String, required: true, unique: true, lowercase: true },
+    password: { type: String, required: true, minlength: 6, select: false },
+    role: { type: String, enum: ['admin', 'hr'], default: 'admin' },
+    avatar: { type: String, default: '' },
+  },
+  { timestamps: true }
+);
+
+userSchema.pre('save', async function (next) {
+  if (!this.isModified('password')) return next();
+  this.password = await bcrypt.hash(this.password, 12);
+  next();
+});
+
+userSchema.methods.matchPassword = function (entered) {
+  return bcrypt.compare(entered, this.password);
+};
+
+export default mongoose.model('User', userSchema);

package/templates/sfms/server/src/routes/authRoutes.js

@@ -0,0 +1,65 @@
+import express from 'express';
+import { body, validationResult } from 'express-validator';
+import User from '../models/User.js';
+import { generateToken, protect } from '../middleware/auth.js';
+
+const router = express.Router();
+
+router.post(
+  '/register',
+  [
+    body('name').trim().notEmpty(),
+    body('email').isEmail().normalizeEmail(),
+    body('password').isLength({ min: 6 }),
+  ],
+  async (req, res, next) => {
+    try {
+      const errors = validationResult(req);
+      if (!errors.isEmpty()) return res.status(400).json({ message: errors.array()[0].msg });
+      const { name, email, password } = req.body;
+      const exists = await User.findOne({ email });
+      if (exists) return res.status(400).json({ message: 'Email already registered' });
+      const user = await User.create({ name, email, password });
+      res.status(201).json({
+        _id: user._id,
+        name: user.name,
+        email: user.email,
+        role: user.role,
+        token: generateToken(user._id),
+      });
+    } catch (err) {
+      next(err);
+    }
+  }
+);
+
+router.post(
+  '/login',
+  [body('email').isEmail(), body('password').notEmpty()],
+  async (req, res, next) => {
+    try {
+      const errors = validationResult(req);
+      if (!errors.isEmpty()) return res.status(400).json({ message: 'Invalid credentials' });
+      const { email, password } = req.body;
+      const user = await User.findOne({ email }).select('+password');
+      if (!user || !(await user.matchPassword(password))) {
+        return res.status(401).json({ message: 'Invalid email or password' });
+      }
+      res.json({
+        _id: user._id,
+        name: user.name,
+        email: user.email,
+        role: user.role,
+        token: generateToken(user._id),
+      });
+    } catch (err) {
+      next(err);
+    }
+  }
+);
+
+router.get('/me', protect, async (req, res) => {
+  res.json(req.user);
+});
+
+export default router;

package/templates/sfms/server/src/routes/dashboardRoutes.js

@@ -0,0 +1,98 @@
+import express from 'express';
+import Employee from '../models/Employee.js';
+import Department from '../models/Department.js';
+import Payroll from '../models/Payroll.js';
+import Student from '../models/Student.js';
+import StudentPayment from '../models/StudentPayment.js';
+import { protect } from '../middleware/auth.js';
+import { monthLabel } from '../utils/payrollCalc.js';
+
+const router = express.Router();
+router.use(protect);
+
+router.get('/stats', async (req, res, next) => {
+  try {
+    const now = new Date();
+    const month = now.getMonth() + 1;
+    const year = now.getFullYear();
+
+    const monthStart = new Date(year, month - 1, 1);
+    const monthEnd = new Date(year, month, 0, 23, 59, 59);
+
+    const [
+      totalEmployees,
+      activeEmployees,
+      departments,
+      currentPayrolls,
+      recentPayrolls,
+      roleBreakdown,
+      activeStudents,
+      monthlyStudentPayments,
+      recentStudentPayments,
+      pendingStudentPayments,
+    ] = await Promise.all([
+      Employee.countDocuments(),
+      Employee.countDocuments({ status: 'active' }),
+      Department.countDocuments(),
+      Payroll.find({ month, year }),
+      Payroll.find()
+        .sort({ createdAt: -1 })
+        .limit(5)
+        .populate('employee', 'firstName lastName employeeId'),
+      Employee.aggregate([
+        { $match: { status: 'active' } },
+        { $group: { _id: '$role', count: { $sum: 1 } } },
+      ]),
+      Student.countDocuments({ status: 'active' }),
+      StudentPayment.find({ paidAt: { $gte: monthStart, $lte: monthEnd }, status: 'completed' }),
+      StudentPayment.find({ status: 'completed' })
+        .sort({ paidAt: -1 })
+        .limit(5)
+        .populate('student', 'firstName lastName studentId grade'),
+      StudentPayment.countDocuments({ status: 'pending' }),
+    ]);
+
+    const monthlyPayroll = currentPayrolls.reduce((s, p) => s + p.netPay, 0);
+    const paidThisMonth = currentPayrolls.filter((p) => p.status === 'paid').length;
+    const studentFeesCollected = monthlyStudentPayments.reduce((s, p) => s + p.amount, 0);
+
+    const last6Months = [];
+    for (let i = 5; i >= 0; i--) {
+      let m = month - i;
+      let y = year;
+      while (m <= 0) {
+        m += 12;
+        y -= 1;
+      }
+      const records = await Payroll.find({ month: m, year: y });
+      last6Months.push({
+        label: monthLabel(m, y).split(' ')[0].slice(0, 3),
+        gross: records.reduce((s, p) => s + p.grossPay, 0),
+        net: records.reduce((s, p) => s + p.netPay, 0),
+      });
+    }
+
+    res.json({
+      totalEmployees,
+      activeEmployees,
+      departments,
+      monthlyPayroll,
+      paidThisMonth,
+      pendingThisMonth: currentPayrolls.length - paidThisMonth,
+      payrollCountThisMonth: currentPayrolls.length,
+      roleBreakdown: roleBreakdown.map((r) => ({ role: r._id, count: r.count })),
+      recentPayrolls,
+      chartData: last6Months,
+      currentPeriod: monthLabel(month, year),
+      activeStudents,
+      studentFeesCollected,
+      studentPaymentCount: monthlyStudentPayments.length,
+      pendingStudentPayments,
+      recentStudentPayments,
+    });
+  } catch (err) {
+    next(err);
+  }
+});
+
+export default router;

package/templates/sfms/server/src/routes/departmentRoutes.js

@@ -0,0 +1,59 @@
+import express from 'express';
+import Department from '../models/Department.js';
+import Employee from '../models/Employee.js';
+import { protect } from '../middleware/auth.js';
+
+const router = express.Router();
+router.use(protect);
+
+router.get('/', async (req, res, next) => {
+  try {
+    const departments = await Department.find().sort({ name: 1 });
+    const withCounts = await Promise.all(
+      departments.map(async (d) => {
+        const count = await Employee.countDocuments({ department: d._id, status: 'active' });
+        return { ...d.toObject(), employeeCount: count };
+      })
+    );
+    res.json(withCounts);
+  } catch (err) {
+    next(err);
+  }
+});
+
+router.post('/', async (req, res, next) => {
+  try {
+    const dept = await Department.create(req.body);
+    res.status(201).json(dept);
+  } catch (err) {
+    next(err);
+  }
+});
+
+router.put('/:id', async (req, res, next) => {
+  try {
+    const dept = await Department.findByIdAndUpdate(req.params.id, req.body, {
+      new: true,
+      runValidators: true,
+    });
+    if (!dept) return res.status(404).json({ message: 'Department not found' });
+    res.json(dept);
+  } catch (err) {
+    next(err);
+  }
+});
+
+router.delete('/:id', async (req, res, next) => {
+  try {
+    const count = await Employee.countDocuments({ department: req.params.id });
+    if (count > 0) {
+      return res.status(400).json({ message: 'Cannot delete department with employees' });
+    }
+    await Department.findByIdAndDelete(req.params.id);
+    res.json({ message: 'Deleted' });
+  } catch (err) {
+    next(err);
+  }
+});
+
+export default router;

package/templates/sfms/server/src/routes/employeeRoutes.js

@@ -0,0 +1,75 @@
+import express from 'express';
+import Employee from '../models/Employee.js';
+import { protect } from '../middleware/auth.js';
+
+const router = express.Router();
+router.use(protect);
+
+router.get('/', async (req, res, next) => {
+  try {
+    const { status, department, search, role } = req.query;
+    const filter = {};
+    if (status) filter.status = status;
+    if (department) filter.department = department;
+    if (role) filter.role = role;
+    if (search) {
+      filter.$or = [
+        { firstName: new RegExp(search, 'i') },
+        { lastName: new RegExp(search, 'i') },
+        { employeeId: new RegExp(search, 'i') },
+        { email: new RegExp(search, 'i') },
+      ];
+    }
+    const employees = await Employee.find(filter)
+      .populate('department', 'name code')
+      .sort({ createdAt: -1 });
+    res.json(employees);
+  } catch (err) {
+    next(err);
+  }
+});
+
+router.get('/:id', async (req, res, next) => {
+  try {
+    const employee = await Employee.findById(req.params.id).populate('department', 'name code');
+    if (!employee) return res.status(404).json({ message: 'Employee not found' });
+    res.json(employee);
+  } catch (err) {
+    next(err);
+  }
+});
+
+router.post('/', async (req, res, next) => {
+  try {
+    const employee = await Employee.create(req.body);
+    const populated = await Employee.findById(employee._id).populate('department', 'name code');
+    res.status(201).json(populated);
+  } catch (err) {
+    next(err);
+  }
+});
+
+router.put('/:id', async (req, res, next) => {
+  try {
+    const employee = await Employee.findByIdAndUpdate(req.params.id, req.body, {
+      new: true,
+      runValidators: true,
+    }).populate('department', 'name code');
+    if (!employee) return res.status(404).json({ message: 'Employee not found' });
+    res.json(employee);
+  } catch (err) {
+    next(err);
+  }
+});
+
+router.delete('/:id', async (req, res, next) => {
+  try {
+    const employee = await Employee.findByIdAndDelete(req.params.id);
+    if (!employee) return res.status(404).json({ message: 'Employee not found' });
+    res.json({ message: 'Deleted' });
+  } catch (err) {
+    next(err);
+  }
+});
+
+export default router;