create-myexam-app 1.0.20 → 1.0.21

package/package.json

@@ -2,7 +2,7 @@
   
   "name": "create-myexam-app",
   
-  "version": "1.0.20",
+  "version": "1.0.21",
   
   "description": "My exam projects",
   

package/projects/SCMS/backend/.env

@@ -1,5 +1,5 @@
-PORT= 5000
+PORT=5000
 
-MONGO_URI=mongodb://localhost:27017/scms_dbb
+MONGO_URI=mongodb://localhost:27017/SCMS
 
 JWT_SECRET=your_secret_key_here

package/projects/SCMS/backend/config/db.js

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

package/projects/SCMS/backend/controllers/authController.js

@@ -0,0 +1,90 @@
+const bcrypt = require('bcrypt');
+const jwt = require('jsonwebtoken');
+const User = require('../models/User');
+const JWT_SECRET = 'change_this_to_a_long_random_secret';
+
+
+
+function createToken(userId) {
+  return jwt.sign({ userId },JWT_SECRET, { expiresIn: '7d' });
+}
+
+function formatUser(user) {
+  return {
+    id: user._id,
+    name: user.name,
+    email: user.email,
+  };
+}
+
+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.toLowerCase() });
+    if (existing) {
+      return res.status(409).json({ message: 'Email already registered' });
+    }
+
+    const hashedPassword = await bcrypt.hash(password, 10);
+    const user = await User.create({
+      name,
+      email: email.toLowerCase(),//to ensure the email is always lowercase
+      password: hashedPassword,
+    });
+
+    const token = createToken(user._id);
+
+    res.status(201).json({
+      token,
+      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.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' });
+    }
+
+    const token = createToken(user._id);
+
+    res.json({
+      token,
+      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 });
+  }
+};

package/projects/SCMS/backend/controllers/deliveryController.js

@@ -0,0 +1,79 @@
+const Delivery = require('../models/delivery');
+const Shipment = require('../models/shipment');
+
+exports.addDelivery = async (req, res) => {
+  try {
+    const { deliveryCode, deliveryDate, quantityDelivered, deliveryStatus, shipmentId } = req.body;
+
+    if (shipmentId) {
+      const shipment = await Shipment.findById(shipmentId);
+      if (!shipment) return res.status(404).json({ msg: 'Shipment not found' });
+    }
+
+    const newDelivery = await Delivery.create({
+      deliveryCode,
+      deliveryDate,
+      quantityDelivered,
+      deliveryStatus,
+      shipment: shipmentId || null,
+    });
+
+    res.status(201).json(newDelivery);
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to add delivery', error: error.message });
+  }
+};
+
+exports.getDeliveries = async (req, res) => {
+  try {
+    const deliveries = await Delivery.find().populate({ path: 'shipment', populate: 'supplier' });
+    res.status(200).json(deliveries);
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to fetch deliveries', error: error.message });
+  }
+};
+
+exports.getDeliveryById = async (req, res) => {
+  try {
+    const delivery = await Delivery.findById(req.params.id).populate({ path: 'shipment', populate: 'supplier' });
+    if (!delivery) return res.status(404).json({ msg: 'Delivery not found' });
+    res.status(200).json(delivery);
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to fetch delivery', error: error.message });
+  }
+};
+
+exports.updateDelivery = async (req, res) => {
+  try {
+    const { shipmentId } = req.body;
+
+    if (shipmentId) {
+      const shipment = await Shipment.findById(shipmentId);
+      if (!shipment) return res.status(404).json({ msg: 'Shipment not found' });
+    }
+
+    const updatedDelivery = await Delivery.findByIdAndUpdate(
+      req.params.id,
+      {
+        ...req.body,
+        shipment: shipmentId || null,
+      },
+      { new: true }
+    );
+
+    if (!updatedDelivery) return res.status(404).json({ msg: 'Delivery not found' });
+    res.status(200).json(updatedDelivery);
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to update delivery', error: error.message });
+  }
+};
+
+exports.deleteDelivery = async (req, res) => {
+  try {
+    const deletedDelivery = await Delivery.findByIdAndDelete(req.params.id);
+    if (!deletedDelivery) return res.status(404).json({ msg: 'Delivery not found' });
+    res.status(200).json({ msg: 'Delivery deleted successfully' });
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to delete delivery', error: error.message });
+  }
+};

