create-ishvexa-app 1.0.0

package/templates/sims-app/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/templates/sims-app/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/templates/sims-app/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/templates/sims-app/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/templates/sims-app/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/templates/sims-app/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/templates/sims-app/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/templates/sims-app/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/templates/sims-app/backend/src/models/User.js

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

package/templates/sims-app/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("/forgot-password", authController.forgotPassword);
+
+module.exports = router;

package/templates/sims-app/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/templates/sims-app/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/templates/sims-app/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/templates/sims-app/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/templates/sims-app/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/templates/sims-app/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/templates/sims-app/backend/src/utils/sparePartHelpers.js

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

package/templates/sims-app/frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>SIMS — Stock Inventory</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

package/templates/sims-app/frontend/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "sims-frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint .",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@tailwindcss/vite": "^4.2.4",
+    "axios": "^1.15.2",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "react-router-dom": "^7.14.2",
+    "tailwindcss": "^4.2.4"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.1",
+    "eslint": "^10.2.0",
+    "eslint-plugin-react-hooks": "^7.1.1",
+    "eslint-plugin-react-refresh": "^0.5.2",
+    "globals": "^17.5.0",
+    "vite": "^8.0.10"
+  }
+}

package/templates/sims-app/frontend/src/App.jsx

@@ -0,0 +1,110 @@
+import { useEffect, useState } from "react";
+import { Navigate, Route, Routes } from "react-router-dom";
+import AppLayout from "./components/AppLayout";
+import LoginPage from "./pages/LoginPage";
+import RegisterPage from "./pages/RegisterPage";
+import ForgotPassword from "./pages/ForgotPassword";
+import SparePartPage from "./pages/SparePartPage";
+import StockInPage from "./pages/StockInPage";
+import StockOutPage from "./pages/StockOutPage";
+import ReportsPage from "./pages/ReportsPage";
+import { fetchCurrentUser, logoutUser } from "./api/authApi";
+
+function ProtectedLayout({ isAuthenticated, username, onLogout }) {
+  if (!isAuthenticated) {
+    return <Navigate to="/login" replace />;
+  }
+  return <AppLayout onLogout={onLogout} username={username} />;
+}
+
+function PublicRoute({ isAuthenticated, children }) {
+  if (isAuthenticated) {
+    return <Navigate to="/spare-part" replace />;
+  }
+  return children;
+}
+
+function App() {
+  const [isAuthenticated, setIsAuthenticated] = useState(false);
+  const [username, setUsername] = useState("");
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    (async () => {
+      try {
+        const r = await fetchCurrentUser();
+        setIsAuthenticated(true);
+        setUsername(r.data.username);
+      } catch {
+        setIsAuthenticated(false);
+      } finally {
+        setLoading(false);
+      }
+    })();
+  }, []);
+
+  const handleLogout = async () => {
+    await logoutUser();
+    setIsAuthenticated(false);
+    setUsername("");
+  };
+
+  if (loading) {
+    return <div className="p-8 text-center text-slate-600">Checking session…</div>;
+  }
+
+  return (
+    <Routes>
+      <Route
+        path="/login"
+        element={
+          <PublicRoute isAuthenticated={isAuthenticated}>
+            <LoginPage
+              onLoginSuccess={(name) => {
+                setIsAuthenticated(true);
+                setUsername(name);
+              }}
+            />
+          </PublicRoute>
+        }
+      />
+      <Route
+        path="/register"
+        element={
+          <PublicRoute isAuthenticated={isAuthenticated}>
+            <RegisterPage />
+          </PublicRoute>
+        }
+      />
+      <Route
+        path="/forgot-password"
+        element={
+          <PublicRoute isAuthenticated={isAuthenticated}>
+            <ForgotPassword />
+          </PublicRoute>
+        }
+      />
+      <Route
+        element={
+          <ProtectedLayout
+            isAuthenticated={isAuthenticated}
+            username={username}
+            onLogout={handleLogout}
+          />
+        }
+      >
+        <Route path="/spare-part" element={<SparePartPage />} />
+        <Route path="/stock-in" element={<StockInPage />} />
+        <Route path="/stock-out" element={<StockOutPage />} />
+        <Route path="/reports" element={<ReportsPage />} />
+        <Route path="/" element={<Navigate to="/spare-part" replace />} />
+      </Route>
+      <Route
+        path="*"
+        element={<Navigate to={isAuthenticated ? "/spare-part" : "/login"} replace />}
+      />
+    </Routes>
+  );
+}
+
+export default App;