Project Introduction

The Supply Chain Tracking System is a web application designed to manage and optimize the flow of goods and services from suppliers to retailers. Built using Node.js, this platform allows users to track inventory, manage orders, and oversee shipments efficiently. The system supports multiple user roles, including admin, supplier, manufacturer, distributor, and retailer, ensuring a tailored experience for each user type. The underlying MySQL database schema is structured to manage users, inventory, orders, order items, suppliers, shipments, analytics, quality control, financial transactions, and compliance, providing a robust foundation for effective supply chain management.

Project Objectives

• To develop a user-friendly interface for users to manage inventory and track orders.
• To allow suppliers and manufacturers to manage their products and performance metrics.
• To implement a secure user authentication system for managing user roles and permissions.
• To facilitate the creation and management of orders, including tracking their status and total amounts.
• To manage shipments, including tracking numbers and delivery statuses.
• To provide analytics on supply chain performance metrics for informed decision-making.
• To ensure quality control of products through inspections and results tracking.
• To manage financial transactions related to orders, including payment methods and statuses.
• To ensure compliance with relevant regulations and standards in the supply chain.
• To ensure the application is scalable and maintainable for future enhancements.

Project Modules

1. User Management Module:

   This module handles user registration, authentication, and role management, allowing users to manage their accounts securely.

2. Inventory Management Module:

   This module allows users to manage inventory levels, including product names, quantities, and reorder levels.

3. Order Management Module:

   This module facilitates the creation and management of orders, including tracking order statuses and total amounts.

4. Order Items Management Module:

   This module manages individual items within orders, including product details and pricing.

5. Supplier Management Module:

   This module allows users to manage supplier information, including contact details and performance metrics.

6. Shipment Management Module:

   This module tracks shipments related to orders, including shipment statuses and tracking numbers.

7. Analytics Module:

   This module provides insights into supply chain performance metrics, helping users make informed decisions.

8. Quality Control Module:

   This module manages quality inspections of products, including results and comments.

9. Financial Transactions Module:

   This module manages financial transactions related to orders, including payment methods and statuses.

10. Compliance Module:

    This module tracks compliance with regulations and standards relevant to the supply chain.

Steps Overview

Set Up the Project: Initialize a new Node.js project and install the required packages.

Configure Sequelize: Set up Sequelize to connect to your database and define models based on the provided tables.

Create Repositories: Implement repository classes for data access.

Create Controllers: Implement controllers to handle business logic.

Set Up Routes: Define routes for the application.

Create EJS Views: Create views using EJS and Bootstrap 5 for the frontend.

Implement CRUD Operations: Implement the CRUD operations for each model.

Create a Dashboard: Create a dashboard to display consolidated data.

Step 1: Set Up the Project

mkdir inventory-management-app
cd inventory-management-app
npm init -y
npm install express sequelize mysql2 ejs body-parser

Step 2: Configure Sequelize

Create a config folder and a database.js file to configure Sequelize.

config/database.js:

const { Sequelize } = require('sequelize');
const sequelize = new Sequelize('your_database_name', 'your_username', 'your_password', {
    host: 'localhost',
    dialect: 'mysql',
});
module.exports = sequelize;

Step 3: Define Models

Create a models folder and define the models based on the provided SQL schema.

