create-ishvexa-app 1.0.0

package/templates/stockhub-sms-app/README.md

@@ -0,0 +1,82 @@
+# Stock Management System (SMS)
+
+National Practical Exam Project
+
+## Installation
+
+```bash
+cd backend-mysql && npm install
+cd ../backend-mongodb && npm install
+cd ../frontend && npm install
+```
+
+## Database Setup (MySQL)
+
+```bash
+cd backend-mysql
+cp .env.example .env
+npm run db:init
+```
+
+## Run Development Server
+
+MySQL API (port 5555):
+
+```bash
+cd backend-mysql && npm run dev
+```
+
+MongoDB API (port 5555 — run one backend at a time):
+
+```bash
+cd backend-mongodb && npm run dev
+```
+
+Frontend (port 5173):
+
+```bash
+cd frontend && npm run dev
+```
+
+Default login: `admin` / `admin123`
+
+## Environment Variables
+
+### backend-mysql
+
+| Variable | Description |
+|----------|-------------|
+| PORT | API port (5555) |
+| JWT_SECRET | Secret for JWT tokens |
+| DB_HOST | MySQL host |
+| DB_USER | MySQL user |
+| DB_PASSWORD | MySQL password |
+| DB_NAME | Database name (SMS) |
+| DB_PORT | MySQL port |
+
+### backend-mongodb
+
+| Variable | Description |
+|----------|-------------|
+| PORT | API port (5555) |
+| JWT_SECRET | Secret for JWT tokens |
+| MONGO_URI | MongoDB connection string |
+
+## API Endpoints
+
+- POST /api/auth/register
+- POST /api/auth/login
+- GET/POST /api/products
+- GET/POST /api/warehouses
+- GET/POST/PUT/DELETE /api/transactions
+- GET /api/reports?period=daily|weekly|monthly&date=&startDate=&endDate=&month=
+
+## Folder Structure
+
+```
+stockhub-sms/
+├── README.md
+├── frontend/
+├── backend-mysql/
+└── backend-mongodb/
+```

package/templates/stockhub-sms-app/backend-mongodb/.env

@@ -0,0 +1,3 @@
+PORT=5555
+JWT_SECRET=exam_jwt_secret_change_in_production
+MONGO_URI=mongodb://localhost:27017/SMS

package/templates/stockhub-sms-app/backend-mongodb/.env.example

@@ -0,0 +1,3 @@
+PORT=5555
+JWT_SECRET=exam_jwt_secret_change_in_production
+MONGO_URI=mongodb://localhost:27017/SMS

package/templates/stockhub-sms-app/backend-mongodb/config/db.js

@@ -0,0 +1,29 @@
+import mongoose from "mongoose";
+import dotenv from "dotenv";
+import User from "../models/User.js";
+
+dotenv.config();
+
+const ADMIN_HASH = "$2b$10$aULsUjp9bb9lf5CZZyY.7./KhwsocVO0duyPlqu0Qnte75xHBdG5C";
+
+export const connectDatabase = async () => {
+  try {
+    await mongoose.connect(process.env.MONGO_URI || "mongodb://localhost:27017/SMS");
+    console.log("Database Connected Successfully");
+    const count = await User.countDocuments();
+    if (count === 0) {
+      await User.create({
+        username: "admin",
+        email: "admin@exam.local",
+        password: ADMIN_HASH,
+      });
+    }
+    return true;
+  } catch (error) {
+    console.log("Database Connection Failed");
+    console.error(error.message);
+    return false;
+  }
+};
+
+export default mongoose;

package/templates/stockhub-sms-app/backend-mongodb/controllers/authController.js

