restaurant-management-system.md

Designing an Online Shopping System

In this article, we will explore the object-oriented design and implementation of a Restaurant Management System using C++.

This system will handle various aspects such as table reservations, order processing, and kitchen management.

System Requirements

The Online Shopping System should:

1. Table Reservation Management: Handle booking and management of tables.
2. Order Management: Process food orders from customers.
3. Inventory Management: Keep track of kitchen inventory and supplies.
4. Billing System: Generate and manage customer bills.

Core Use Cases

1. Reserving Tables
2. Placing and Processing Food Orders
3. Managing Inventory
4. Generating and Processing Bills

Key Classes:

• RestaurantManagementSystem: Manages the entire system.
• Table: Represents a dining table in the restaurant.
• Order: Manages a customer's food order.
• Inventory: Keeps track of kitchen inventory.
• Bill: Represents a customer's bill.

#include <iostream>
#include <vector>
#include <string>

class Order {
public:
    Order(std::string itemName, int quantity) : itemName(std::move(itemName)), quantity(quantity) {}

    std::string getItemName() const { return itemName; }
    int getQuantity() const { return quantity; }

private:
    std::string itemName;
    int quantity;
};

class Table {
public:
    Table(int tableNumber) : tableNumber(tableNumber) {}

    int getTableNumber() const { return tableNumber; }
    bool isOccupied() const { return occupied; }
    const std::vector<Order>& getOrders() const { return orders; }

    void occupy() { occupied = true; }
    void release() { occupied = false; orders.clear(); }
    void placeOrder(const Order& order) { orders.push_back(order); }

private:
    int tableNumber;
    bool occupied = false;
    std::vector<Order> orders;
};

class Inventory {
public:
    void addItem(std::string itemName, int quantity) {
        inventory[itemName] += quantity;
    }

    bool processOrder(const Order& order) {
        if (inventory[order.getItemName()] >= order.getQuantity()) {
            inventory[order.getItemName()] -= order.getQuantity();
            return true;
        }
        return false;
    }

    void displayInventory() const {
        std::cout << "Inventory:\n";
        for (const auto& item : inventory) {
            std::cout << item.first << ": " << item.second << "\n";
        }
        std::cout << "----------------\n";
    }

private:
    std::unordered_map<std::string, int> inventory;
};

class Bill {
public:
    Bill(int tableNumber) : tableNumber(tableNumber) {}

    int getTableNumber() const { return tableNumber; }
    double getTotalAmount() const { return totalAmount; }

    void calculateTotal(const std::vector<Order>& orders) {
        for (const auto& order : orders) {
            // Assume a simple price per item for demonstration purposes
            totalAmount += itemPrices[order.getItemName()] * order.getQuantity();
        }
    }

private:
    int tableNumber;
    double totalAmount = 0.0;
    std::unordered_map<std::string, double> itemPrices{
        {"Dish1", 10.0},
        {"Dish2", 15.0},
        // Add more items and prices as needed
    };
};

class RestaurantManagementSystem {
public:
    void reserveTable(int tableNumber) {
        tables[tableNumber - 1].occupy();
    }

    void releaseTable(int tableNumber) {
        tables[tableNumber - 1].release();
    }

    void placeOrder(int tableNumber, const Order& order) {
        if (tables[tableNumber - 1].isOccupied() && inventory.processOrder(order)) {
            tables[tableNumber - 1].placeOrder(order);
        } else {
            std::cout << "Order cannot be placed. Table not occupied or insufficient inventory.\n";
        }
    }

    void generateBill(int tableNumber) {
        Table& table = tables[tableNumber - 1];
        if (table.isOccupied()) {
            Bill bill(tableNumber);
            bill.calculateTotal(table.getOrders());
            std::cout << "Bill for Table " << tableNumber << " - Total Amount: $" << bill.getTotalAmount() << "\n";
        } else {
            std::cout << "Cannot generate bill. Table not occupied.\n";
        }
    }

    void displayInventory() const {
        inventory.displayInventory();
    }

private:
    std::vector<Table> tables{
        Table(1),
        Table(2),
        Table(3),
        // Add more tables as needed
    };

    Inventory inventory;
};

int main() {
    RestaurantManagementSystem restaurant;

    // Reserve tables
    restaurant.reserveTable(1);
    restaurant.reserveTable(2);

    // Display inventory
    restaurant.displayInventory();

    // Place orders
    restaurant.placeOrder(1, Order("Dish1", 2));
    restaurant.placeOrder(2, Order("Dish2", 1));
    restaurant.placeOrder(1, Order("Dish3", 3)); // Should fail due to insufficient inventory

    // Generate bills
    restaurant.generateBill(1);
    restaurant.generateBill(2);

    // Release tables
    restaurant.releaseTable(1);
    restaurant.releaseTable(2);

    return 0;
}