package/projects/SCMS/backend/controllers/productController.js

@@ -0,0 +1,74 @@
+const Product = require('../models/Product');
+
+
+exports.getproduct = async (req, res) => {
+  try {
+    const products = await Product.find().populate('Supplier');
+    if (!products) {
+      return res.status(404).json({ message: 'Products not found' });
+    }
+    res.json(products);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+}
+
+exports.getproductbyid = async (req, res) => {
+  try {
+    const productById = await Product.findById(req.params.id).populate('Supplier');
+    if (!productById) {
+      return res.status(404).json({ message: 'Product not found' });
+    }
+    res.json(productById);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+};
+
+exports.addproduct = async (req, res) => {
+  try {
+    const { productCode, productName, category, unitPrice, quantity, expiryDate } = req.body
+    const newproduct = await Product.create({
+      productCode,
+      productName,
+      category,
+      unitPrice,
+      quantity,
+      expiryDate,
+      Supplier: req.user._id
+    });
+
+    res.status(201).json(newproduct);
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+}
+
+exports.updateproduct = async (req, res) => {
+  try {
+    const updateproducts = await Product.findByIdAndUpdate(
+      req.params.id,
+      req.body,
+      { new: true }
+    );
+    if (!updateproducts) return res.status(404).json({ msg: " product not found" })
+
+    res.json({ msg: "Products updated Syccessfully", data: updateproducts });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+}
+
+exports.deleteproduct = async (req, res) => {
+  try {
+    const deleteproduct = await Product.findByIdAndDelete(
+      req.params.id
+    );
+    if (!deleteproduct) {
+      return res.status(404).json({ message: 'product not found' });
+    }
+    res.json({ message: 'Product deleted successfully' });
+  } catch (err) {
+    res.status(500).json({ message: err.message });
+  }
+}

package/projects/SCMS/backend/controllers/reportsController.js

@@ -0,0 +1,77 @@
+const Supplier = require('../models/Supplier');
+const Shipment = require('../models/shipment');
+const Delivery = require('../models/delivery');
+
+function getStartDate(days) {
+  const date = new Date();
+  date.setHours(0, 0, 0, 0);
+  date.setDate(date.getDate() - days);
+  return date;
+}
+
+exports.getReportSummary = async (req, res) => {
+  try {
+    const now = new Date();
+    const dailyStart = getStartDate(1);
+    const weeklyStart = getStartDate(7);
+    const monthlyStart = getStartDate(30);
+
+    const [
+      totalSuppliers,
+      dailySuppliers,
+      weeklySuppliers,
+      monthlySuppliers,
+      totalShipments,
+      dailyShipments,
+      weeklyShipments,
+      monthlyShipments,
+      totalDeliveries,
+      dailyDeliveries,
+      weeklyDeliveries,
+      monthlyDeliveries,
+      recentShipments,
+      recentDeliveries,
+    ] = await Promise.all([
+      Supplier.countDocuments(),
+      Supplier.countDocuments({ createdAt: { $gte: dailyStart } }),
+      Supplier.countDocuments({ createdAt: { $gte: weeklyStart } }),
+      Supplier.countDocuments({ createdAt: { $gte: monthlyStart } }),
+      Shipment.countDocuments(),
+      Shipment.countDocuments({ createdAt: { $gte: dailyStart } }),
+      Shipment.countDocuments({ createdAt: { $gte: weeklyStart } }),
+      Shipment.countDocuments({ createdAt: { $gte: monthlyStart } }),
+      Delivery.countDocuments(),
+      Delivery.countDocuments({ createdAt: { $gte: dailyStart } }),
+      Delivery.countDocuments({ createdAt: { $gte: weeklyStart } }),
+      Delivery.countDocuments({ createdAt: { $gte: monthlyStart } }),
+      Shipment.find().sort({ createdAt: -1 }).limit(5).populate('supplier'),
+      Delivery.find().sort({ createdAt: -1 }).limit(5).populate({ path: 'shipment', populate: 'supplier' }),
+    ]);
+
+    res.status(200).json({
+      suppliers: {
+        total: totalSuppliers,
+        daily: dailySuppliers,
+        weekly: weeklySuppliers,
+        monthly: monthlySuppliers,
+      },
+      shipments: {
+        total: totalShipments,
+        daily: dailyShipments,
+        weekly: weeklyShipments,
+        monthly: monthlyShipments,
+      },
+      deliveries: {
+        total: totalDeliveries,
+        daily: dailyDeliveries,
+        weekly: weeklyDeliveries,
+        monthly: monthlyDeliveries,
+      },
+      recentShipments,
+      recentDeliveries,
+      generatedAt: now,
+    });
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to generate report', error: error.message });
+  }
+};

package/projects/SCMS/backend/controllers/shipmentController.js

@@ -0,0 +1,80 @@
+const Shipment = require('../models/shipment');
+const Supplier = require('../models/Supplier');
+
+exports.addShipment = async (req, res) => {
+  try {
+    const { shipmentNumber, shipmentDate, shipmentStatus, destination, supplierId } = req.body;
+
+    if (supplierId) {
+      const supplier = await Supplier.findById(supplierId);
+      if (!supplier) return res.status(404).json({ msg: 'Supplier not found' });
+    }
+
+    const newShipment = await Shipment.create({
+      shipmentNumber,
+      shipmentDate,
+      shipmentStatus,
+      destination,
+      supplier: supplierId || null,
+    });
+
+    res.status(201).json(newShipment);
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to add shipment', error: error.message });
+  }
+};
+
+exports.getShipments = async (req, res) => {
+  try {
+    const shipments = await Shipment.find().populate('supplier');
+    res.status(200).json(shipments);
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to fetch shipments', error: error.message });
+  }
+};
+
+exports.getShipmentById = async (req, res) => {
+  try {
+    const shipment = await Shipment.findById(req.params.id).populate('supplier');
+    if (!shipment) return res.status(404).json({ msg: 'Shipment not found' });
+    res.status(200).json(shipment);
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to fetch shipment', error: error.message });
+  }
+};
+
+exports.updateShipment = async (req, res) => {
+  try {
+    const { supplierId } = req.body;
+
+    if (supplierId) {
+      const supplier = await Supplier.findById(supplierId);
+      if (!supplier) return res.status(404).json({ msg: 'Supplier not found' });
+    }
+
+    const updatedShipment = await Shipment.findByIdAndUpdate(
+      req.params.id,
+      {
+        ...req.body,
+        supplier: supplierId || null,
+      },
+      { new: true }
+    );
+
+    if (!updatedShipment) return res.status(404).json({ msg: 'Shipment not found' });
+
+    res.status(200).json(updatedShipment);
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to update shipment', error: error.message });
+  }
+};
+
+exports.deleteShipment = async (req, res) => {
+  try {
+    const deletedShipment = await Shipment.findByIdAndDelete(req.params.id);
+    if (!deletedShipment) return res.status(404).json({ msg: 'Shipment not found' });
+    res.status(200).json({ msg: 'Shipment deleted successfully' });
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to delete shipment', error: error.message });
+  }
+};

package/projects/SCMS/backend/controllers/supplierController.js

@@ -0,0 +1,58 @@
+const supplier = require('../models/Supplier');
+
+exports.addsupplier = async (req, res) => {
+  try {
+    const newsupplier = new supplier(req.body);
+    await newsupplier.save();
+    res.status(200).json({ msg: 'Supplier added successful' });
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to add supplier', error: error.message });
+  }
+};
+
+exports.getsupplierbyid = async (req, res) => {
+  try {
+    const singlesupplier = await supplier.findById(req.params.id);
+
+    if (!singlesupplier) return res.status(404).json({ msg: 'Supplier not found' });
+
+    res.status(200).json(singlesupplier);
+  } catch (error) {
+    res.status(500).json({ msg: 'failed to fetch', error: error.message });
+  }
+};
+
+exports.getsupplier = async (req, res) => {
+  try {
+    const getsupplier = await supplier.find();
+    res.status(200).json(getsupplier);
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+};
+
+exports.updatesupplier = async (req, res) => {
+  try {
+    const updatesupplier = await supplier.findByIdAndUpdate(req.params.id, req.body, {
+      new: true,
+    });
+
+    if (!updatesupplier) return res.status(404).json({ msg: 'Supplier not found' });
+
+    res.status(200).json({ msg: 'updated successfully' });
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to update', error: error.message });
+  }
+};
+
+exports.deletesupplier = async (req, res) => {
+  try {
+    const deletesupplier = await supplier.findByIdAndDelete(req.params.id);
+
+    if (!deletesupplier) return res.status(404).json({ msg: 'Supplier not found' });
+
+    res.status(200).json({ msg: 'Deleted successfully' });
+  } catch (error) {
+    res.status(500).json({ msg: 'Failed to delete', error: error.message });
+  }
+};

package/projects/SCMS/backend/middleware/auth.js

@@ -0,0 +1,32 @@
+// this middleware is helping us to protect our routes so that only authenticated users can access the routes
+//it is checking if the user is authenticated by checking the token in the header(the header is the part of the request that contains the token)
+//if the user is not authenticated, it will return a 401 status code and a message that the user is not authorized
+//if the user is authenticated, it will return the user object
+//and the user object is the user that is authenticated
+
+const jwt = require('jsonwebtoken');
+const User = require('../models/User');
+const JWT_SECRET = 'change_this_to_a_long_random_secret';
+
+exports.protect = async (req, res, next) => {
+  try {
+    const header = req.headers.authorization;
+
+    if (!header || !header.startsWith('Bearer ')) {
+      return res.status(401).json({ message: 'Not authorized' });
+    }
+
+    const token = header.split(' ')[1];
+    const decoded = jwt.verify(token, JWT_SECRET);
+    const user = await User.findById(decoded.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' });
+  }
+};

package/projects/SCMS/backend/models/User.js

@@ -0,0 +1,28 @@
+const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema(
+  {
+    name: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    email: {
+      type: String,
+      required: true,
+      unique: true,
+      lowercase: true,
+      trim: true,
+    },
+    password: {
+      type: String,
+      required: true,
+      minlength: 6,
+    },
+  },
+  { timestamps: true }
+);
+
+const User = mongoose.model('User', userSchema);
+
+module.exports = User;

package/projects/SCMS/backend/models/delivery.js

@@ -0,0 +1,33 @@
+const mongoose = require('mongoose');
+
+const deliverySchema = new mongoose.Schema(
+  {
+    deliveryCode: {
+      type: String,
+      required: true,
+      trim: true,
+      unique: true,
+    },
+    deliveryDate: {
+      type: Date,
+      required: true,
+    },
+    quantityDelivered: {
+      type: Number,
+      required: true,
+    },
+    deliveryStatus: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    shipment: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Shipment',
+      required: false,
+    },
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model('Delivery', deliverySchema);

package/projects/SCMS/backend/models/product.js

@@ -0,0 +1,43 @@
+const mongoose = require('mongoose');
+const Supplier = require('./Supplier');
+
+const productSchema = new mongoose.Schema(
+  {
+    productCode: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    productName: {
+      type: String,
+      default: '',
+      trim: true,
+    },
+    category: {
+      type: String,
+      required: true,
+      trim: true
+    },
+
+    unitPrice: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    quantity: {
+      type: String,
+      required: true,
+      trim: true
+    },
+    expiryDate: {
+      type: String
+    },
+    Supplier: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Supplier'
+    }
+
+  }
+);
+
+module.exports = mongoose.model('Product', productSchema);

package/projects/SCMS/backend/models/shipment.js

@@ -0,0 +1,34 @@
+const mongoose = require('mongoose');
+
+const shipmentSchema = new mongoose.Schema(
+  {
+    shipmentNumber: {
+      type: String,
+      required: true,
+      trim: true,
+      unique: true,
+    },
+    shipmentDate: {
+      type: Date,
+      required: true,
+    },
+    shipmentStatus: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    destination: {
+      type: String,
+      required: true,
+      trim: true,
+    },
+    supplier: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: 'Supplier',
+      required: false,
+    },
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model('Shipment', shipmentSchema);