@@ -0,0 +1,93 @@
+import bcrypt from "bcryptjs";
+import jwt from "jsonwebtoken";
+import User from "../models/User.js";
+
+const signToken = (user) =>
+  jwt.sign(
+    { id: user._id, username: user.username },
+    process.env.JWT_SECRET || "exam_secret",
+    { expiresIn: "8h" }
+  );
+
+const normalizeEmail = (email) => String(email || "").trim().toLowerCase();
+
+export const register = async (req, res) => {
+  try {
+    const { username, email, password } = req.body;
+    if (!username || !email || !password) {
+      return res.status(400).json({ message: "Username, email and password are required." });
+    }
+    const emailNorm = normalizeEmail(email);
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(emailNorm)) {
+      return res.status(400).json({ message: "Enter a valid email address." });
+    }
+    const existingUser = await User.findOne({ username: username.trim() });
+    if (existingUser) {
+      return res.status(409).json({ message: "Username already exists." });
+    }
+    const existingEmail = await User.findOne({ email: emailNorm });
+    if (existingEmail) {
+      return res.status(409).json({ message: "Email already registered." });
+    }
+    const hash = await bcrypt.hash(password, 10);
+    await User.create({ username: username.trim(), email: emailNorm, password: hash });
+    return res.status(201).json({ message: "Account created successfully." });
+  } catch {
+    return res.status(500).json({ message: "Server error during registration." });
+  }
+};
+
+export const login = async (req, res) => {
+  try {
+    const { username, password } = req.body;
+    if (!username || !password) {
+      return res.status(400).json({ message: "Username and password are required." });
+    }
+    const user = await User.findOne({ username: username.trim() });
+    if (!user) {
+      return res.status(401).json({ message: "Invalid credentials." });
+    }
+    const match = await bcrypt.compare(password, user.password);
+    if (!match) {
+      return res.status(401).json({ message: "Invalid credentials." });
+    }
+    return res.json({
+      message: "Login successful.",
+      token: signToken(user),
+      user: { id: user._id, username: user.username, email: user.email },
+    });
+  } catch {
+    return res.status(500).json({ message: "Server error during login." });
+  }
+};
+
+export const forgotPassword = async (req, res) => {
+  try {
+    const { email, newPassword, confirmPassword } = req.body;
+    if (!email) {
+      return res.status(400).json({ success: false, message: "Email is required." });
+    }
+    if (!newPassword) {
+      return res.status(400).json({ success: false, message: "New password is required." });
+    }
+    if (!confirmPassword) {
+      return res.status(400).json({ success: false, message: "Confirm password is required." });
+    }
+    if (newPassword !== confirmPassword) {
+      return res.status(400).json({
+        success: false,
+        message: "New password and confirm password must match.",
+      });
+    }
+    const emailNorm = normalizeEmail(email);
+    const user = await User.findOne({ email: emailNorm });
+    if (!user) {
+      return res.status(404).json({ success: false, message: "User not found" });
+    }
+    user.password = await bcrypt.hash(newPassword, 10);
+    await user.save();
+    return res.json({ success: true, message: "Password reset successfully" });
+  } catch {
+    return res.status(500).json({ success: false, message: "Server error." });
+  }
+};

package/templates/stockhub-sms-app/backend-mongodb/controllers/productController.js

@@ -0,0 +1,29 @@
+import Product from "../models/Product.js";
+
+export const create = async (req, res) => {
+  try {
+    if (req.body.productCode === undefined || req.body.productCode === "") return res.status(400).json({ message: "Product Code is required." });
+    if (req.body.productName === undefined || req.body.productName === "") return res.status(400).json({ message: "Product Name is required." });
+    if (req.body.category === undefined || req.body.category === "") return res.status(400).json({ message: "Category is required." });
+    if (req.body.quantityInStock === undefined || req.body.quantityInStock === "") return res.status(400).json({ message: "Quantity In Stock is required." });
+    if (req.body.unitPrice === undefined || req.body.unitPrice === "") return res.status(400).json({ message: "Unit Price is required." });
+    if (req.body.supplierName === undefined || req.body.supplierName === "") return res.status(400).json({ message: "Supplier Name is required." });
+    if (req.body.dateReceived === undefined || req.body.dateReceived === "") return res.status(400).json({ message: "Date Received is required." });
+    await Product.create({ product_code: req.body.productCode, product_name: req.body.productName, category: req.body.category, quantity_in_stock: req.body.quantityInStock, unit_price: req.body.unitPrice, supplier_name: req.body.supplierName, date_received: req.body.dateReceived });
+    return res.status(201).json({ message: "Product added successfully." });
+  } catch (error) {
+    if (error.code === 11000) {
+      return res.status(409).json({ message: "Product already exists." });
+    }
+    return res.status(500).json({ message: "Failed to add product." });
+  }
+};
+
+export const getAll = async (_req, res) => {
+  try {
+    const rows = await Product.find().sort({ product_code: -1 }).lean();
+    return res.json(rows.map((r) => { const { _id, __v, ...rest } = r; return rest; }));
+  } catch {
+    return res.status(500).json({ message: "Failed to fetch product records." });
+  }
+};

