@20052507/dab-enterprise-bws 1.0.1

package/backend-project/controllers/productController.js

@@ -0,0 +1,104 @@
+const pool = require('../config/database');
+
+const getAllProducts = async (req, res) => {
+  try {
+    const [products] = await pool.query('SELECT * FROM products ORDER BY CreatedAt DESC');
+    res.json(products);
+  } catch (error) {
+    console.error('Error fetching products:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const getProductById = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const [products] = await pool.query('SELECT * FROM products WHERE ProductID = ?', [id]);
+    
+    if (products.length === 0) {
+      return res.status(404).json({ message: 'Product not found' });
+    }
+    
+    res.json(products[0]);
+  } catch (error) {
+    console.error('Error fetching product:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const createProduct = async (req, res) => {
+  try {
+    const { ProductName, Category, Quantity, UnitPrice } = req.body;
+
+    if (!ProductName || !Category || Quantity === undefined || !UnitPrice) {
+      return res.status(400).json({ message: 'All fields are required' });
+    }
+
+    const [result] = await pool.query(
+      'INSERT INTO products (ProductName, Category, Quantity, UnitPrice) VALUES (?, ?, ?, ?)',
+      [ProductName, Category, Quantity, UnitPrice]
+    );
+
+    // Create or update stock status for this product
+    await pool.query(
+      'INSERT INTO stockstatus (ProductID, AvailableQuantity, SoldQuantity) VALUES (?, ?, 0) ON DUPLICATE KEY UPDATE AvailableQuantity = ?',
+      [result.insertId, Quantity, Quantity]
+    );
+
+    res.status(201).json({ 
+      message: 'Product created successfully', 
+      productId: result.insertId 
+    });
+  } catch (error) {
+    console.error('Error creating product:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const updateProduct = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { ProductName, Category, Quantity, UnitPrice } = req.body;
+
+    if (!ProductName || !Category || Quantity === undefined || !UnitPrice) {
+      return res.status(400).json({ message: 'All fields are required' });
+    }
+
+    await pool.query(
+      'UPDATE products SET ProductName = ?, Category = ?, Quantity = ?, UnitPrice = ? WHERE ProductID = ?',
+      [ProductName, Category, Quantity, UnitPrice, id]
+    );
+
+    // Update stock status
+    await pool.query(
+      'UPDATE stockstatus SET AvailableQuantity = ? WHERE ProductID = ?',
+      [Quantity, id]
+    );
+
+    res.json({ message: 'Product updated successfully' });
+  } catch (error) {
+    console.error('Error updating product:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const deleteProduct = async (req, res) => {
+  try {
+    const { id } = req.params;
+    
+    await pool.query('DELETE FROM products WHERE ProductID = ?', [id]);
+    
+    res.json({ message: 'Product deleted successfully' });
+  } catch (error) {
+    console.error('Error deleting product:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+module.exports = {
+  getAllProducts,
+  getProductById,
+  createProduct,
+  updateProduct,
+  deleteProduct
+};

package/backend-project/controllers/salesController.js

@@ -0,0 +1,208 @@
+const pool = require('../config/database');
+
+const getAllSales = async (req, res) => {
+  try {
+    const [sales] = await pool.query(`
+      SELECT s.*, p.ProductName, p.Category 
+      FROM sales s 
+      JOIN products p ON s.ProductID = p.ProductID 
+      ORDER BY s.SalesDate DESC, s.CreatedAt DESC
+    `);
+    res.json(sales);
+  } catch (error) {
+    console.error('Error fetching sales:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const getSalesById = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const [sales] = await pool.query(`
+      SELECT s.*, p.ProductName, p.Category 
+      FROM sales s 
+      JOIN products p ON s.ProductID = p.ProductID 
+      WHERE s.SalesID = ?
+    `, [id]);
+    
+    if (sales.length === 0) {
+      return res.status(404).json({ message: 'Sale not found' });
+    }
+    
+    res.json(sales[0]);
+  } catch (error) {
+    console.error('Error fetching sale:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const createSale = async (req, res) => {
+  const connection = await pool.getConnection();
+  
+  try {
+    await connection.beginTransaction();
+
+    const { ProductID, SoldQuantity, SoldUnitPrice, SalesDate } = req.body;
+
+    if (!ProductID || !SoldQuantity || !SoldUnitPrice || !SalesDate) {
+      await connection.rollback();
+      return res.status(400).json({ message: 'All fields are required' });
+    }
+
+    // Check if product exists and has enough stock
+    const [products] = await connection.query(
+      'SELECT * FROM products WHERE ProductID = ?',
+      [ProductID]
+    );
+
+    if (products.length === 0) {
+      await connection.rollback();
+      return res.status(404).json({ message: 'Product not found' });
+    }
+
+    const product = products[0];
+
+    if (product.Quantity < SoldQuantity) {
+      await connection.rollback();
+      return res.status(400).json({ message: 'Insufficient stock' });
+    }
+
+    // Create sale record
+    const [result] = await connection.query(
+      'INSERT INTO sales (ProductID, SoldQuantity, SoldUnitPrice, SalesDate) VALUES (?, ?, ?, ?)',
+      [ProductID, SoldQuantity, SoldUnitPrice, SalesDate]
+    );
+
+    // Update product quantity
+    await connection.query(
+      'UPDATE products SET Quantity = Quantity - ? WHERE ProductID = ?',
+      [SoldQuantity, ProductID]
+    );
+
+    // Update stock status
+    await connection.query(
+      `UPDATE stockstatus 
+       SET AvailableQuantity = AvailableQuantity - ?, 
+           SoldQuantity = SoldQuantity + ? 
+       WHERE ProductID = ?`,
+      [SoldQuantity, SoldQuantity, ProductID]
+    );
+
+    await connection.commit();
+
+    res.status(201).json({ 
+      message: 'Sale created successfully', 
+      salesId: result.insertId 
+    });
+  } catch (error) {
+    await connection.rollback();
+    console.error('Error creating sale:', error);
+    res.status(500).json({ message: 'Server error' });
+  } finally {
+    connection.release();
+  }
+};
+
+const updateSale = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { ProductID, SoldQuantity, SoldUnitPrice, SalesDate } = req.body;
+
+    if (!ProductID || !SoldQuantity || !SoldUnitPrice || !SalesDate) {
+      return res.status(400).json({ message: 'All fields are required' });
+    }
+
+    await pool.query(
+      'UPDATE sales SET ProductID = ?, SoldQuantity = ?, SoldUnitPrice = ?, SalesDate = ? WHERE SalesID = ?',
+      [ProductID, SoldQuantity, SoldUnitPrice, SalesDate, id]
+    );
+
+    res.json({ message: 'Sale updated successfully' });
+  } catch (error) {
+    console.error('Error updating sale:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const deleteSale = async (req, res) => {
+  try {
+    const { id } = req.params;
+    
+    await pool.query('DELETE FROM sales WHERE SalesID = ?', [id]);
+    
+    res.json({ message: 'Sale deleted successfully' });
+  } catch (error) {
+    console.error('Error deleting sale:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const getDailySalesReport = async (req, res) => {
+  try {
+    const { date } = req.query;
+    
+    let query = `
+      SELECT 
+        DATE(SalesDate) as Date,
+        COUNT(*) as TotalSales,
+        SUM(SoldQuantity) as TotalQuantity,
+        SUM(SoldTotalPrice) as TotalRevenue
+      FROM sales
+    `;
+    
+    let params = [];
+    
+    if (date) {
+      query += ' WHERE DATE(SalesDate) = ?';
+      params.push(date);
+    }
+    
+    query += ' GROUP BY DATE(SalesDate) ORDER BY Date DESC';
+    
+    const [report] = await pool.query(query, params);
+    res.json(report);
+  } catch (error) {
+    console.error('Error generating daily sales report:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const getDailySalesDetails = async (req, res) => {
+  try {
+    const { date } = req.query;
+    
+    let query = `
+      SELECT 
+        s.*,
+        p.ProductName,
+        p.Category
+      FROM sales s
+      JOIN products p ON s.ProductID = p.ProductID
+    `;
+    
+    let params = [];
+    
+    if (date) {
+      query += ' WHERE DATE(s.SalesDate) = ?';
+      params.push(date);
+    }
+    
+    query += ' ORDER BY s.SalesDate DESC, s.CreatedAt DESC';
+    
+    const [details] = await pool.query(query, params);
+    res.json(details);
+  } catch (error) {
+    console.error('Error fetching daily sales details:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+module.exports = {
+  getAllSales,
+  getSalesById,
+  createSale,
+  updateSale,
+  deleteSale,
+  getDailySalesReport,
+  getDailySalesDetails
+};

package/backend-project/controllers/stockController.js

@@ -0,0 +1,76 @@
+const pool = require('../config/database');
+
+const getAllStockStatus = async (req, res) => {
+  try {
+    const [stock] = await pool.query(`
+      SELECT 
+        ss.*,
+        p.ProductName,
+        p.Category,
+        p.UnitPrice,
+        p.TotalPrice
+      FROM stockstatus ss
+      JOIN products p ON ss.ProductID = p.ProductID
+      ORDER BY p.ProductName
+    `);
+    res.json(stock);
+  } catch (error) {
+    console.error('Error fetching stock status:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const getStockStatusByProductId = async (req, res) => {
+  try {
+    const { id } = req.params;
+    const [stock] = await pool.query(`
+      SELECT 
+        ss.*,
+        p.ProductName,
+        p.Category,
+        p.UnitPrice,
+        p.TotalPrice
+      FROM stockstatus ss
+      JOIN products p ON ss.ProductID = p.ProductID
+      WHERE ss.ProductID = ?
+    `, [id]);
+    
+    if (stock.length === 0) {
+      return res.status(404).json({ message: 'Stock status not found' });
+    }
+    
+    res.json(stock[0]);
+  } catch (error) {
+    console.error('Error fetching stock status:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+const getStockStatusReport = async (req, res) => {
+  try {
+    const [report] = await pool.query(`
+      SELECT 
+        p.ProductName,
+        p.Category,
+        ss.AvailableQuantity as StoredQuantity,
+        ss.SoldQuantity,
+        ss.RemainingQuantity,
+        p.UnitPrice,
+        p.TotalPrice,
+        ss.LastUpdated
+      FROM stockstatus ss
+      JOIN products p ON ss.ProductID = p.ProductID
+      ORDER BY p.ProductName
+    `);
+    res.json(report);
+  } catch (error) {
+    console.error('Error generating stock status report:', error);
+    res.status(500).json({ message: 'Server error' });
+  }
+};
+
+module.exports = {
+  getAllStockStatus,
+  getStockStatusByProductId,
+  getStockStatusReport
+};

package/backend-project/middleware/authMiddleware.js

@@ -0,0 +1,9 @@
+const authMiddleware = (req, res, next) => {
+  if (req.session && req.session.userId) {
+    next();
+  } else {
+    res.status(401).json({ message: 'Unauthorized. Please login.' });
+  }
+};
+
+module.exports = authMiddleware;

package/backend-project/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "backend-project",
+  "version": "1.0.0",
+  "description": "DAB Enterprise Ltd Backend API",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "keywords": ["express", "mysql", "api"],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "bcryptjs": "^2.4.3",
+    "cors": "^2.8.5",
+    "express": "^4.18.2",
+    "express-session": "^1.17.3",
+    "mysql2": "^3.6.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  }
+}

package/backend-project/routes/authRoutes.js

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

package/backend-project/routes/productRoutes.js

@@ -0,0 +1,18 @@
+const express = require('express');
+const router = express.Router();
+const authMiddleware = require('../middleware/authMiddleware');
+const { 
+  getAllProducts, 
+  getProductById, 
+  createProduct, 
+  updateProduct, 
+  deleteProduct 
+} = require('../controllers/productController');
+
+router.get('/', authMiddleware, getAllProducts);
+router.get('/:id', authMiddleware, getProductById);
+router.post('/', authMiddleware, createProduct);
+router.put('/:id', authMiddleware, updateProduct);
+router.delete('/:id', authMiddleware, deleteProduct);
+
+module.exports = router;

package/backend-project/routes/salesRoutes.js

@@ -0,0 +1,22 @@
+const express = require('express');
+const router = express.Router();
+const authMiddleware = require('../middleware/authMiddleware');
+const { 
+  getAllSales, 
+  getSalesById, 
+  createSale, 
+  updateSale, 
+  deleteSale,
+  getDailySalesReport,
+  getDailySalesDetails
+} = require('../controllers/salesController');
+
+router.get('/', authMiddleware, getAllSales);
+router.get('/:id', authMiddleware, getSalesById);
+router.post('/', authMiddleware, createSale);
+router.put('/:id', authMiddleware, updateSale);
+router.delete('/:id', authMiddleware, deleteSale);
+router.get('/report/daily', authMiddleware, getDailySalesReport);
+router.get('/report/daily/details', authMiddleware, getDailySalesDetails);
+
+module.exports = router;

package/backend-project/routes/stockRoutes.js

@@ -0,0 +1,14 @@
+const express = require('express');
+const router = express.Router();
+const authMiddleware = require('../middleware/authMiddleware');
+const { 
+  getAllStockStatus, 
+  getStockStatusByProductId,
+  getStockStatusReport
+} = require('../controllers/stockController');
+
+router.get('/', authMiddleware, getAllStockStatus);
+router.get('/:id', authMiddleware, getStockStatusByProductId);
+router.get('/report/status', authMiddleware, getStockStatusReport);
+
+module.exports = router;

package/backend-project/server.js

@@ -0,0 +1,133 @@
+const express = require('express');
+const cors = require('cors');
+const session = require('express-session');
+const mysql = require('mysql2/promise');
+
+const app = express();
+const PORT = process.env.PORT || 5000;
+
+// Middleware
+app.use(cors({
+  origin: 'http://localhost:3000',
+  credentials: true
+}));
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Session configuration
+app.use(session({
+  secret: 'dab-enterprise-secret-key-2026',
+  resave: false,
+  saveUninitialized: false,
+  cookie: {
+    secure: false,
+    maxAge: 24 * 60 * 60 * 1000 // 24 hours
+  }
+}));
+
+// Routes
+const authRoutes = require('./routes/authRoutes');
+const productRoutes = require('./routes/productRoutes');
+const salesRoutes = require('./routes/salesRoutes');
+const stockRoutes = require('./routes/stockRoutes');
+
+app.use('/api/auth', authRoutes);
+app.use('/api/products', productRoutes);
+app.use('/api/sales', salesRoutes);
+app.use('/api/stock', stockRoutes);
+
+// Health check
+app.get('/api/health', (req, res) => {
+  res.json({ status: 'OK', message: 'DAB Enterprise API is running' });
+});
+
+// Initialize database
+const initializeDatabase = async () => {
+  try {
+    const connection = await mysql.createConnection({
+      host: 'localhost',
+      user: 'root',
+      password: ''
+    });
+
+    // Create database
+    await connection.query('CREATE DATABASE IF NOT EXISTS db');
+    await connection.query('USE db');
+
+    // Create users table
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS users (
+        UserID INT AUTO_INCREMENT PRIMARY KEY,
+        Username VARCHAR(50) UNIQUE NOT NULL,
+        Password VARCHAR(255) NOT NULL,
+        CreatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+    // Create products table
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS products (
+        ProductID INT AUTO_INCREMENT PRIMARY KEY,
+        ProductName VARCHAR(100) NOT NULL,
+        Category VARCHAR(50) NOT NULL,
+        Quantity INT NOT NULL DEFAULT 0,
+        UnitPrice DECIMAL(10, 2) NOT NULL,
+        TotalPrice DECIMAL(10, 2) GENERATED ALWAYS AS (Quantity * UnitPrice) STORED,
+        CreatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+
+    // Create sales table
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS sales (
+        SalesID INT AUTO_INCREMENT PRIMARY KEY,
+        ProductID INT NOT NULL,
+        SoldQuantity INT NOT NULL,
+        SoldUnitPrice DECIMAL(10, 2) NOT NULL,
+        SoldTotalPrice DECIMAL(10, 2) GENERATED ALWAYS AS (SoldQuantity * SoldUnitPrice) STORED,
+        SalesDate DATE NOT NULL,
+        CreatedAt TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (ProductID) REFERENCES products(ProductID) ON DELETE CASCADE
+      )
+    `);
+
+    // Create stockstatus table
+    await connection.query(`
+      CREATE TABLE IF NOT EXISTS stockstatus (
+        StockID INT AUTO_INCREMENT PRIMARY KEY,
+        ProductID INT UNIQUE NOT NULL,
+        AvailableQuantity INT NOT NULL DEFAULT 0,
+        SoldQuantity INT NOT NULL DEFAULT 0,
+        RemainingQuantity INT GENERATED ALWAYS AS (AvailableQuantity - SoldQuantity) STORED,
+        LastUpdated TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+        FOREIGN KEY (ProductID) REFERENCES products(ProductID) ON DELETE CASCADE
+      )
+    `);
+
+    // Check if admin user exists, if not create one
+    const [users] = await connection.query('SELECT * FROM users WHERE Username = ?', ['admin']);
+    
+    if (users.length === 0) {
+      const bcrypt = require('bcryptjs');
+      const hashedPassword = await bcrypt.hash('Admin@123', 10);
+      await connection.query(
+        'INSERT INTO users (Username, Password) VALUES (?, ?)',
+        ['admin', hashedPassword]
+      );
+      console.log('Default admin user created: Username: admin, Password: Admin@123');
+    }
+
+    await connection.end();
+    console.log('Database initialized successfully');
+  } catch (error) {
+    console.error('Database initialization error:', error);
+  }
+};
+
+// Start server
+app.listen(PORT, async () => {
+  console.log(`Server is running on port ${PORT}`);
+  await initializeDatabase();
+});
+
+module.exports = app;

package/frontend-project/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "frontend-project",
+  "version": "1.0.0",
+  "description": "DAB Enterprise Ltd Frontend",
+  "private": true,
+  "dependencies": {
+    "axios": "^1.5.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "react-router-dom": "^6.16.0",
+    "react-scripts": "5.0.1"
+  },
+  "scripts": {
+    "start": "react-scripts start",
+    "build": "react-scripts build",
+    "test": "react-scripts test",
+    "eject": "react-scripts eject"
+  },
+  "eslintConfig": {
+    "extends": [
+      "react-app"
+    ]
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  },
+  "devDependencies": {
+    "tailwindcss": "^3.3.3",
+    "autoprefixer": "^10.4.15",
+    "postcss": "^8.4.29"
+  }
+}

package/frontend-project/postcss.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

package/frontend-project/public/index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="theme-color" content="#000000" />
+    <meta name="description" content="DAB Enterprise Ltd - Business Web Solution" />
+    <title>DAB Enterprise Ltd - BWS</title>
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+  </body>
+</html>