react-node-app 1.0.0

package/.gitignore

@@ -0,0 +1,6 @@
+node_modules/
+dist/
+.env
+*.log
+.DS_Store
+Thumbs.db

package/backend-project/config/db.js

@@ -0,0 +1,13 @@
+const mongoose = require('mongoose');
+
+const connectDB = async () => {
+  try {
+    const conn = await mongoose.connect(process.env.MONGO_URI);
+    console.log(`MongoDB Connected: ${conn.connection.host}`);
+  } catch (error) {
+    console.error(`MongoDB Connection Error: ${error.message}`);
+    process.exit(1);
+  }
+};
+
+module.exports = connectDB;

package/backend-project/controllers/authController.js

@@ -0,0 +1,63 @@
+const bcrypt = require('bcryptjs');
+const User = require('../models/User');
+
+exports.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 });
+    if (!user) {
+      return res.status(401).json({ message: 'Invalid username or password' });
+    }
+
+    const isMatch = await bcrypt.compare(password, user.password);
+    if (!isMatch) {
+      return res.status(401).json({ message: 'Invalid username or password' });
+    }
+
+    req.session.userId = user._id;
+    req.session.role = user.role;
+    req.session.username = user.username;
+
+    res.json({
+      message: 'Login successful',
+      user: {
+        id: user._id,
+        username: user.username,
+        role: user.role,
+      },
+    });
+  } catch (error) {
+    console.error('Login error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.logout = (req, res) => {
+  req.session.destroy((err) => {
+    if (err) {
+      return res.status(500).json({ message: 'Logout failed' });
+    }
+    res.clearCookie('connect.sid');
+    res.json({ message: 'Logout successful' });
+  });
+};
+
+exports.checkSession = (req, res) => {
+  if (req.session && req.session.userId) {
+    res.json({
+      authenticated: true,
+      user: {
+        id: req.session.userId,
+        username: req.session.username,
+        role: req.session.role,
+      },
+    });
+  } else {
+    res.json({ authenticated: false });
+  }
+};

package/backend-project/controllers/productController.js

@@ -0,0 +1,113 @@
+const Product = require('../models/Product');
+
+exports.createProduct = async (req, res) => {
+  try {
+    const { productName, category, quantity, unitPrice } = req.body;
+
+    const product = new Product({
+      productName,
+      category,
+      quantity,
+      unitPrice,
+    });
+
+    const saved = await product.save();
+    res.status(201).json(saved);
+  } catch (error) {
+    if (error.name === 'ValidationError') {
+      const messages = Object.values(error.errors).map((e) => e.message);
+      return res.status(400).json({ message: messages.join(', ') });
+    }
+    console.error('Create product error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.getProducts = async (req, res) => {
+  try {
+    const { search, page = 1, limit = 10 } = req.query;
+    const query = {};
+
+    if (search) {
+      query.$or = [
+        { productName: { $regex: search, $options: 'i' } },
+        { category: { $regex: search, $options: 'i' } },
+      ];
+    }
+
+    const total = await Product.countDocuments(query);
+    const products = await Product.find(query)
+      .sort({ createdAt: -1 })
+      .skip((page - 1) * limit)
+      .limit(parseInt(limit));
+
+    res.json({
+      products,
+      total,
+      page: parseInt(page),
+      pages: Math.ceil(total / limit),
+    });
+  } catch (error) {
+    console.error('Get products error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.getProduct = async (req, res) => {
+  try {
+    const product = await Product.findById(req.params.id);
+    if (!product) {
+      return res.status(404).json({ message: 'Product not found' });
+    }
+    res.json(product);
+  } catch (error) {
+    console.error('Get product error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.updateProduct = async (req, res) => {
+  try {
+    const { productName, category, quantity, unitPrice } = req.body;
+
+    const updateData = {};
+    if (productName !== undefined) updateData.productName = productName;
+    if (category !== undefined) updateData.category = category;
+    if (quantity !== undefined) updateData.quantity = quantity;
+    if (unitPrice !== undefined) updateData.unitPrice = unitPrice;
+    if (quantity !== undefined || unitPrice !== undefined) {
+      const existing = await Product.findById(req.params.id);
+      updateData.totalPrice = (quantity ?? existing.quantity) * (unitPrice ?? existing.unitPrice);
+    }
+
+    const product = await Product.findByIdAndUpdate(req.params.id, updateData, {
+      new: true,
+      runValidators: true,
+    });
+
+    if (!product) {
+      return res.status(404).json({ message: 'Product not found' });
+    }
+    res.json(product);
+  } catch (error) {
+    if (error.name === 'ValidationError') {
+      const messages = Object.values(error.errors).map((e) => e.message);
+      return res.status(400).json({ message: messages.join(', ') });
+    }
+    console.error('Update product error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.deleteProduct = async (req, res) => {
+  try {
+    const product = await Product.findByIdAndDelete(req.params.id);
+    if (!product) {
+      return res.status(404).json({ message: 'Product not found' });
+    }
+    res.json({ message: 'Product deleted successfully' });
+  } catch (error) {
+    console.error('Delete product error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};

package/backend-project/controllers/reportController.js

@@ -0,0 +1,93 @@
+const Sale = require('../models/Sale');
+const StockStatus = require('../models/StockStatus');
+const Product = require('../models/Product');
+
+exports.getDailySalesReport = async (req, res) => {
+  try {
+    const { date, startDate, endDate } = req.query;
+    const query = {};
+
+    if (date) {
+      const start = new Date(date);
+      start.setHours(0, 0, 0, 0);
+      const end = new Date(date);
+      end.setHours(23, 59, 59, 999);
+      query.salesDate = { $gte: start, $lte: end };
+    } else if (startDate && endDate) {
+      const start = new Date(startDate);
+      start.setHours(0, 0, 0, 0);
+      const end = new Date(endDate);
+      end.setHours(23, 59, 59, 999);
+      query.salesDate = { $gte: start, $lte: end };
+    }
+
+    const sales = await Sale.find(query)
+      .populate('productId', 'productName category')
+      .sort({ salesDate: -1 });
+
+    const totalRevenue = sales.reduce((sum, sale) => sum + sale.soldTotalPrice, 0);
+
+    res.json({ sales, totalRevenue, count: sales.length });
+  } catch (error) {
+    console.error('Daily sales report error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.getStockStatusReport = async (req, res) => {
+  try {
+    const { date } = req.query;
+    const query = {};
+
+    if (date) {
+      const start = new Date(date);
+      start.setHours(0, 0, 0, 0);
+      const end = new Date(date);
+      end.setHours(23, 59, 59, 999);
+      query.generatedAt = { $gte: start, $lte: end };
+    }
+
+    const stockStatuses = await StockStatus.find(query)
+      .populate('productId', 'productName category')
+      .sort({ generatedAt: -1 });
+
+    res.json({ stockStatuses, count: stockStatuses.length });
+  } catch (error) {
+    console.error('Stock status report error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.getDashboardData = async (req, res) => {
+  try {
+    const totalProducts = await Product.countDocuments();
+    const totalSalesCount = await Sale.countDocuments();
+    const allSales = await Sale.find();
+    const totalRevenue = allSales.reduce((sum, s) => sum + s.soldTotalPrice, 0);
+    const products = await Product.find();
+    const availableStock = products.reduce((sum, p) => sum + p.quantity, 0);
+
+    const today = new Date();
+    today.setHours(0, 0, 0, 0);
+    const dailySales = await Sale.find({ salesDate: { $gte: today } })
+      .populate('productId', 'productName')
+      .sort({ salesDate: -1 })
+      .limit(10);
+
+    const categoryData = await Product.aggregate([
+      { $group: { _id: '$category', count: { $sum: 1 } } },
+    ]);
+
+    res.json({
+      totalProducts,
+      totalSales: totalSalesCount,
+      totalRevenue,
+      availableStock,
+      dailySales,
+      categoryData,
+    });
+  } catch (error) {
+    console.error('Dashboard data error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};

package/backend-project/controllers/saleController.js

@@ -0,0 +1,91 @@
+const Sale = require('../models/Sale');
+const Product = require('../models/Product');
+const StockStatus = require('../models/StockStatus');
+
+exports.createSale = async (req, res) => {
+  try {
+    const { productId, soldQuantity, soldUnitPrice, salesDate } = req.body;
+
+    const product = await Product.findById(productId);
+    if (!product) {
+      return res.status(404).json({ message: 'Product not found' });
+    }
+
+    if (soldQuantity > product.quantity) {
+      return res.status(400).json({
+        message: `Insufficient stock. Available: ${product.quantity}, Requested: ${soldQuantity}`,
+      });
+    }
+
+    const sale = new Sale({
+      productId,
+      soldQuantity,
+      soldUnitPrice,
+      salesDate,
+    });
+
+    const savedSale = await sale.save();
+
+    product.quantity -= soldQuantity;
+    product.totalPrice = product.quantity * product.unitPrice;
+    await product.save();
+
+    let stockStatus = await StockStatus.findOne({ productId });
+    if (stockStatus) {
+      stockStatus.soldQuantity += soldQuantity;
+      await stockStatus.save();
+    } else {
+      stockStatus = new StockStatus({
+        productId,
+        availableQuantity: product.quantity + soldQuantity,
+        soldQuantity,
+        generatedAt: new Date(),
+      });
+      await stockStatus.save();
+    }
+
+    res.status(201).json(savedSale);
+  } catch (error) {
+    if (error.name === 'ValidationError') {
+      const messages = Object.values(error.errors).map((e) => e.message);
+      return res.status(400).json({ message: messages.join(', ') });
+    }
+    console.error('Create sale error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.getSales = async (req, res) => {
+  try {
+    const { page = 1, limit = 10 } = req.query;
+    const total = await Sale.countDocuments();
+    const sales = await Sale.find()
+      .populate('productId', 'productName category')
+      .sort({ createdAt: -1 })
+      .skip((page - 1) * limit)
+      .limit(parseInt(limit));
+
+    res.json({
+      sales,
+      total,
+      page: parseInt(page),
+      pages: Math.ceil(total / limit),
+    });
+  } catch (error) {
+    console.error('Get sales error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.getSale = async (req, res) => {
+  try {
+    const sale = await Sale.findById(req.params.id).populate('productId', 'productName category');
+    if (!sale) {
+      return res.status(404).json({ message: 'Sale not found' });
+    }
+    res.json(sale);
+  } catch (error) {
+    console.error('Get sale error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};

package/backend-project/controllers/stockController.js

@@ -0,0 +1,126 @@
+const StockStatus = require('../models/StockStatus');
+const Product = require('../models/Product');
+
+exports.createStockStatus = async (req, res) => {
+  try {
+    const { productId, availableQuantity, soldQuantity, generatedAt } = req.body;
+
+    const product = await Product.findById(productId);
+    if (!product) {
+      return res.status(404).json({ message: 'Product not found' });
+    }
+
+    const stockStatus = new StockStatus({
+      productId,
+      availableQuantity,
+      soldQuantity,
+      generatedAt: generatedAt || new Date(),
+    });
+
+    const saved = await stockStatus.save();
+    const populated = await StockStatus.findById(saved._id).populate('productId', 'productName category');
+    res.status(201).json(populated);
+  } catch (error) {
+    if (error.name === 'ValidationError') {
+      const messages = Object.values(error.errors).map((e) => e.message);
+      return res.status(400).json({ message: messages.join(', ') });
+    }
+    console.error('Create stock status error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.getStockStatuses = async (req, res) => {
+  try {
+    const { search, page = 1, limit = 10 } = req.query;
+    const query = {};
+
+    if (search) {
+      const products = await Product.find({
+        productName: { $regex: search, $options: 'i' },
+      }).select('_id');
+      const productIds = products.map((p) => p._id);
+      query.productId = { $in: productIds };
+    }
+
+    const total = await StockStatus.countDocuments(query);
+    const stockStatuses = await StockStatus.find(query)
+      .populate('productId', 'productName category')
+      .sort({ generatedAt: -1 })
+      .skip((page - 1) * limit)
+      .limit(parseInt(limit));
+
+    res.json({
+      stockStatuses,
+      total,
+      page: parseInt(page),
+      pages: Math.ceil(total / limit),
+    });
+  } catch (error) {
+    console.error('Get stock statuses error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.getStockStatus = async (req, res) => {
+  try {
+    const stockStatus = await StockStatus.findById(req.params.id).populate(
+      'productId',
+      'productName category'
+    );
+    if (!stockStatus) {
+      return res.status(404).json({ message: 'Stock status not found' });
+    }
+    res.json(stockStatus);
+  } catch (error) {
+    console.error('Get stock status error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.updateStockStatus = async (req, res) => {
+  try {
+    const { availableQuantity, soldQuantity, generatedAt } = req.body;
+
+    const updateData = {};
+    if (availableQuantity !== undefined) updateData.availableQuantity = availableQuantity;
+    if (soldQuantity !== undefined) updateData.soldQuantity = soldQuantity;
+    if (generatedAt !== undefined) updateData.generatedAt = generatedAt;
+    if (availableQuantity !== undefined || soldQuantity !== undefined) {
+      const existing = await StockStatus.findById(req.params.id);
+      updateData.remainingQuantity =
+        (availableQuantity ?? existing.availableQuantity) -
+        (soldQuantity ?? existing.soldQuantity);
+    }
+
+    const stockStatus = await StockStatus.findByIdAndUpdate(req.params.id, updateData, {
+      new: true,
+      runValidators: true,
+    }).populate('productId', 'productName category');
+
+    if (!stockStatus) {
+      return res.status(404).json({ message: 'Stock status not found' });
+    }
+    res.json(stockStatus);
+  } catch (error) {
+    if (error.name === 'ValidationError') {
+      const messages = Object.values(error.errors).map((e) => e.message);
+      return res.status(400).json({ message: messages.join(', ') });
+    }
+    console.error('Update stock status error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+exports.deleteStockStatus = async (req, res) => {
+  try {
+    const stockStatus = await StockStatus.findByIdAndDelete(req.params.id);
+    if (!stockStatus) {
+      return res.status(404).json({ message: 'Stock status not found' });
+    }
+    res.json({ message: 'Stock status deleted successfully' });
+  } catch (error) {
+    console.error('Delete stock status error:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};

package/backend-project/middleware/auth.js

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

package/backend-project/models/Product.js

@@ -0,0 +1,40 @@
+const mongoose = require('mongoose');
+
+const productSchema = new mongoose.Schema({
+  productName: {
+    type: String,
+    required: [true, 'Product name is required'],
+    trim: true,
+  },
+  category: {
+    type: String,
+    required: [true, 'Category is required'],
+    trim: true,
+  },
+  quantity: {
+    type: Number,
+    required: [true, 'Quantity is required'],
+    min: [0, 'Quantity cannot be negative'],
+    default: 0,
+  },
+  unitPrice: {
+    type: Number,
+    required: [true, 'Unit price is required'],
+    min: [0.01, 'Unit price must be greater than 0'],
+  },
+  totalPrice: {
+    type: Number,
+    default: 0,
+  },
+  createdAt: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+productSchema.pre('save', function (next) {
+  this.totalPrice = this.quantity * this.unitPrice;
+  next();
+});
+
+module.exports = mongoose.model('Product', productSchema);

package/backend-project/models/Sale.js

@@ -0,0 +1,38 @@
+const mongoose = require('mongoose');
+
+const saleSchema = new mongoose.Schema({
+  productId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Product',
+    required: [true, 'Product is required'],
+  },
+  soldQuantity: {
+    type: Number,
+    required: [true, 'Sold quantity is required'],
+    min: [1, 'Sold quantity must be at least 1'],
+  },
+  soldUnitPrice: {
+    type: Number,
+    required: [true, 'Sold unit price is required'],
+    min: [0.01, 'Price must be greater than 0'],
+  },
+  soldTotalPrice: {
+    type: Number,
+    default: 0,
+  },
+  salesDate: {
+    type: Date,
+    required: [true, 'Sales date is required'],
+  },
+  createdAt: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+saleSchema.pre('save', function (next) {
+  this.soldTotalPrice = this.soldQuantity * this.soldUnitPrice;
+  next();
+});
+
+module.exports = mongoose.model('Sale', saleSchema);

package/backend-project/models/StockStatus.js

@@ -0,0 +1,35 @@
+const mongoose = require('mongoose');
+
+const stockStatusSchema = new mongoose.Schema({
+  productId: {
+    type: mongoose.Schema.Types.ObjectId,
+    ref: 'Product',
+    required: [true, 'Product is required'],
+  },
+  availableQuantity: {
+    type: Number,
+    required: [true, 'Available quantity is required'],
+    min: 0,
+  },
+  soldQuantity: {
+    type: Number,
+    required: [true, 'Sold quantity is required'],
+    min: 0,
+    default: 0,
+  },
+  remainingQuantity: {
+    type: Number,
+    default: 0,
+  },
+  generatedAt: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+stockStatusSchema.pre('save', function (next) {
+  this.remainingQuantity = this.availableQuantity - this.soldQuantity;
+  next();
+});
+
+module.exports = mongoose.model('StockStatus', stockStatusSchema);

package/backend-project/models/User.js

@@ -0,0 +1,24 @@
+const mongoose = require('mongoose');
+
+const userSchema = new mongoose.Schema({
+  username: {
+    type: String,
+    required: [true, 'Username is required'],
+    unique: true,
+    trim: true,
+  },
+  password: {
+    type: String,
+    required: [true, 'Password is required'],
+  },
+  role: {
+    type: String,
+    default: 'admin',
+  },
+  createdAt: {
+    type: Date,
+    default: Date.now,
+  },
+});
+
+module.exports = mongoose.model('User', userSchema);

package/backend-project/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "bws-backend",
+  "version": "1.0.0",
+  "description": "Business Web Solution - Backend API (Express + MongoDB)",
+  "keywords": ["bws", "api", "express", "mongodb", "inventory"],
+  "license": "MIT",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js",
+    "seed": "node utils/seed.js"
+  },
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "express-session": "^1.17.3",
+    "mongoose": "^8.0.3"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.2"
+  }
+}

package/backend-project/routes/authRoutes.js

@@ -0,0 +1,9 @@
+const express = require('express');
+const router = express.Router();
+const { login, logout, checkSession } = require('../controllers/authController');
+
+router.post('/login', login);
+router.post('/logout', logout);
+router.get('/session', checkSession);
+
+module.exports = router;