package/templates/stockhub-sms-app/backend-mongodb/controllers/reportController.js

@@ -0,0 +1,53 @@
+const clean = (rows) => rows.map((r) => { const { _id, __v, ...rest } = r; return rest; });
+
+const monthBounds = (month) => {
+  const start = new Date(`${month}-01T00:00:00`);
+  const end = new Date(start.getFullYear(), start.getMonth() + 1, 0, 23, 59, 59, 999);
+  return { start, end };
+};
+
+import Product from "../models/Product.js";
+import Warehouse from "../models/Warehouse.js";
+import StockTransaction from "../models/StockTransaction.js";
+
+export const getReports = async (req, res) => {
+  try {
+    const period = req.query.period || "daily";
+    const date = req.query.date || new Date().toISOString().slice(0, 10);
+    const startDate = req.query.startDate;
+    const endDate = req.query.endDate;
+    const month = req.query.month || date.slice(0, 7);
+
+    const products = clean(await Product.find().lean());
+    const warehouses = clean(await Warehouse.find().lean());
+
+    let stockIn;
+    let stockOut;
+
+    if (period === "daily") {
+      const start = new Date(`${date}T00:00:00`);
+      const end = new Date(`${date}T23:59:59`);
+      const range = { $gte: start, $lte: end };
+      stockIn = clean(await StockTransaction.find({ transaction_type: "IN", transaction_date: range }).lean());
+      stockOut = clean(await StockTransaction.find({ transaction_type: "OUT", transaction_date: range }).lean());
+    } else if (period === "weekly") {
+      if (!startDate || !endDate) {
+        return res.status(400).json({ message: "Start date and end date are required for weekly reports." });
+      }
+      const start = new Date(`${startDate}T00:00:00`);
+      const end = new Date(`${endDate}T23:59:59`);
+      const range = { $gte: start, $lte: end };
+      stockIn = clean(await StockTransaction.find({ transaction_type: "IN", transaction_date: range }).lean());
+      stockOut = clean(await StockTransaction.find({ transaction_type: "OUT", transaction_date: range }).lean());
+    } else {
+      const { start, end } = monthBounds(month);
+      const range = { $gte: start, $lte: end };
+      stockIn = clean(await StockTransaction.find({ transaction_type: "IN", transaction_date: range }).lean());
+      stockOut = clean(await StockTransaction.find({ transaction_type: "OUT", transaction_date: range }).lean());
+    }
+
+    return res.json({ period, reports: { products, warehouses, stockIn, stockOut } });
+  } catch {
+    return res.status(500).json({ message: "Failed to generate reports." });
+  }
+};

package/templates/stockhub-sms-app/backend-mongodb/controllers/transactionController.js

