create-steve-rogers 1.0.0 → 1.0.2

package/apps/SIMS/backend/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "sims-backend",
+  "version": "1.0.0",
+  "main": "src/server.js",
+  "scripts": {
+    "dev": "nodemon src/server.js",
+    "start": "node src/server.js"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "connect-mongo": "^6.0.0",
+    "cors": "^2.8.6",
+    "dotenv": "^17.4.2",
+    "express": "^5.2.1",
+    "express-session": "^1.19.0",
+    "mongoose": "^9.5.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.14"
+  }
+}

package/apps/SIMS/backend/src/config/db.js

@@ -0,0 +1,9 @@
+const mongoose = require("mongoose");
+
+const connectDatabase = async () => {
+  const mongoUri = process.env.MONGO_URI || "mongodb://127.0.0.1:27017/sims";
+  await mongoose.connect(mongoUri);
+  console.log("MongoDB connected (SIMS database)");
+};
+
+module.exports = connectDatabase;

package/apps/SIMS/backend/src/controllers/authController.js

@@ -0,0 +1,93 @@
+const bcrypt = require("bcryptjs");
+const User = require("../models/User");
+const { strongPasswordError } = require("../utils/passwordPolicy");
+
+const normalize = (value) => String(value || "").trim();
+
+const register = async (req, res) => {
+  try {
+    const username = normalize(req.body.username);
+    const password = String(req.body.password || "");
+    if (!username || !password) {
+      return res.status(400).json({ message: "Username and password are required" });
+    }
+    if (username.length < 3) {
+      return res.status(400).json({ message: "Username must be at least 3 characters" });
+    }
+    const pwdErr = strongPasswordError(password);
+    if (pwdErr) {
+      return res.status(400).json({ message: pwdErr });
+    }
+    const existingUser = await User.findOne({ username });
+    if (existingUser) {
+      return res.status(409).json({ message: "Username already exists" });
+    }
+    const passwordHash = await bcrypt.hash(password, 10);
+    await User.create({ username, passwordHash });
+    return res.status(201).json({ message: "User created successfully" });
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+const login = async (req, res) => {
+  try {
+    const username = normalize(req.body.username);
+    const password = String(req.body.password || "");
+    if (!username || !password) {
+      return res.status(400).json({ message: "Username and password are required" });
+    }
+    const user = await User.findOne({ username });
+    if (!user) {
+      return res.status(401).json({ message: "Invalid credentials" });
+    }
+    const isValid = await bcrypt.compare(password, user.passwordHash);
+    if (!isValid) {
+      return res.status(401).json({ message: "Invalid credentials" });
+    }
+    req.session.userId = user._id;
+    req.session.username = user.username;
+    return res.json({ message: "Login successful", username: user.username });
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+const currentUser = (req, res) => {
+  if (!req.session.userId) {
+    return res.status(401).json({ message: "Unauthorized" });
+  }
+  return res.json({ username: req.session.username });
+};
+
+const logout = (req, res) => {
+  req.session.destroy(() => {
+    res.clearCookie("connect.sid");
+    res.json({ message: "Logged out" });
+  });
+};
+
+const recoverPassword = async (req, res) => {
+  try {
+    const username = normalize(req.body.username);
+    const newPassword = String(req.body.newPassword || "");
+    if (!username || !newPassword) {
+      return res.status(400).json({ message: "Username and new password are required" });
+    }
+    const pwdErr = strongPasswordError(newPassword);
+    if (pwdErr) {
+      return res.status(400).json({ message: pwdErr });
+    }
+    const user = await User.findOne({ username });
+    if (!user) {
+      return res.status(404).json({ message: "User not found" });
+    }
+    user.passwordHash = await bcrypt.hash(newPassword, 10);
+    await user.save();
+    return res.json({ message: "Password updated successfully" });
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+module.exports = { register, login, currentUser, logout, recoverPassword };

package/apps/SIMS/backend/src/controllers/simsReportController.js

@@ -0,0 +1,94 @@
+const SparePart = require("../models/SparePart");
+const StockIn = require("../models/StockIn");
+const StockOut = require("../models/StockOut");
+
+const dayRange = (dateStr) => {
+  const d = new Date(String(dateStr));
+  if (Number.isNaN(d.getTime())) return null;
+  const start = new Date(d);
+  start.setHours(0, 0, 0, 0);
+  const end = new Date(start);
+  end.setDate(end.getDate() + 1);
+  return { start, end };
+};
+
+const dailyStockStatus = async (req, res) => {
+  try {
+    const { date } = req.query;
+    if (!date) {
+      return res.status(400).json({ message: "date query (YYYY-MM-DD) is required" });
+    }
+    const range = dayRange(date);
+    if (!range) {
+      return res.status(400).json({ message: "Invalid date" });
+    }
+    const parts = await SparePart.find();
+    const rows = [];
+    for (const p of parts) {
+      const inSum = await StockIn.aggregate([
+        {
+          $match: {
+            sparePart: p._id,
+            stockInDate: { $gte: range.start, $lt: range.end },
+          },
+        },
+        { $group: { _id: null, total: { $sum: "$stockInQuantity" } } },
+      ]);
+      const outSum = await StockOut.aggregate([
+        {
+          $match: {
+            sparePart: p._id,
+            stockOutDate: { $gte: range.start, $lt: range.end },
+          },
+        },
+        { $group: { _id: null, total: { $sum: "$stockOutQuantity" } } },
+      ]);
+      const stockInDay = inSum[0]?.total || 0;
+      const stockOutDay = outSum[0]?.total || 0;
+      rows.push({
+        spareName: p.name,
+        category: p.category,
+        storedQuantity: p.quantity,
+        stockInQuantity: stockInDay,
+        stockOutQuantity: stockOutDay,
+        remainingQuantity: p.quantity,
+      });
+    }
+    return res.json(rows);
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+const dailyStockOut = async (req, res) => {
+  try {
+    const { date } = req.query;
+    if (!date) {
+      return res.status(400).json({ message: "date query (YYYY-MM-DD) is required" });
+    }
+    const range = dayRange(date);
+    if (!range) {
+      return res.status(400).json({ message: "Invalid date" });
+    }
+    const list = await StockOut.find({
+      stockOutDate: { $gte: range.start, $lt: range.end },
+    })
+      .populate("sparePart", "name category")
+      .sort({ stockOutDate: 1 });
+    return res.json(
+      list.map((r) => ({
+        id: r._id,
+        spareName: r.sparePart?.name || "",
+        category: r.sparePart?.category || "",
+        stockOutQuantity: r.stockOutQuantity,
+        stockOutUnitPrice: r.stockOutUnitPrice,
+        stockOutTotalPrice: r.stockOutTotalPrice,
+        stockOutDate: r.stockOutDate,
+      }))
+    );
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+module.exports = { dailyStockStatus, dailyStockOut };

package/apps/SIMS/backend/src/controllers/sparePartController.js

@@ -0,0 +1,41 @@
+const SparePart = require("../models/SparePart");
+const { recalcPartTotals } = require("../utils/sparePartHelpers");
+
+const create = async (req, res) => {
+  try {
+    const { name, category, quantity, unitPrice } = req.body;
+    if (!name || !category || quantity === undefined || unitPrice === undefined) {
+      return res.status(400).json({ message: "Name, category, quantity, and unit price are required" });
+    }
+    const q = Number(quantity);
+    const u = Number(unitPrice);
+    if (Number.isNaN(q) || q < 0 || Number.isNaN(u) || u < 0) {
+      return res.status(400).json({ message: "Invalid quantity or unit price" });
+    }
+    const t = q * u;
+    const part = await SparePart.create({
+      name: String(name).trim(),
+      category: String(category).trim(),
+      quantity: q,
+      unitPrice: u,
+      totalPrice: t,
+    });
+    return res.status(201).json(part);
+  } catch (error) {
+    if (error.code === 11000) {
+      return res.status(409).json({ message: "A spare part with this name and category already exists" });
+    }
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+const list = async (_req, res) => {
+  try {
+    const items = await SparePart.find().sort({ name: 1 });
+    return res.json(items);
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+module.exports = { create, list };

package/apps/SIMS/backend/src/controllers/stockInController.js

@@ -0,0 +1,45 @@
+const SparePart = require("../models/SparePart");
+const StockIn = require("../models/StockIn");
+const { recalcPartTotals } = require("../utils/sparePartHelpers");
+
+const create = async (req, res) => {
+  try {
+    const { sparePartId, stockInQuantity, stockInDate } = req.body;
+    if (!sparePartId || stockInQuantity === undefined || !stockInDate) {
+      return res.status(400).json({ message: "Spare part, stock-in quantity, and date are required" });
+    }
+    const qty = Number(stockInQuantity);
+    if (Number.isNaN(qty) || qty < 1) {
+      return res.status(400).json({ message: "Stock-in quantity must be at least 1" });
+    }
+    const part = await SparePart.findById(sparePartId);
+    if (!part) {
+      return res.status(404).json({ message: "Spare part not found" });
+    }
+    part.quantity += qty;
+    recalcPartTotals(part);
+    await part.save();
+
+    const record = await StockIn.create({
+      sparePart: sparePartId,
+      stockInQuantity: qty,
+      stockInDate: new Date(stockInDate),
+    });
+    return res.status(201).json(record);
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+const list = async (_req, res) => {
+  try {
+    const list = await StockIn.find()
+      .populate("sparePart", "name category")
+      .sort({ stockInDate: -1 });
+    return res.json(list);
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+module.exports = { create, list };

package/apps/SIMS/backend/src/controllers/stockOutController.js

@@ -0,0 +1,123 @@
+const SparePart = require("../models/SparePart");
+const StockOut = require("../models/StockOut");
+const { recalcPartTotals } = require("../utils/sparePartHelpers");
+
+const create = async (req, res) => {
+  try {
+    const { sparePartId, stockOutQuantity, stockOutUnitPrice, stockOutDate } = req.body;
+    if (!sparePartId || stockOutQuantity === undefined || stockOutUnitPrice === undefined || !stockOutDate) {
+      return res
+        .status(400)
+        .json({ message: "Spare part, quantity, unit price, and date are required" });
+    }
+    const qty = Number(stockOutQuantity);
+    const unit = Number(stockOutUnitPrice);
+    if (Number.isNaN(qty) || qty < 1) {
+      return res.status(400).json({ message: "Invalid stock-out quantity" });
+    }
+    if (Number.isNaN(unit) || unit < 0) {
+      return res.status(400).json({ message: "Invalid unit price" });
+    }
+    const part = await SparePart.findById(sparePartId);
+    if (!part) {
+      return res.status(404).json({ message: "Spare part not found" });
+    }
+    if (part.quantity < qty) {
+      return res.status(400).json({ message: "Not enough quantity in stock" });
+    }
+    part.quantity -= qty;
+    recalcPartTotals(part);
+    await part.save();
+    const total = qty * unit;
+    const record = await StockOut.create({
+      sparePart: sparePartId,
+      stockOutQuantity: qty,
+      stockOutUnitPrice: unit,
+      stockOutTotalPrice: total,
+      stockOutDate: new Date(stockOutDate),
+    });
+    return res.status(201).json(record);
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+const list = async (_req, res) => {
+  try {
+    const list = await StockOut.find()
+      .populate("sparePart", "name category")
+      .sort({ stockOutDate: -1 });
+    return res.json(list);
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+const update = async (req, res) => {
+  try {
+    const current = await StockOut.findById(req.params.id);
+    if (!current) {
+      return res.status(404).json({ message: "Stock out not found" });
+    }
+    const part = await SparePart.findById(current.sparePart);
+    if (!part) {
+      return res.status(404).json({ message: "Spare part not found" });
+    }
+    part.quantity += current.stockOutQuantity;
+    recalcPartTotals(part);
+
+    const qty = Number(req.body.stockOutQuantity);
+    const unit = Number(req.body.stockOutUnitPrice);
+    const failRestore = async () => {
+      part.quantity -= current.stockOutQuantity;
+      recalcPartTotals(part);
+      await part.save();
+    };
+    if (Number.isNaN(qty) || qty < 1) {
+      await failRestore();
+      return res.status(400).json({ message: "Invalid stock-out quantity" });
+    }
+    if (Number.isNaN(unit) || unit < 0) {
+      await failRestore();
+      return res.status(400).json({ message: "Invalid unit price" });
+    }
+    if (part.quantity < qty) {
+      await failRestore();
+      return res.status(400).json({ message: "Not enough quantity in stock" });
+    }
+    part.quantity -= qty;
+    recalcPartTotals(part);
+    await part.save();
+    if (req.body.stockOutDate) {
+      current.stockOutDate = new Date(req.body.stockOutDate);
+    }
+    current.stockOutQuantity = qty;
+    current.stockOutUnitPrice = unit;
+    current.stockOutTotalPrice = qty * unit;
+    await current.save();
+    return res.json(current);
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+const remove = async (req, res) => {
+  try {
+    const current = await StockOut.findById(req.params.id);
+    if (!current) {
+      return res.status(404).json({ message: "Stock out not found" });
+    }
+    const part = await SparePart.findById(current.sparePart);
+    if (part) {
+      part.quantity += current.stockOutQuantity;
+      recalcPartTotals(part);
+      await part.save();
+    }
+    await StockOut.findByIdAndDelete(req.params.id);
+    return res.json({ message: "Stock out removed" });
+  } catch (error) {
+    return res.status(500).json({ message: error.message });
+  }
+};
+
+module.exports = { create, list, update, remove };

package/apps/SIMS/backend/src/middleware/auth.js

@@ -0,0 +1,8 @@
+const requireAuth = (req, res, next) => {
+  if (!req.session.userId) {
+    return res.status(401).json({ message: "Unauthorized" });
+  }
+  return next();
+};
+
+module.exports = requireAuth;

package/apps/SIMS/backend/src/models/SparePart.js

@@ -0,0 +1,17 @@
+const mongoose = require("mongoose");
+
+const sparePartSchema = new mongoose.Schema(
+  {
+    name: { type: String, required: true, trim: true },
+    category: { type: String, required: true, trim: true },
+    quantity: { type: Number, required: true, min: 0, default: 0 },
+    unitPrice: { type: Number, required: true, min: 0 },
+    totalPrice: { type: Number, required: true, min: 0 },
+  },
+  { timestamps: true }
+);
+
+// Helps satisfy “duplicate data entry is eliminated” (assessment checklist 2.12)
+sparePartSchema.index({ name: 1, category: 1 }, { unique: true });
+
+module.exports = mongoose.model("SparePart", sparePartSchema);

package/apps/SIMS/backend/src/models/StockIn.js

@@ -0,0 +1,16 @@
+const mongoose = require("mongoose");
+
+const stockInSchema = new mongoose.Schema(
+  {
+    sparePart: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "SparePart",
+      required: true,
+    },
+    stockInQuantity: { type: Number, required: true, min: 1 },
+    stockInDate: { type: Date, required: true },
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model("StockIn", stockInSchema);

package/apps/SIMS/backend/src/models/StockOut.js

@@ -0,0 +1,18 @@
+const mongoose = require("mongoose");
+
+const stockOutSchema = new mongoose.Schema(
+  {
+    sparePart: {
+      type: mongoose.Schema.Types.ObjectId,
+      ref: "SparePart",
+      required: true,
+    },
+    stockOutQuantity: { type: Number, required: true, min: 1 },
+    stockOutUnitPrice: { type: Number, required: true, min: 0 },
+    stockOutTotalPrice: { type: Number, required: true, min: 0 },
+    stockOutDate: { type: Date, required: true },
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model("StockOut", stockOutSchema);

package/apps/SIMS/backend/src/models/User.js

@@ -0,0 +1,11 @@
+const mongoose = require("mongoose");
+
+const userSchema = new mongoose.Schema(
+  {
+    username: { type: String, required: true, unique: true, trim: true },
+    passwordHash: { type: String, required: true },
+  },
+  { timestamps: true }
+);
+
+module.exports = mongoose.model("User", userSchema);

package/apps/SIMS/backend/src/routes/authRoutes.js

@@ -0,0 +1,12 @@
+const express = require("express");
+const authController = require("../controllers/authController");
+
+const router = express.Router();
+
+router.post("/register", authController.register);
+router.post("/login", authController.login);
+router.get("/me", authController.currentUser);
+router.post("/logout", authController.logout);
+router.post("/recover", authController.recoverPassword);
+
+module.exports = router;

package/apps/SIMS/backend/src/routes/simsReportRoutes.js

@@ -0,0 +1,8 @@
+const express = require("express");
+const simsReportController = require("../controllers/simsReportController");
+const requireAuth = require("../middleware/auth");
+
+const router = express.Router();
+router.get("/daily-stock-status", requireAuth, simsReportController.dailyStockStatus);
+router.get("/daily-stockout", requireAuth, simsReportController.dailyStockOut);
+module.exports = router;

package/apps/SIMS/backend/src/routes/sparePartRoutes.js

@@ -0,0 +1,8 @@
+const express = require("express");
+const sparePartController = require("../controllers/sparePartController");
+const requireAuth = require("../middleware/auth");
+
+const router = express.Router();
+router.post("/", requireAuth, sparePartController.create);
+router.get("/", requireAuth, sparePartController.list);
+module.exports = router;

package/apps/SIMS/backend/src/routes/stockInRoutes.js

@@ -0,0 +1,8 @@
+const express = require("express");
+const stockInController = require("../controllers/stockInController");
+const requireAuth = require("../middleware/auth");
+
+const router = express.Router();
+router.post("/", requireAuth, stockInController.create);
+router.get("/", requireAuth, stockInController.list);
+module.exports = router;

package/apps/SIMS/backend/src/routes/stockOutRoutes.js

@@ -0,0 +1,10 @@
+const express = require("express");
+const stockOutController = require("../controllers/stockOutController");
+const requireAuth = require("../middleware/auth");
+
+const router = express.Router();
+router.post("/", requireAuth, stockOutController.create);
+router.get("/", requireAuth, stockOutController.list);
+router.put("/:id", requireAuth, stockOutController.update);
+router.delete("/:id", requireAuth, stockOutController.remove);
+module.exports = router;

package/apps/SIMS/backend/src/server.js

@@ -0,0 +1,62 @@
+const express = require("express");
+const cors = require("cors");
+const session = require("express-session");
+const connectMongo = require("connect-mongo");
+const dotenv = require("dotenv");
+const connectDatabase = require("./config/db");
+const authRoutes = require("./routes/authRoutes");
+const sparePartRoutes = require("./routes/sparePartRoutes");
+const stockInRoutes = require("./routes/stockInRoutes");
+const stockOutRoutes = require("./routes/stockOutRoutes");
+const simsReportRoutes = require("./routes/simsReportRoutes");
+
+dotenv.config();
+
+const app = express();
+const PORT = process.env.PORT || 5001;
+const FRONTEND_URL = process.env.FRONTEND_URL || "http://localhost:5174";
+const MongoStore = connectMongo.default || connectMongo.MongoStore || connectMongo;
+const MONGO_URI = process.env.MONGO_URI || "mongodb://127.0.0.1:27017/sims";
+
+app.use(
+  cors({
+    origin: FRONTEND_URL,
+    credentials: true,
+  })
+);
+app.use(express.json());
+app.set("trust proxy", 1);
+app.use(
+  session({
+    name: "sims.sid",
+    secret: process.env.SESSION_SECRET || "sims-exam-secret",
+    resave: false,
+    saveUninitialized: false,
+    store: MongoStore.create({ mongoUrl: MONGO_URI }),
+    cookie: {
+      httpOnly: true,
+      sameSite: "lax",
+      maxAge: 1000 * 60 * 60 * 8,
+    },
+  })
+);
+
+app.get("/api/health", (_req, res) => {
+  res.json({ message: "SIMS API is running" });
+});
+app.use("/api/auth", authRoutes);
+app.use("/api/spare-parts", sparePartRoutes);
+app.use("/api/stock-in", stockInRoutes);
+app.use("/api/stock-out", stockOutRoutes);
+app.use("/api/reports", simsReportRoutes);
+
+connectDatabase()
+  .then(() => {
+    app.listen(PORT, () => {
+      console.log(`SIMS server running on port ${PORT}`);
+    });
+  })
+  .catch((error) => {
+    console.error("Failed to start server:", error.message);
+    process.exit(1);
+  });

package/apps/SIMS/backend/src/utils/passwordPolicy.js

@@ -0,0 +1,10 @@
+const strongPasswordError = (password) => {
+  const p = String(password || "");
+  if (p.length < 8) return "Password must be at least 8 characters (strong password required)";
+  if (!/[A-Z]/.test(p)) return "Password must include an uppercase letter";
+  if (!/[a-z]/.test(p)) return "Password must include a lowercase letter";
+  if (!/[0-9]/.test(p)) return "Password must include a number";
+  return null;
+};
+
+module.exports = { strongPasswordError };

package/apps/SIMS/backend/src/utils/sparePartHelpers.js

@@ -0,0 +1,5 @@
+const recalcPartTotals = (part) => {
+  part.totalPrice = part.quantity * part.unitPrice;
+};
+
+module.exports = { recalcPartTotals };