models/User.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const User = sequelize.define('User ', {
    UserId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    Username: {
        type: DataTypes.STRING(50),
        allowNull: false,
        unique: true,
    },
    PasswordHash: {
        type: DataTypes.STRING(256),
        allowNull: false,
    },
    Email: {
        type: DataTypes.STRING(100),
        allowNull: false,
        unique: true,
    },
    FirstName: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    LastName: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    RoleId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = User;

models/Role.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Role = sequelize.define('Role', {
    RoleId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    RoleName: {
        type: DataTypes.STRING(50),
        allowNull: false,
        unique: true,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Role;

models/InventoryItem.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const InventoryItem = sequelize.define('InventoryItem', {
    InventoryItemId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    ItemName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Quantity: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ReorderLevel: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    SupplierId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = InventoryItem;

models/Order.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Order = sequelize.define('Order', {
    OrderId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    OrderDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    TotalAmount: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    Status: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Order;

models/Supplier.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Supplier = sequelize.define('Supplier', {
    SupplierId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    SupplierName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    ContactPerson: {
        type: DataTypes.STRING(100),
    },
    Phone: {
        type: DataTypes.STRING(20),
    },
    Email: {
        type: DataTypes.STRING(100),
    },
    Address: {
        type: DataTypes.STRING(255),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Supplier;

models/Shipment.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Shipment = sequelize.define('Shipment', {
    ShipmentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    OrderId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ShipmentDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    DeliveryDate: {
        type: DataTypes.DATE,
    },
    Status: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Shipment;

models/Report.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Report = sequelize.define('Report', {
    ReportId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ReportDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    ReportContent: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Report;

models/QualityInspection.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const QualityInspection = sequelize.define('QualityInspection', {
    InspectionId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    ShipmentId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    InspectionDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    Status: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    Comments: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = QualityInspection;

models/CostTracking.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const CostTracking = sequelize.define('CostTracking', {
    CostTrackingId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    OrderId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Cost: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    CostDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = CostTracking;

models/Notification.js:

const { DataTypes } = require(' sequelize');
const sequelize = require('../config/database');
const Notification = sequelize.define('Notification', {
    NotificationId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Message: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
    IsRead: {
        type: DataTypes.BOOLEAN,
        defaultValue: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Notification;

models/Feedback.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Feedback = sequelize.define('Feedback', {
    FeedbackId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    FeedbackContent: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Feedback;

Step 4: Create Repositories

Create a repositories folder and implement repository classes for data access.

repositories/UserRepository.js:

class UserRepository {
    async findAll() {
        return await User.findAll();
    }
    async findById(id) {
        return await User.findByPk(id);
    }
    async create(userData) {
        return await User.create(userData);
    }
    async update(id, userData) {
        const user = await this.findById(id);
        return await user.update(userData);
    }
    async delete(id) {
        const user = await this.findById(id);
        return await user.destroy();
    }
}
module.exports = new UserRepository();

repositories/RoleRepository.js:

class RoleRepository {
    async findAll() {
        return await Role.findAll();
    }
    async findById(id) {
        return await Role.findByPk(id);
    }
    async create(roleData) {
        return await Role.create(roleData);
    }
    async update(id, roleData) {
        const role = await this.findById(id);
        return await role.update(roleData);
    }
    async delete(id) {
        const role = await this.findById(id);
        return await role.destroy();
    }
}
module.exports = new RoleRepository();

Step 5: Create Controllers

Create a controllers folder and implement controllers to handle business logic.

controllers/UserController.js:

const UserRepository = require('../repositories/UserRepository');
class UserController {
    async getAllUsers(req, res) {
        const users = await UserRepository.findAll();
        res.render('users/index', { users });
    }
    async getUser (req, res) {
        const user = await UserRepository.findById(req.params.id);
        res.render('users/edit', { user });
    }
    async createUser (req, res) {
        await UserRepository.create(req.body);
        res.redirect('/users');
    }
    async updateUser (req, res) {
        await UserRepository.update(req.params.id, req.body);
        res.redirect('/users');
    }
    async deleteUser (req, res) {
        await UserRepository.delete(req.params.id);
        res.redirect('/users');
    }
}
module.exports = new UserController();

Step 6: Set Up Routes

Define routes for the application in a routes folder.

routes/userRoutes.js:

const express = require('express');
const router = express.Router();
const UserController = require('../controllers/UserController');
router.get('/', UserController.getAllUsers);
router.get('/:id', UserController.getUser );
router.post('/', UserController.createUser );
router.put('/:id', UserController.updateUser );
router.delete('/:id', UserController.deleteUser );
module.exports = router;

Step 7: Create EJS Views

Create views using EJS and Bootstrap 5 for the frontend in a views folder.

views/users/index.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Users</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Users</h1 <a href="/users/new" class="btn btn-primary mb-3">Add User</a>
        <table class="table">
            <thead>
                <tr>
                    <th>UserId</th>
                    <th>Username</th>
                    <th>Email</th>
                    <th>First Name</th>
                    <th>Last Name</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% users.forEach(user => { %>
                    <tr>
                        <td><%= user.UserId %></td>
                        <td><%= user.Username %></td>
                        <td><%= user.Email %></td>
                        <td><%= user.FirstName %></td>
                        <td><%= user.LastName %></td>
                        <td>
                            <a href="/users/<%= user.UserId %>" class="btn btn-warning">Edit</a>
                            <form action="/users/<%= user.UserId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/users/edit.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit User</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Edit User</h1>
        <form action="/users/<%= user.UserId %>?_method=PUT" method="POST">
            <div class="mb-3">
                <label for="Username" class="form-label">Username</label>
                <input type="text" class="form-control" id="Username" name="Username" value="<%= user.Username %>" required>
            </div>
            <div class="mb-3">
                <label for="Email" class="form-label">Email</label>
                <input type="email" class="form-control" id="Email" name="Email" value="<%= user.Email %>" required>
            </div>
            <div class="mb-3">
                <label for="FirstName" class="form-label">First Name</label>
                <input type="text" class="form-control" id="FirstName" name="FirstName" value="<%= user.FirstName %>" required>
            </div>
            <div class="mb-3">
                <label for="LastName" class="form-label">Last Name</label>
                <input type="text" class="form-control" id="LastName" name="LastName" value="<%= user.LastName %>" required>
            </div>
            <button type="submit" class="btn btn-primary">Update User</button>
        </form>
    </div>
</body>
</html>

Step 8: Implement CRUD Operations

Ensure that the CRUD operations are implemented in the controller and repository classes as shown above. You can replicate similar structures for other models like Roles, InventoryItems, Orders, etc., by creating their respective repositories, controllers, and views.

Step 9: Create a Dashboard

You can create a dashboard similar to the previous example, where you can display consolidated data from various models. This will involve creating a new route, controller, and EJS view for the dashboard.

routes/dashboardRoutes.js:

const express = require('express');
const router = express.Router();
const DashboardController = require('../controllers/DashboardController');
router.get('/', DashboardController.displayDashboard);
module.exports = router;

controllers/DashboardController.js:

const UserRepository = require('../repositories/UserRepository');
const RoleRepository = require('../repositories/RoleRepository');
const InventoryItemRepository = require('../repositories/InventoryItemRepository');
class DashboardController {
    async displayDashboard(req, res) {
        try {
            const users = await UserRepository.findAll();
            const roles = await RoleRepository.findAll();
            const inventoryItems = await InventoryItemRepository.findAll();
            res.render('dashboard', {
                title: 'Dashboard',
                users,
                roles,
                inventoryItems,
            });
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new DashboardController();

views/dashboard.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title><%= title %></title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5"><%= title %></h1>
        <h2 class="mt-4">Users</h2>
        <table class="table">
            <thead>
                <tr>
                    <th>UserId</th>
                    <th>Username</th>
                    <th>Email</th>
                    <th>First Name</th>
                    <th>Last Name</th>
                </tr>
            </thead>
            <tbody>
                <% users.forEach(user => { %>
                    <tr>
                        <td><%= user.UserId %></td>
                        <td><%= user.Username %></td>
                        <td><%= user.Email %></td>
                        <td><%= user.FirstName %></td>
                        <td><%= user.LastName %></td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
        <h2 class="mt-4">Roles</h2>
        <table class="table">
            <thead>
                <tr>
                    <th>RoleId</th>
                    <th>Role Name</th>
                </tr>
            </thead>
            <tbody>
                <% roles.forEach(role => { %>
                    <tr>
                        <td><%= role.RoleId %></td>
                        <td><%= role.RoleName %></td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
        <h2 class="mt-4">Inventory Items</h2>
        <table class="table">
            <thead>
                <tr>
                    <th>InventoryItemId</th>
                    <th>Item Name</th>
                    <th>Quantity</th>
                    <th>Reorder Level</th>
                </tr>
            </thead>
            <tbody>
                <% inventoryItems.forEach(item => { %>
                    <tr>
                        <td><%= item.InventoryItemId %></td>
                        <td><%= item.ItemName %></td>
                        <td><%= item.Quantity %></td>
                        <td><%= item.ReorderLevel %></td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

Final Integration

In your main application file (e.g., app.js), ensure to include the necessary middleware and routes:

const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const sequelize = require('./config/database');
const userRoutes = require('./routes/userRoutes');
const dashboardRoutes = require('./routes/dashboardRoutes');
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use(express.static('public'));
app.use('/users', userRoutes);
app.use('/dashboard', dashboardRoutes);
sequelize.sync().then(() => {
    app.listen(3000, () => {
        console.log('Server is running on http://localhost:3000');
    });
}).catch(err => {
    console.error('Unable to connect to the database:', err);
});

This setup provides a complete CRUD application with a dashboard that displays consolidated data from the various models. You can expand upon this structure by adding more features, validations, and error handling as needed.

Complete Setup for Remaining Models

Following are the complete setup for the remaining models (InventoryItems, Orders, Suppliers, Shipments, Reports, QualityInspections, CostTracking, Notifications, and Feedback) including their Sequelize models, repositories, controllers, routes, and EJS views.

Step 1: Define Remaining Models

models/InventoryItem.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const InventoryItem = sequelize.define('InventoryItem', {
    InventoryItemId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    ItemName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    Quantity: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ReorderLevel: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    SupplierId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = InventoryItem;

models/Order.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Order = sequelize.define('Order', {
    OrderId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    OrderDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    TotalAmount: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    Status: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Order;

models/Supplier.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Supplier = sequelize.define('Supplier', {
    SupplierId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    SupplierName: {
        type: DataTypes.STRING(100),
        allowNull: false,
    },
    ContactPerson: {
        type: DataTypes.STRING(100),
    },
    Phone: {
        type: DataTypes.STRING(20),
    },
    Email: {
        type: DataTypes.STRING(100),
    },
    Address: {
        type: DataTypes.STRING(255),
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Supplier;

models/Shipment.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Shipment = sequelize.define('Shipment', {
    ShipmentId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    OrderId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ShipmentDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    DeliveryDate: {
        type: DataTypes.DATE,
    },
    Status: {
        type: DataTypes.STRING(50),
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
    UpdatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Shipment;

models/Report.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Report = sequelize.define('Report', {
    ReportId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    ReportDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    ReportContent: {
        type: DataTypes.TEXT,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Report;

models/QualityInspection.js:

javascript javascript const { DataTypes } = require('sequelize'); const sequelize = require('../config/database');
const QualityInspection = sequelize.define('QualityInspection', { InspectionId: { type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true, }, ShipmentId: { type: DataTypes.INTEGER, allowNull: false, }, InspectionDate: { type: DataTypes.DATE, allowNull: false, }, Status: { type: DataTypes.STRING(50), allowNull: false, }, Comments: { type: DataTypes.TEXT, }, CreatedAt: { type: DataTypes.DATE, defaultValue: DataTypes.NOW, }, UpdatedAt: { type: DataTypes.DATE, defaultValue: DataTypes.NOW, }, });
module.exports = QualityInspection;

models/CostTracking.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const CostTracking = sequelize.define('CostTracking', {
    CostTrackingId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    OrderId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Cost: {
        type: DataTypes.DECIMAL(18, 2),
        allowNull: false,
    },
    CostDate: {
        type: DataTypes.DATE,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = CostTracking;

models/Notification.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Notification = sequelize.define('Notification', {
    NotificationId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    Message: {
        type: DataTypes.STRING(255),
        allowNull: false,
    },
    IsRead: {
        type: DataTypes.BOOLEAN,
        defaultValue: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Notification;

models/Feedback.js:

const { DataTypes } = require('sequelize');
const sequelize = require('../config/database');
const Feedback = sequelize.define('Feedback', {
    FeedbackId: {
        type: DataTypes.INTEGER,
        primaryKey: true,
        autoIncrement: true,
    },
    UserId: {
        type: DataTypes.INTEGER,
        allowNull: false,
    },
    FeedbackContent: {
        type: DataTypes.TEXT,
        allowNull: false,
    },
    CreatedAt: {
        type: DataTypes.DATE,
        defaultValue: DataTypes.NOW,
    },
});
module.exports = Feedback;

Step 2: Create Repositories for Remaining Models

repositories/InventoryItemRepository.js:

class InventoryItemRepository {
    async findAll() {
        return await InventoryItem.findAll();
    }
    async findById(id) {
        return await InventoryItem.findByPk(id);
    }
    async create(itemData) {
        return await InventoryItem.create(itemData);
    }
    async update(id, itemData) {
        const item = await this.findById(id);
        return await item.update(itemData);
    }
    async delete(id) {
        const item = await this.findById(id);
        return await item.destroy();
    }
}
module.exports = new InventoryItemRepository();

repositories/OrderRepository.js:

class OrderRepository {
    async findAll() {
        return await Order.findAll();
    }
    async findById(id) {
        return await Order.findByPk(id);
    }
    async create(orderData) {
        return await Order.create(orderData);
    }
    async update(id, orderData) {
        const order = await this.findById(id);
        return await order.update(orderData);
    }
    async delete(id) {
        const order = await this.findById(id);
        return await order.destroy();
    }
}
module.exports = new OrderRepository();

repositories/SupplierRepository.js:

class SupplierRepository {
    async findAll() {
        return await Supplier.findAll();
    }
    async findById(id) {
        return await Supplier.findByPk(id);
    }
    async create(supplierData) {
        return await Supplier.create(supplierData);
    }
    async update(id, supplierData) {
        const supplier = await this.findById(id);
        return await supplier.update(supplierData);
    }
    async delete(id) {
        const supplier = await this.findById(id);
        return await supplier.destroy();
    }
}
module.exports = new SupplierRepository();

repositories/ShipmentRepository.js:

const Shipment = require('../models/Shipment');
class ShipmentRepository {
    async findAll() {
        return await Shipment.findAll();
    }
    async findById(id) {
        return await Shipment.findByPk(id);
    }
    async create(shipmentData) {
        return await Shipment.create(shipmentData);
    }
    async update(id, shipmentData) {
        const shipment = await this.findById(id);
        return await shipment.update(shipmentData);
    }
    async delete(id) {
        const shipment = await this.findById(id);
        return await shipment.destroy();
    }
}
module.exports = new ShipmentRepository();

repositories/ReportRepository.js:

const Report = require('../models/Report');
class ReportRepository {
    async findAll() {
        return await Report.findAll();
    }
    async findById(id) {
        return await Report.findByPk(id);
    }
    async create(reportData) {
        return await Report.create(reportData);
    }
    async update(id, reportData) {
        const report = await this.findById(id);
        return await report.update(reportData);
    }
    async delete(id) {
        const report = await this.findById(id);
        return await report.destroy();
    }
}
module.exports = new ReportRepository();

repositories/QualityInspectionRepository.js:

const QualityInspection = require('../models/QualityInspection');
class QualityInspectionRepository {
    async findAll() {
        return await QualityInspection.findAll();
    }
    async findById(id) {
        return await QualityInspection.findByPk(id);
    }
    async create(inspectionData) {
        return await QualityInspection.create(inspectionData);
    }
    async update(id, inspectionData) {
        const inspection = await this.findById(id);
        return await inspection.update(inspectionData);
    }
    async delete(id) {
        const inspection = await this.findById(id);
        return await inspection.destroy();
    }
}
module.exports = new QualityInspectionRepository();

repositories/CostTrackingRepository.js:

const CostTracking = require('../models/CostTracking');
class CostTrackingRepository {
    async findAll() {
        return await CostTracking.findAll();
    }
    async findById(id) {
        return await CostTracking.findByPk(id);
    }
    async create(costData) {
        return await CostTracking.create(costData);
    }
    async update(id, costData) {
        const costTracking = await this.findById(id);
        return await costTracking.update(costData);
    }
    async delete(id) {
        const costTracking = await this.findById(id);
        return await costTracking.destroy();
    }
}
module.exports = new CostTrackingRepository();

repositories/NotificationRepository.js:

const Notification = require('../models/Notification');
class NotificationRepository {
    async findAll() {
        return await Notification.findAll();
    }
    async findById(id) {
        return await Notification.findByPk(id);
    }
    async create(notificationData) {
        return await Notification.create(notificationData);
    }
    async update(id, notificationData) {
        const notification = await this.findById(id);
        return await notification.update(notificationData);
    }
    async delete(id) {
        const notification = await this.findById(id);
        return await notification.destroy();
    }
}
module.exports = new NotificationRepository();

repositories/FeedbackRepository.js:

const Feedback = require('../models/Feedback');
class FeedbackRepository {
    async findAll() {
        return await Feedback.findAll();
    }
    async findById(id) {
        return await Feedback.findByPk(id);
    }
    async create(feedbackData) {
        return await Feedback.create(feedbackData);
    }
    async update(id, feedbackData) {
        const feedback = await this.findById(id);
        return await feedback.update(feedbackData);
    }
    async delete(id) {
        const feedback = await this.findById(id);
        return await feedback.destroy();
    }
}
module.exports = new FeedbackRepository();

Step 3: Create Controllers for Remaining Models

controllers/InventoryItemController.js:

const InventoryItemRepository = require('../repositories/InventoryItemRepository');
class InventoryItemController {
    async getAllItems(req, res) {
        const items = await InventoryItemRepository.findAll();
        res.render('inventoryItems/index', { items });
    }
    async getItem(req, res) {
        const item = await InventoryItemRepository.findBy Id(req.params.id);
        res.render('inventoryItems/edit', { item });
    }
    async createItem(req, res) {
        await InventoryItemRepository.create(req.body);
        res.redirect('/inventory-items');
    }
    async updateItem(req, res) {
        await InventoryItemRepository.update(req.params.id, req.body);
        res.redirect('/inventory-items');
    }
    async deleteItem(req, res) {
        await InventoryItemRepository.delete(req.params.id);
        res.redirect('/inventory-items');
    }
}
module.exports = new InventoryItemController();

controllers/OrderController.js:

const OrderRepository = require('../repositories/OrderRepository');
class OrderController {
    async getAllOrders(req, res) {
        const orders = await OrderRepository.findAll();
        res.render('orders/index', { orders });
    }
    async getOrder(req, res) {
        const order = await OrderRepository.findById(req.params.id);
        res.render('orders/edit', { order });
    }
    async createOrder(req, res) {
        await OrderRepository.create(req.body);
        res.redirect('/orders');
    }
    async updateOrder(req, res) {
        await OrderRepository.update(req.params.id, req.body);
        res.redirect('/orders');
    }
    async deleteOrder(req, res) {
        await OrderRepository.delete(req.params.id);
        res.redirect('/orders');
    }
}
module.exports = new OrderController();

controllers/SupplierController.js:

const SupplierRepository = require('../repositories/SupplierRepository');
class SupplierController {
    async getAllSuppliers(req, res) {
        const suppliers = await SupplierRepository.findAll();
        res.render('suppliers/index', { suppliers });
    }
    async getSupplier(req, res) {
        const supplier = await SupplierRepository.findById(req.params.id);
        res.render('suppliers/edit', { supplier });
    }
    async createSupplier(req, res) {
        await SupplierRepository.create(req.body);
        res.redirect('/suppliers');
    }
    async updateSupplier(req, res) {
        await SupplierRepository.update(req.params.id, req.body);
        res.redirect('/suppliers');
    }
    async deleteSupplier(req, res) {
        await SupplierRepository.delete(req.params.id);
        res.redirect('/suppliers');
    }
}
module.exports = new SupplierController();

controllers/ShipmentController.js:

const ShipmentRepository = require('../repositories/ShipmentRepository');
class ShipmentController {
    async getAllShipments(req, res) {
        const shipments = await ShipmentRepository.findAll();
        res.render('shipments/index', { shipments });
    }
    async getShipment(req, res) {
        const shipment = await ShipmentRepository.findById(req.params.id);
        res.render('shipments/edit', { shipment });
    }
    async createShipment(req, res) {
        await ShipmentRepository.create(req.body);
        res.redirect('/shipments');
    }
    async updateShipment(req, res) {
        await ShipmentRepository.update(req.params.id, req.body);
        res.redirect('/shipments');
    }
    async deleteShipment(req, res) {
        await ShipmentRepository.delete(req.params.id);
        res.redirect('/shipments');
    }
}
module.exports = new ShipmentController();

controllers/ReportController.js:

const ReportRepository = require('../repositories/ReportRepository');
class ReportController {
    async getAllReports(req, res) {
        const reports = await ReportRepository.findAll();
        res.render('reports/index', { reports });
    }
    async getReport(req, res) {
        const report = await ReportRepository.findById(req.params.id);
        res.render('reports/edit', { report });
    }
    async createReport(req, res) {
        await ReportRepository.create(req.body);
        res.redirect('/reports');
    }
    async updateReport(req, res) {
        await ReportRepository.update(req.params.id, req.body);
        res.redirect('/reports');
    }
    async deleteReport(req, res) {
        await ReportRepository.delete(req.params.id);
        res.redirect('/reports');
    }
}
module.exports = new ReportController();

controllers/QualityInspectionController.js:

const QualityInspectionRepository = require('../repositories/QualityInspectionRepository');
class QualityInspectionController {
    async getAllInspections(req, res) {
        const inspections = await QualityInspectionRepository.findAll();
        res.render('qualityInspections/index', { inspections });
    }
    async getInspection(req, res) {
        const inspection = await QualityInspectionRepository.findById(req.params.id);
        res.render('qualityInspections/edit', { inspection });
    }
    async createInspection(req, res) {
        await QualityInspectionRepository.create(req.body);
        res.redirect('/quality-inspections');
    }
    async updateInspection(req, res) {
        await QualityInspectionRepository.update(req.params.id, req.body);
        res.redirect('/quality-inspections');
    }
    async deleteInspection(req, res) {
        await QualityInspectionRepository.delete(req.params.id);
        res.redirect('/quality-inspections');
    }
}
module.exports = new QualityInspectionController();

controllers/CostTrackingController.js:

const CostTrackingRepository = require('../repositories/CostTrackingRepository');
class CostTrackingController {
    async getAllCosts(req, res) {
        const costs = await CostTrackingRepository.findAll();
        res.render('costTracking/index', { costs });
    }
    async getCost(req, res) {
        const cost = await CostTrackingRepository.findById(req.params.id);
        res.render('costTracking/edit', { cost });
    }
    async createCost(req, res) {
        await CostTrackingRepository.create(req.body);
        res.redirect('/cost-tracking');
    }
    async updateCost(req, res) {
        await CostTrackingRepository.update(req.params.id, req.body);
        res.redirect('/cost-tracking');
    }
    async deleteCost(req, res) {
        await CostTrackingRepository.delete(req.params.id);
        res.redirect('/cost-tracking');
    }
}
module.exports = new CostTrackingController();

controllers/NotificationController.js:

const NotificationRepository = require('../repositories/NotificationRepository');
class NotificationController {
    async getAllNotifications(req, res) {
        const notifications = await NotificationRepository.findAll();
        res.render('notifications/index', { notifications });
    }
    async getNotification(req, res) {
        const notification = await NotificationRepository.findById(req.params.id);
        res.render('notifications/edit', { notification });
    }
    async createNotification(req, res) {
        await NotificationRepository.create(req.body);
        res.redirect('/notifications');
    }
    async updateNotification(req, res) {
        await NotificationRepository.update(req.params.id, req.body);
        res.redirect('/notifications');
    }
    async deleteNotification(req, res) {
        await NotificationRepository.delete(req.params.id);
        res.redirect('/notifications');
    }
}
module.exports = new NotificationController();

controllers/FeedbackController.js:

const FeedbackRepository = require('../repositories/FeedbackRepository');
class FeedbackController {
    async getAllFeedbacks(req, res) {
        const feedbacks = await FeedbackRepository.findAll();
        res.render('feedback/index', { feedbacks });
    }
    async getFeedback(req, res) {
        const feedback = await FeedbackRepository.findById(req.params.id);
        res.render('feedback/edit', { feedback });
    }
    async createFeedback(req, res) {
        await FeedbackRepository.create(req.body);
        res.redirect('/feedback');
    }
    async updateFeedback(req, res) {
        await FeedbackRepository.update(req.params.id, req.body);
        res.redirect('/feedback');
    }
    async deleteFeedback(req, res) {
        await FeedbackRepository.delete(req.params.id);
        res.redirect('/feedback');
    }
}
module.exports = new FeedbackController();

Step 4: Set Up Routes for Remaining Models

routes/inventoryItemRoutes.js:

const express = require('express');
const router = express.Router();
const InventoryItemController = require('../controllers/InventoryItemController');
router.get('/', InventoryItemController.getAllItems);
router.get('/:id', InventoryItemController.getItem);
router.post('/', InventoryItemController.createItem);
router.put('/:id', InventoryItemController.updateItem);
router.delete('/:id', InventoryItemController.deleteItem);
module.exports = router;

routes/orderRoutes.js:

const express = require('express');
const router = express.Router();
const OrderController = require('../controllers/OrderController');
router.get('/', OrderController.getAllOrders);
router.get('/:id', OrderController.getOrder);
router.post('/', OrderController.createOrder);
router.put('/:id', OrderController.updateOrder);
router.delete('/:id', OrderController.deleteOrder);
module.exports = router;

routes/supplierRoutes.js:

const express = require('express');
const router = express.Router();
const SupplierController = require('../controllers/SupplierController');
router.get('/', SupplierController.getAllSuppliers);
router.get('/:id', SupplierController.getSupplier);
router.post('/', SupplierController.createSupplier);
router.put('/:id', SupplierController.updateSupplier);
router.delete('/:id', SupplierController.deleteSupplier);
module.exports = router;

routes/shipmentRoutes.js:

const express = require('express');
const router = express.Router();
const ShipmentController = require('../controllers/ShipmentController');
router.get('/', ShipmentController.getAllShipments);
router.get('/:id', ShipmentController.getShipment);
router.post('/', ShipmentController.createShipment);
router.put('/:id', ShipmentController.updateShipment);
router.delete('/:id', ShipmentController.deleteShipment);
module.exports = router;

routes/reportRoutes.js:

const express = require('express');
const router = express.Router();
const ReportController = require('../controllers/ReportController');
router.get('/', Report Controller.getAllReports);
router.get('/:id', ReportController.getReport);
router.post('/', ReportController.createReport);
router.put('/:id', ReportController.updateReport);
router.delete('/:id', ReportController.deleteReport);
module.exports = router;

routes/qualityInspectionRoutes.js:

const express = require('express');
const router = express.Router();
const QualityInspectionController = require('../controllers/QualityInspectionController');
router.get('/', QualityInspectionController.getAllInspections);
router.get('/:id', QualityInspectionController.getInspection);
router.post('/', QualityInspectionController.createInspection);
router.put('/:id', QualityInspectionController.updateInspection);
router.delete('/:id', QualityInspectionController.deleteInspection);
module.exports = router;

routes/costTrackingRoutes.js:

const express = require('express');
const router = express.Router();
const CostTrackingController = require('../controllers/CostTrackingController');
router.get('/', CostTrackingController.getAllCosts);
router.get('/:id', CostTrackingController.getCost);
router.post('/', CostTrackingController.createCost);
router.put('/:id', CostTrackingController.updateCost);
router.delete('/:id', CostTrackingController.deleteCost);
module.exports = router;

routes/notificationRoutes.js:

const express = require('express');
const router = express.Router();
const NotificationController = require('../controllers/NotificationController');
router.get('/', NotificationController.getAllNotifications);
router.get('/:id', NotificationController.getNotification);
router.post('/', NotificationController.createNotification);
router.put('/:id', NotificationController.updateNotification);
router.delete('/:id', NotificationController.deleteNotification);
module.exports = router;

routes/feedbackRoutes.js:

const express = require('express');
const router = express.Router();
const FeedbackController = require('../controllers/FeedbackController');
router.get('/', FeedbackController.getAllFeedbacks);
router.get('/:id', FeedbackController.getFeedback);
router.post('/', FeedbackController.createFeedback);
router.put('/:id', FeedbackController.updateFeedback);
router.delete('/:id', FeedbackController.deleteFeedback);
module.exports = router;

Step 5: Create EJS Views for Remaining Models

views/inventoryItems/index.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Inventory Items</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Inventory Items</h1>
        <a href="/inventory-items/new" class="btn btn-primary mb-3">Add Item</a>
        <table class="table">
            <thead>
                <tr>
                    <th>InventoryItemId</th>
                    <th>Item Name</th>
                    <th>Quantity</th>
                    <th>Reorder Level</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% items.forEach(item => { %>
                    <tr>
                        <td><%= item.InventoryItemId %></td>
                        <td><%= item.ItemName %></td>
                        <td><%= item.Quantity %></td>
                        <td><%= item.ReorderLevel %></td>
                        <td>
                            <a href="/inventory-items/<%= item.InventoryItemId %>" class="btn btn-warning">Edit</a>
                            <form action="/inventory-items/<%= item.InventoryItemId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/inventoryItems/edit.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit Inventory Item</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Edit Inventory Item</h1>
        <form action="/inventory-items/<%= item.InventoryItemId %>?_method=PUT" method="POST">
            <div class="mb-3">
                <label for="ItemName" class="form-label">Item Name</label>
                <input type="text" class="form-control" id="ItemName" name="ItemName" value="<%= item.ItemName %>" required>            
            </div>
            <div class="mb-3">
                <label for="Quantity" class="form-label">Quantity</label>
                <input type="number" class="form-control" id="Quantity" name="Quantity" value="<%= item.Quantity %>" required>
            </div>
            <div class="mb-3">
                <label for="ReorderLevel" class="form-label">Reorder Level</label>
                <input type="number" class="form-control" id="ReorderLevel" name="ReorderLevel" value="<%= item.ReorderLevel %>" required>
            </div>
            <button type="submit" class="btn btn-primary">Update Item</button>
        </form>
    </div>
</body>
</html>

views/orders/index.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Orders</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Orders</h1>
        <a href="/orders/new" class="btn btn-primary mb-3">Add Order</a>
        <table class="table">
            <thead>
                <tr>
                    <th>OrderId</th>
                    <th>UserId</th>
                    <th>OrderDate</th>
                    <th>TotalAmount</th>
                    <th>Status</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% orders.forEach(order => { %>
                    <tr>
                        <td><%= order.OrderId %></td>
                        <td><%= order.UserId %></td>
                        <td><%= order.OrderDate %></td>
                        <td><%= order.TotalAmount %></td>
                        <td><%= order.Status %></td>
                        <td>
                            <a href="/orders/<%= order.OrderId %>" class="btn btn-warning">Edit</a>
                            <form action="/orders/<%= order.OrderId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/orders/edit.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit Order</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Edit Order</h1>
        <form action="/orders/<%= order.OrderId %>?_method=PUT" method="POST">
            <div class="mb-3">
                <label for="User Id" class="form-label">User Id</label>
                <input type="number" class="form-control" id="User Id" name="User Id" value="<%= order.UserId %>" required>
            </div>
            <div class="mb-3">
                <label for="OrderDate" class="form-label">Order Date</label>
                <input type="date" class="form-control" id="OrderDate" name="OrderDate" value="<%= order.OrderDate.toISOString().split('T')[0] %>" required>
            </div>
            <div class="mb-3">
                <label for="TotalAmount" class="form-label">Total Amount</label>
                <input type="number" class="form-control" id="TotalAmount" name="TotalAmount" value="<%= order.TotalAmount %>" required>
            </div>
            <div class="mb-3">
                <label for="Status" class="form-label">Status</label>
                <input type="text" class="form-control" id="Status" name="Status" value="<%= order.Status %>" required>
            </div>
            <button type="submit" class="btn btn-primary">Update Order</button>
        </form>
    </div>
</body>
</html>

views/suppliers/index.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">    
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Suppliers</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Suppliers</h1>
        <a href="/suppliers/new" class="btn btn-primary mb-3">Add Supplier</a>
        <table class="table">
            <thead>
                <tr>
                    <th>SupplierId</th>
                    <th>Supplier Name</th>
                    <th>Contact Person</th>
                    <th>Phone</th>
                    <th>Email</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% suppliers.forEach(supplier => { %>
                    <tr>
                        <td><%= supplier.SupplierId %></td>
                        <td><%= supplier.SupplierName %></td>
                        <td><%= supplier.ContactPerson %></td>
                        <td><%= supplier.Phone %></td>
                        <td><%= supplier.Email %></td>
                        <td>
                            <a href="/suppliers/<%= supplier.SupplierId %>" class="btn btn-warning">Edit</a>
                            <form action="/suppliers/<%= supplier.SupplierId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/suppliers/edit.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit Supplier</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Edit Supplier</h1>
        <form action="/suppliers/<%= supplier.SupplierId %>?_method=PUT" method="POST">
            <div class="mb-3">
                <label for="SupplierName" class="form-label">Supplier Name</label>
                <input type="text" class="form-control" id="SupplierName" name="SupplierName" value="<%= supplier.SupplierName %>" required>
            </div>
            <div class="mb-3">
                <label for="ContactPerson" class="form-label">Contact Person</label>
                <input type="text" class="form-control" id="ContactPerson" name="ContactPerson" value="<%= supplier.ContactPerson %>">
            </div>
            <div class="mb-3">
                <label for="Phone" class="form-label">Phone</label>
                <input type="text" class="form-control" id="Phone" name="Phone" value="<%= supplier.Phone %>">
            </div>
            <div class="mb-3">
                <label for="Email" class="form-label">Email</label>
                <input type="email" class="form-control" id="Email" name="Email" value="<%= supplier.Email %>">
            </div>
            <div class="mb-3">
                <label for="Address" class="form-label">Address</label>
                <input type="text" class="form-control" id="Address" name="Address" value="<%= supplier.Address %>">
            </div>
            <button type="submit" class="btn btn-primary">Update Supplier</button>
        </form>
    </div>
</body>
</html>

views/shipments/index.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Shipments</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Shipments</h1>
        <a href="/shipments/new" class="btn btn-primary mb-3">Add Shipment</a>
        <table class="table">
            <thead>
                <tr>
                    <th>ShipmentId</th>
                    <th>OrderId</th>
                    <th>ShipmentDate</th>                    
                    <th>DeliveryDate</th>
                    <th>Status</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% shipments.forEach(shipment => { %>
                    <tr>
                        <td><%= shipment.ShipmentId %></td>
                        <td><%= shipment.OrderId %></td>
                        <td><%= shipment.ShipmentDate %></td>
                        <td><%= shipment.DeliveryDate ? shipment.DeliveryDate : 'N/A' %></td>
                        <td><%= shipment.Status %></td>
                        <td>
                            <a href="/shipments/<%= shipment.ShipmentId %>" class="btn btn-warning">Edit</a>
                            <form action="/shipments/<%= shipment.ShipmentId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/shipments/edit.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit Shipment</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Edit Shipment</h1>
        <form action="/shipments/<%= shipment.ShipmentId %>?_method=PUT" method="POST">
            <div class="mb-3">
                <label for="OrderId" class="form-label">Order Id</label>
                <input type="number" class="form-control" id="OrderId" name="OrderId" value="<%= shipment.OrderId %>" required>
            </div>
            <div class="mb-3">
                <label for="ShipmentDate" class="form-label">Shipment Date</label>
                <input type="date" class="form-control" id="ShipmentDate" name="ShipmentDate" value="<%= shipment.ShipmentDate.toISOString().split('T')[0] %>" required>
            </div>
            <div class="mb-3">
                <label for="DeliveryDate" class="form-label">Delivery Date</label>
                <input type="date" class="form-control" id="DeliveryDate" name="DeliveryDate" value="<%= shipment.DeliveryDate ? shipment.DeliveryDate.toISOString().split('T')[0] : '' %>">
            </div>
            <div class="mb-3">
                <label for="Status" class="form-label">Status</label>
                <input type="text" class="form-control" id="Status" name="Status" value="<%= shipment.Status %>" required>
            </div>
            <button type="submit" class="btn btn-primary">Update Shipment</button>
        </form>
    </div>
</body>
</html>

views/reports/index.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Reports</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Reports</h1>
        <a href="/reports/new" class="btn btn-primary mb-3">Add Report</a>
        <table class="table">
            <thead>
                <tr>
                    <th>ReportId</th>
                    <th>UserId</th>
                    <th>ReportDate</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% reports.forEach(report => { %>
                    <tr>
                        <td><%= report.ReportId %></td>
                        <td><%= report.UserId %></td>
                        <td><%= report.ReportDate %></td>
                        <td>
                            <a href="/reports/<%= report.ReportId %>" class="btn btn-warning">Edit</a>
                            <form action="/reports/<%= report.ReportId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %
            </tbody>
        </table>
    </div>
</body>
</html>

views/reports/edit.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit Report</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Edit Report</h1>
        <form action="/reports/<%= report.ReportId %>?_method=PUT" method="POST">
            <div class="mb-3">
                <label for="User Id" class="form-label">User  Id</label>
                <input type="number" class="form-control" id="User Id" name="User Id" value="<%= report.UserId %>" required>
            </div>
            <div class="mb-3">
                <label for="ReportDate" class="form-label">Report Date</label>
                <input type="date" class="form-control" id="ReportDate" name="ReportDate" value="<%= report.ReportDate.toISOString().split('T')[0] %>" required>
            </div>
            <div class="mb-3">
                <label for="ReportContent" class="form-label">Report Content</label>
                <textarea class="form-control" id="ReportContent" name="ReportContent" required><%= report.ReportContent %></textarea>
            </div>
            <button type="submit" class="btn btn-primary">Update Report</button>
        </form>
    </div>
</body>
</html>

views/qualityInspections/index.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Quality Inspections</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Quality Inspections</h1>
        <a href="/quality-inspections/new" class="btn btn-primary mb-3">Add Inspection</a>
        <table class="table">
            <thead>
                <tr>
                    <th>InspectionId</th>
                    <th>ShipmentId</th>
                    <th>InspectionDate</th>
                    <th>Status</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% inspections.forEach(inspection => { %>
                    <tr>
                        <td><%= inspection.InspectionId %></td>
                        <td><%= inspection.ShipmentId %></td>
                        <td><%= inspection.InspectionDate %></td>
                        <td><%= inspection.Status %></td>
                        <td>
                            <a href="/quality-inspections/<%= inspection.InspectionId %>" class="btn btn-warning">Edit</a>
                            <form action="/quality-inspections/<%= inspection.InspectionId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/qualityInspections/edit.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit Quality Inspection</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Edit Quality Inspection</h1>
        <form action="/quality-inspections/<%= inspection.InspectionId %>?_method=PUT" method="POST">
            <div class="mb-3">
                <label for="ShipmentId" class="form-label">Shipment Id</label>
                <input type="number" class="form-control" id="ShipmentId" name="ShipmentId" value="<%= inspection.ShipmentId %>" required>
            </div>
            <div class="mb-3">
                <label for="InspectionDate" class="form-label">Inspection Date</label>
                <input type=" date" class="form-control" id="InspectionDate" name="InspectionDate" value="<%= inspection.InspectionDate.toISOString().split('T')[0] %>" required>
            </div>
            <div class="mb-3">
                <label for="Status" class="form-label">Status</label>
                <input type="text" class="form-control" id="Status" name="Status" value="<%= inspection.Status %>" required>
            </div>
            <div class="mb-3">
                <label for="Comments" class="form-label">Comments</label>
                <textarea class="form-control" id="Comments" name="Comments"><%= inspection.Comments %></textarea>
            </div>
            <button type="submit" class="btn btn-primary">Update Inspection</button>
        </form>
    </div>
</body>
</html>

views/costTracking/index.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Cost Tracking</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Cost Tracking</h1>
        <a href="/cost-tracking/new" class="btn btn-primary mb-3">Add Cost</a>
        <table class="table">
            <thead>
                <tr>
                    <th>CostTrackingId</th>
                    <th>OrderId</th>
                    <th>Cost</th>
                    <th>CostDate</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% costs.forEach(cost => { %>
                    <tr>
                        <td><%= cost.CostTrackingId %></td>
                        <td><%= cost.OrderId %></td>
                        <td><%= cost.Cost %></td>
                        <td><%= cost.CostDate %></td>
                        <td>
                            <a href="/cost-tracking/<%= cost.CostTrackingId %>" class="btn btn-warning">Edit</a>
                            <form action="/cost-tracking/<%= cost.CostTrackingId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/costTracking/edit.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit Cost Tracking</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Edit Cost Tracking</h1>
        <form action="/cost-tracking/<%= cost.CostTrackingId %>?_method=PUT" method="POST">
            <div class="mb-3">
                <label for="OrderId" class="form-label">Order Id</label>
                <input type="number" class="form-control" id="OrderId" name="OrderId" value="<%= cost.OrderId %>" required>
            </div>
            <div class="mb-3">
                <label for="Cost" class="form-label">Cost</label>
                <input type="number" class="form-control" id="Cost" name="Cost" value="<%= cost.Cost %>" required>
            </div>
            <div class="mb-3">
                <label for="CostDate" class="form-label">Cost Date</label>
                <input type="date" class="form-control" id="CostDate" name="CostDate" value="<%= cost.CostDate.toISOString().split('T')[0] %>" required>
            </div>
            <button type="submit" class="btn btn-primary">Update Cost</button>
        </form>
    </div>
</body>
</html>

views/notifications/index.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Notifications</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Notifications</h1>
        <a href="/notifications/new" class="btn btn-primary mb-3">Add Notification</a>
        <table class="table">
            <thead>
                <tr>
                    <th>NotificationId</th>
                    <th>UserId</th>
                    <th>Message</th>
                    <th>IsRead</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% notifications.forEach(notification => { %>
                    <tr>
                        <td><%= notification.NotificationId %></td>
                        <td><%= notification.UserId %></td>
                        <td><%= notification.Message %></td>
                        <td><%= notification.IsRead ? 'Yes' : 'No' %></td>
                        <td>
                            <a href="/notifications/<%= notification.NotificationId %>" class="btn btn-warning">Edit</a>
                            <form action="/notifications/<%= notification.NotificationId %>?_method=DELETE" method="POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/notifications/edit.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit Notification</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Edit Notification</h1>
        <form action="/notifications/<%= notification.NotificationId %>?_method=PUT" method="POST">
            <div class="mb-3">
                <label for="User Id" class="form-label">User  Id</label>
                <input type="number" class="form-control" id="User Id" name="User Id" value="<%= notification.UserId %>" required>
            </div>
            <div class="mb-3">
                <label for="Message" class="form-label">Message</label>
                <input type="text" class="form-control" id="Message" name="Message" value="<%= notification.Message %>" required>
            </div>
            <div class="mb-3">
                <label for="IsRead" class="form-label">Is Read</label>
                <select class="form-control" id="IsRead" name="IsRead">
                    <option value="1" <%= notification.IsRead ? 'selected' : '' %>>Yes</option>
                    <option value="0" <%= !notification.IsRead ? 'selected' : '' %>>No</option>
                </select>
            </div>
            <button type="submit" class="btn btn-primary">Update Notification</button>
        </form>
    </div>
</body>
</html>

views/feedback/index.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Feedback</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Feedback</h1>
        <a href="/feedback/new" class="btn btn-primary mb-3">Add Feedback</a>
        <table class="table">
            <thead>
                <tr>
                    <th>FeedbackId</th>
                    <th>UserId</th>
                    <th>FeedbackContent</th>
                    <th>Actions</th>
                </tr>
            </thead>
            <tbody>
                <% feedbacks.forEach(feedback => { %>
                    <tr>
                        <td><%= feedback.FeedbackId %></td>
                        <td><%= feedback.UserId %></td>
                        <td><%= feedback.FeedbackContent %></td>
                        <td>
                            <a href="/feedback/<%= feedback.FeedbackId %>" class="btn btn-warning">Edit</a>
                            <form action="/feedback/<%= feedback.FeedbackId %>?_method=DELETE" method=" POST" style="display:inline;">
                                <button type="submit" class="btn btn-danger">Delete</button>
                            </form>
                        </td>
                    </tr>
                <% }) %>
            </tbody>
        </table>
    </div>
</body>
</html>

views/feedback/edit.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title>Edit Feedback</title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5">Edit Feedback</h1>
        <form action="/feedback/<%= feedback.FeedbackId %>?_method=PUT" method="POST">
            <div class="mb-3">
                <label for="User Id" class="form-label">User  Id</label>
                <input type="number" class="form-control" id="User Id" name="User Id" value="<%= feedback.UserId %>" required>
            </div>
            <div class="mb-3">
                <label for="FeedbackContent" class="form-label">Feedback Content</label>
                <textarea class="form-control" id="FeedbackContent" name="FeedbackContent" required><%= feedback.FeedbackContent %></textarea>
            </div>
            <button type="submit" class="btn btn-primary">Update Feedback</button>
        </form>
    </div>
</body>
</html>

Final Integration

In your main application file (e.g., app.js), ensure to include the necessary middleware and routes for all models:

const express = require('express');
const bodyParser = require('body-parser');
const methodOverride = require('method-override');
const sequelize = require('./config/database');
const userRoutes = require('./routes/userRoutes');
const inventoryItemRoutes = require('./routes/inventoryItemRoutes');
const orderRoutes = require('./routes/orderRoutes');
const supplierRoutes = require('./routes/supplierRoutes');
const shipmentRoutes = require('./routes/shipmentRoutes');
const reportRoutes = require('./routes/reportRoutes');
const qualityInspectionRoutes = require('./routes/qualityInspectionRoutes');
const costTrackingRoutes = require('./routes/costTrackingRoutes');
const notificationRoutes = require('./routes/notificationRoutes');
const feedbackRoutes = require('./routes/feedbackRoutes');
const app = express();
app.set('view engine', 'ejs');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(methodOverride('_method'));
app.use(express.static('public'));
app.use('/users', userRoutes);
app.use('/inventory-items', inventoryItemRoutes);
app.use('/orders', orderRoutes);
app.use('/suppliers', supplierRoutes);
app.use('/shipments', shipmentRoutes);
app.use('/reports', reportRoutes);
app.use('/quality-inspections', qualityInspectionRoutes);
app.use('/cost-tracking', costTrackingRoutes);
app.use('/notifications', notificationRoutes);
app.use('/feedback', feedbackRoutes);
sequelize.sync().then(() => {
    app.listen(3000, () => {
        console.log('Server is running on http://localhost:3000');
    });
}).catch(err => {
    console.error('Unable to connect to the database:', err);
});

This completes the setup for a complete CRUD application using Node.js, Sequelize, and EJS with Bootstrap 5 templates for all the specified models. You can further enhance the application by adding validations, authentication, and more features as needed.

Creating a Dashboard Page

To create a dashboard page that displays consolidated data related to your inventory management project, we will follow these steps:

Step 1: Define the Dashboard Route

Create a new file for the dashboard routes.

routes/dashboardRoutes.js:

const express = require('express');
const router = express.Router();
const DashboardController = require('../controllers/DashboardController');
router.get('/', DashboardController.displayDashboard);
module.exports = router;

Step 2: Create the Dashboard Controller

Create a new file for the dashboard controller.

controllers/DashboardController.js:

const UserRepository = require('../repositories/UserRepository');
const InventoryItemRepository = require('../repositories/InventoryItemRepository');
const OrderRepository = require('../repositories/OrderRepository');
const SupplierRepository = require('../repositories/SupplierRepository');
const ShipmentRepository = require('../repositories/ShipmentRepository');
const ReportRepository = require('../repositories/ReportRepository');
class DashboardController {
    async displayDashboard(req, res) {
        try {
            const users = await UserRepository.findAll();
            const inventoryItems = await InventoryItemRepository.findAll();
            const orders = await OrderRepository.findAll();
            const suppliers = await SupplierRepository.findAll();
            const shipments = await ShipmentRepository.findAll();
            const reports = await ReportRepository.findAll();
            res.render('dashboard', {
                title: 'Dashboard',
                userCount: users.length,
                inventoryItemCount: inventoryItems.length,
                orderCount: orders.length,
                supplierCount: suppliers.length,
                shipmentCount: shipments.length,
                reportCount: reports.length,
            });
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    }
}
module.exports = new DashboardController();

Step 3: Set Up the EJS View

Create a new EJS file for the dashboard view.

views/dashboard.ejs:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="https://stackpath.bootstrapcdn.com/bootstrap/5.1.3/css/bootstrap.min.css" rel="stylesheet">
    <title><%= title %></title>
</head>
<body>
    <div class="container">
        <h1 class="mt-5"><%= title %></h1>
        <div class="row mt-4">
            <div class="col-md-4">
                <div class="card text-white bg-primary mb-3">
                    <div class="card-header">Total Users</div>
                    <div class="card-body">
                        <h5 class="card-title"><%= userCount %></h5>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card text-white bg-success mb-3">
                    <div class="card-header">Total Inventory Items</div>
                    <div class="card-body">
                        <h5 class="card-title"><%= inventoryItemCount %></h5>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card text-white bg-warning mb-3">
                    <div class="card-header">Total Orders</div>
                    <div class="card-body">
                        <h5 class="card-title"><%= orderCount %></h5>
                    </div>
                </div>
            </div>
        </div>
        <div class="row mt-4">
            <div class="col-md-4">
                <div class="card text-white bg-info mb-3">
                    <div class="card-header">Total Suppliers</div>
                    <div class="card-body">
                        <h5 class="card-title"><%= supplierCount %></h5>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card text-white bg-danger mb-3">
                    <div class="card-header">Total Shipments</div>
                    <div class="card-body">
                        <h5 class="card-title"><%= shipmentCount %></h5>
                    </div>
                </div>
            </div>
            <div class="col-md-4">
                <div class="card text-white bg-secondary mb-3 <div class="card-header">Total Reports</div>
                    <div class="card-body">
                        <h5 class="card-title"><%= reportCount %></h5>
                    </div>
                </div>
            </div>
        </div>
    </div>
</body>
</html>

Step 4: Integrate Everything

In your main application file (e.g., app.js), ensure to include the new dashboard route:

const dashboardRoutes = require('./routes/dashboardRoutes');
// Other routes...
app.use('/dashboard', dashboardRoutes);

Final Steps

Run Your Application: Start your server and navigate to /dashboard to view the dashboard page.

Test the Data: Ensure that the data displayed on the dashboard reflects the current state of your database.

This setup provides a consolidated view of key metrics related to your inventory management project, allowing users to quickly assess the status of various components. You can further enhance the dashboard by adding charts, graphs, or more detailed statistics as needed.