@@ -0,0 +1,74 @@
+import StockTransaction from "../models/StockTransaction.js";
+import Product from "../models/Product.js";
+import Warehouse from "../models/Warehouse.js";
+
+const validateRefs = async (productCode, warehouseCode) => {
+  const product = await Product.findOne({ product_code: productCode });
+  if (!product) return "Selected product does not exist.";
+  const warehouse = await Warehouse.findOne({ warehouse_code: warehouseCode });
+  if (!warehouse) return "Selected warehouse does not exist.";
+  return null;
+};
+
+export const create = async (req, res) => {
+  try {
+    if (req.body.transactionDate === undefined || req.body.transactionDate === "") return res.status(400).json({ message: "Transaction Date is required." });
+    if (req.body.quantityMoved === undefined || req.body.quantityMoved === "") return res.status(400).json({ message: "Quantity Moved is required." });
+    if (req.body.transactionType === undefined || req.body.transactionType === "") return res.status(400).json({ message: "Type (IN/OUT) is required." });
+    if (req.body.productCode === undefined || req.body.productCode === "") return res.status(400).json({ message: "Product Code is required." });
+    if (req.body.warehouseCode === undefined || req.body.warehouseCode === "") return res.status(400).json({ message: "Warehouse Code is required." });
+    const refError = await validateRefs(req.body.productCode, req.body.warehouseCode);
+    if (refError) return res.status(400).json({ message: refError });
+    await StockTransaction.create({ transaction_date: req.body.transactionDate, quantity_moved: req.body.quantityMoved, transaction_type: req.body.transactionType, product_code: req.body.productCode, warehouse_code: req.body.warehouseCode });
+    return res.status(201).json({ message: "Transaction added successfully." });
+  } catch (error) {
+    if (error.code === 11000) {
+      return res.status(409).json({ message: "Transaction already exists." });
+    }
+    return res.status(500).json({ message: "Failed to add transaction." });
+  }
+};
+
+export const getAll = async (_req, res) => {
+  try {
+    const rows = await StockTransaction.find().sort({ transaction_id: -1 }).lean();
+    return res.json(rows.map((r) => { const { _id, __v, ...rest } = r; return rest; }));
+  } catch {
+    return res.status(500).json({ message: "Failed to fetch transaction records." });
+  }
+};
+
+export const update = async (req, res) => {
+  try {
+    if (req.body.transactionDate === undefined || req.body.transactionDate === "") return res.status(400).json({ message: "Transaction Date is required." });
+    if (req.body.quantityMoved === undefined || req.body.quantityMoved === "") return res.status(400).json({ message: "Quantity Moved is required." });
+    if (req.body.transactionType === undefined || req.body.transactionType === "") return res.status(400).json({ message: "Type (IN/OUT) is required." });
+    if (req.body.productCode === undefined || req.body.productCode === "") return res.status(400).json({ message: "Product Code is required." });
+    if (req.body.warehouseCode === undefined || req.body.warehouseCode === "") return res.status(400).json({ message: "Warehouse Code is required." });
+    const refError = await validateRefs(req.body.productCode, req.body.warehouseCode);
+    if (refError) return res.status(400).json({ message: refError });
+    const updated = await StockTransaction.findOneAndUpdate(
+      { transaction_id: req.params.id },
+      { transaction_date: req.body.transactionDate, quantity_moved: req.body.quantityMoved, transaction_type: req.body.transactionType, product_code: req.body.productCode, warehouse_code: req.body.warehouseCode },
+      { new: true }
+    );
+    if (!updated) {
+      return res.status(404).json({ message: "Transaction not found." });
+    }
+    return res.json({ message: "Transaction updated successfully." });
+  } catch {
+    return res.status(500).json({ message: "Failed to update transaction." });
+  }
+};
+
+export const remove = async (req, res) => {
+  try {
+    const deleted = await StockTransaction.findOneAndDelete({ transaction_id: req.params.id });
+    if (!deleted) {
+      return res.status(404).json({ message: "Transaction not found." });
+    }
+    return res.json({ message: "Transaction deleted successfully." });
+  } catch {
+    return res.status(500).json({ message: "Failed to delete transaction." });
+  }
+};

package/templates/stockhub-sms-app/backend-mongodb/controllers/warehouseController.js

@@ -0,0 +1,25 @@
+import Warehouse from "../models/Warehouse.js";
+
+export const create = async (req, res) => {
+  try {
+    if (req.body.warehouseCode === undefined || req.body.warehouseCode === "") return res.status(400).json({ message: "Warehouse Code is required." });
+    if (req.body.warehouseName === undefined || req.body.warehouseName === "") return res.status(400).json({ message: "Warehouse Name is required." });
+    if (req.body.warehouseLocation === undefined || req.body.warehouseLocation === "") return res.status(400).json({ message: "Location is required." });
+    await Warehouse.create({ warehouse_code: req.body.warehouseCode, warehouse_name: req.body.warehouseName, warehouse_location: req.body.warehouseLocation });
+    return res.status(201).json({ message: "Warehouse added successfully." });
+  } catch (error) {
+    if (error.code === 11000) {
+      return res.status(409).json({ message: "Warehouse already exists." });
+    }
+    return res.status(500).json({ message: "Failed to add warehouse." });
+  }
+};
+
+export const getAll = async (_req, res) => {
+  try {
+    const rows = await Warehouse.find().sort({ warehouse_code: -1 }).lean();
+    return res.json(rows.map((r) => { const { _id, __v, ...rest } = r; return rest; }));
+  } catch {
+    return res.status(500).json({ message: "Failed to fetch warehouse records." });
+  }
+};

package/templates/stockhub-sms-app/backend-mongodb/middleware/auth.js

@@ -0,0 +1,16 @@
+import jwt from "jsonwebtoken";
+
+const auth = (req, res, next) => {
+  const header = req.headers.authorization;
+  if (!header || !header.startsWith("Bearer ")) {
+    return res.status(401).json({ message: "Authentication required." });
+  }
+  try {
+    req.user = jwt.verify(header.split(" ")[1], process.env.JWT_SECRET || "exam_secret");
+    next();
+  } catch {
+    return res.status(401).json({ message: "Invalid or expired token." });
+  }
+};
+
+export default auth;

package/templates/stockhub-sms-app/backend-mongodb/models/Counter.js

@@ -0,0 +1,13 @@
+import mongoose from "mongoose";
+
+const counterSchema = new mongoose.Schema({
+  _id: { type: String, required: true },
+  seq: { type: Number, default: 0 },
+});
+
+counterSchema.statics.getNext = async function (name) {
+  const doc = await this.findByIdAndUpdate(name, { $inc: { seq: 1 } }, { new: true, upsert: true });
+  return doc.seq;
+};
+
+export default mongoose.model("Counter", counterSchema);

package/templates/stockhub-sms-app/backend-mongodb/models/Product.js

@@ -0,0 +1,16 @@
+import mongoose from "mongoose";
+
+
+const schema = new mongoose.Schema({
+  product_code: { type: String, required: true, unique: true },
+  product_name: { type: String, required: true },
+  category: { type: String, required: true },
+  quantity_in_stock: { type: Number, required: true },
+  unit_price: { type: Number, required: true },
+  supplier_name: { type: String, required: true },
+  date_received: { type: Date, required: true }
+}, { collection: "products" });
+
+
+
+export default mongoose.model("Product", schema);

package/templates/stockhub-sms-app/backend-mongodb/models/StockTransaction.js

@@ -0,0 +1,19 @@
+import mongoose from "mongoose";
+import Counter from "./Counter.js";
+
+const schema = new mongoose.Schema({
+  transaction_id: { type: Number, unique: true },
+  transaction_date: { type: Date, required: true },
+  quantity_moved: { type: Number, required: true },
+  transaction_type: { type: String, required: true },
+  product_code: { type: String, required: true },
+  warehouse_code: { type: String, required: true }
+}, { collection: "stock_transactions" });
+
+schema.pre("save", async function () {
+  if (this.isNew && (this.transaction_id === undefined || this.transaction_id === null)) {
+    this.transaction_id = await Counter.getNext("transaction_id");
+  }
+});
+
+export default mongoose.model("StockTransaction", schema);

package/templates/stockhub-sms-app/backend-mongodb/models/User.js

@@ -0,0 +1,9 @@
+import mongoose from "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 },
+  password: { type: String, required: true },
+});
+
+export default mongoose.model("User", userSchema);

package/templates/stockhub-sms-app/backend-mongodb/models/Warehouse.js

@@ -0,0 +1,12 @@
+import mongoose from "mongoose";
+
+
+const schema = new mongoose.Schema({
+  warehouse_code: { type: String, required: true, unique: true },
+  warehouse_name: { type: String, required: true },
+  warehouse_location: { type: String, required: true }
+}, { collection: "warehouses" });
+
+
+
+export default mongoose.model("Warehouse", schema);