V ID Y AN

N IK
SEN K U R SECO ND ARY SC

ET
O

H
SHA
I

OO
AN
L
SESSION:2024-2025
Informatics Practices Project
TOPIC: Cafe Management System
ROLL NO:
SUBMITTED BY: Harshit Verma

SUBMITTED TO: Mr. Shivakant

Mishra Sir
● A Cafe Management System is a software application or tool designed to
streamline and manage various operations in a café or restaurant. It helps
café owners and staff handle tasks like order processing, inventory
management, billing, customer relationship management (CRM), and
reporting in a more efficient and organize manner.

● By automating routine tasks and providing real-time data, a cafe

management system can improve efficiency, reduce errors, enhance
customer service, and ultimately increase profitability.
 THE SYSTEM REQUIREMENT :

Hardware Requirements:

● Processor (CPU):
○ Minimum: Intel Core i3 or equivalent
○ Recommended: Intel Core i5 or higher
● RAM (Memory):
○ Minimum: 4 GB
○ Recommended: 8 GB or more
● Hard Drive (Storage):
○ Minimum: 500 GB HDD or SSD
○ Recommended: 256 GB SSD for faster performance
(especially for systems with heavy transaction processing)
● Display:
○ Minimum: 15-inch monitor with 1366x768 resolution
○ Recommended: Full HD display (1920x1080) for better
clarity
● Peripherals:
○ POS (Point-of-Sale) terminal or touch screen (if applicable)
○ Barcode scanner (if selling products with barcodes)
○ Receipt printer
○ Cash drawer
● Networking:
○ Stable internet connection (if using cloud-based services)
○ Local area network (LAN) setup for connected devices (POS
systems, printers)

2. Software Requirements:

● Operating System:
○ Windows 10 or later (if using a Windows-based system)
○ macOS (if using a Mac)
○ Linux (if using open-source software)
● Database:
○ MySQL, SQL Server, or PostgreSQL for storing customer,
sales, and inventory data
○ SQLite (for smaller, simpler setups)
● Additional Software:
 ○ Web browser (Chrome, Firefox, Safari) if using a cloud-based
system
○ Microsoft Office or other office suite (for reports, inventory
management, etc.)
○ POS software (may be part of the cafe management system
or installed separately)
○ Backup software (for data security)

3. Other Considerations:

● Cloud vs. On-premises:

○ Cloud-based systems typically have lower hardware
requirements since most processing is done on the cloud.
○ On-premises systems may require more robust hardware
setups depending on the features and number of users.
● Security:
○ Antivirus and firewall software to secure POS and customer
data.
○ Regular updates for system and software security patches.
Key features of a Cafe Management System
include:

● Order Management: Allows staff to take orders from customers (either manually
or digitally), send them to the kitchen, and update order statuses.

● Billing & Payments: Generates bills based on orders, calculates totals, applies
discounts or taxes, and processes payments (cash, card, or digital).

● Inventory Management: Tracks stock levels of ingredients, beverages, and

supplies, helping to prevent shortages and waste.

● Customer Relationship Management (CRM): Stores customer data (like

preferences, visit history, etc.) to offer personalised service and promotions.

● Employee Management: Tracks employee work schedules, payroll, and

performance metrics.

● Reporting & Analytics: Provides detailed reports on sales, profit margins,

inventory usage, and customer preferences to help make data-driven
decisions.
 ABOUT PYTHON

Python is a high-level, interpreted programming language that is widely known for its simplicity,
readability, and versatility. It was created by Guido van Rossum and first released in 1991.
Since then, Python has become one of the most popular programming languages in the world,
used for everything from web development and data analysis to artificial intelligence and
scientific computing.

Key Features of Python

1. Simple and Readable Syntax

o Python emphasizes code readability and simplicity, making it an excellent
language for beginners.
o It uses indentation to define code blocks instead of curly braces or semicolons,
which helps in writing clean and easily understandable code.
2. Interpreted Language
o Python is an interpreted language, meaning that the code is executed line by line
by the Python interpreter. This makes debugging easier, but it can sometimes lead
to slower execution compared to compiled languages.
3. Dynamically Typed
o Python is dynamically typed, which means you don’t need to declare the type of a
variable when defining it. The interpreter will figure it out at runtime.
4. Object-Oriented and Functional
o Python supports both object-oriented programming (OOP) and functional
programming paradigms. You can define classes and objects, use inheritance,
and also use functions as first-class objects (functions can be assigned to
variables, passed as arguments, etc.).
5. Extensive Standard Library
o Python comes with a vast standard library that supports many tasks, such as file
I/O, system calls, regular expressions, and working with data formats like JSON
and CSV. This allows you to quickly solve many problems without needing
external libraries.
6. Cross-Platform
o Python is cross-platform, meaning that it can run on various operating systems
like Windows, macOS, Linux, and others. Python code generally runs the same
way across these platforms.

Popular Use Cases for Python

1. Web Development
o Python is used extensively in web development with frameworks like Django,
Flask, and FastAPI.
 o These frameworks provide tools and libraries for building robust web applications
quickly.
2. Data Science and Machine Learning
o Python is one of the leading languages in data science, machine learning, and
artificial intelligence. Libraries like NumPy, Pandas, Matplotlib, TensorFlow,
and Scikit-learn make it easy to process data, visualize it, and build machine
learning models.
3. Automation and Scripting
o Python is commonly used for automating repetitive tasks, such as file
management, web scraping, or sending emails, thanks to libraries like Selenium,
BeautifulSoup, and requests.
4. Scientific Computing
o Python is widely used in scientific research for numerical and symbolic
computation with libraries such as SciPy, SymPy, and Jupyter notebooks.
5. Game Development
o Although not as popular as other languages like C++ or Java for large-scale game
development, Python is used in creating 2D games, especially with libraries like
Pygame.
6. Cybersecurity
o Python is also commonly used in cybersecurity tasks, such as writing scripts for
penetration testing, exploiting vulnerabilities, and automating security processes.

Python vs Other Languages

 Python vs JavaScript: While both are high-level languages used for web development,
Python excels in data science, automation, and scientific computing, while JavaScript is
essential for client-side web development and building interactive websites.
 Python vs Java: Java is a statically typed, compiled language commonly used for large-
scale enterprise applications, while Python is dynamically typed and interpreted, which
makes it more flexible and quicker for rapid development.
 Python vs C/C++: Python is much easier to learn and use, especially for beginners. C
and C++ offer more control over low-level operations like memory management, which
makes them faster but more complex.

Conclusion
Python’s simplicity, powerful libraries, and broad applications make it an excellent choice for
programmers at all levels. Whether you're a beginner trying to learn programming or an expert
building sophisticated machine learning models, Python provides the tools and community to
help you succeed.
 ABOUT MYSQL

MySQL is one of the most popular relational database management systems (RDBMS) in the
world. It is open-source, widely used for web applications, and forms the backbone of many web
technologies. MySQL uses Structured Query Language (SQL) for managing and manipulating
relational databases. It is known for its reliability, performance, and ease of use.

Key Features of MySQL

1. Open Source
o MySQL is open-source software, meaning it's freely available to the public. You
can download, use, and modify the source code. MySQL is maintained and
distributed under the GNU General Public License (GPL).
2. Relational Database Management System (RDBMS)
o MySQL is an RDBMS, meaning it stores data in tables that are related to each
other. It uses structured query language (SQL) for creating, modifying, querying,
and managing data in relational databases.
3. Scalability and Flexibility
o MySQL can handle large databases and can scale as your data grows. It supports
very large databases with terabytes of data.
4. Cross-Platform Support
o MySQL runs on a wide variety of operating systems, including Linux, Windows,
macOS, and Unix.
5. High Performance
o MySQL is designed for speed and high performance. It uses indexing, query
optimization, and caching techniques to ensure fast query response times, even
with large datasets.
6. Multi-User Support
o MySQL supports multiple users, providing user authentication and permissions. It
has robust support for multi-threading, allowing concurrent access by multiple
users without compromising performance.
7. Replication
o MySQL supports master-slave replication, allowing for database copies (replicas)
to be maintained in different locations, improving performance and data
redundancy.
8. Security
o MySQL provides strong security features, including SSL support, user
authentication, and encrypted connections to protect sensitive data.
9. Data Types
o MySQL supports a wide range of data types, including INT, VARCHAR,
DATE, TEXT, BLOB, and more. This makes it flexible enough to handle a wide
variety of data.
10. Stored Procedures and Triggers
 o MySQL supports stored procedures, which allow you to store SQL queries in
the database and execute them repeatedly. It also supports triggers, which are
special types of stored procedures executed automatically in response to certain
events (e.g., before or after an insert or update operation).

Key Components of MySQL

1. Database: A collection of related tables.
2. Table: A structured set of data stored in rows and columns.
3. Query: A command that retrieves or manipulates data in a database. It can be a
SELECT, INSERT, UPDATE, or DELETE statement.
4. Index: A data structure used to improve the speed of data retrieval operations on a
database table.
5. Stored Procedure: A precompiled collection of SQL statements that can be executed
with a single call.
6. Trigger: A set of SQL statements that are automatically executed or fired when certain
events occur on a database table.

Conclusion
MySQL is a robust, flexible, and widely-used database system that forms the foundation of many
web applications and data-driven projects. It is popular for its high performance, scalability, and
ease of use. Whether you are building a small web app or a large-scale enterprise application,
MySQL offers the tools and features you need for effective database management.
PYTHON
CODE:-
import mysql.connector
from datetime import datetime

# Connect to MySQL database

def connect_to_db():
return mysql.connector.connect( host="localhost",user="root", password="SVNDEV", database="CafeManagement")

# Add new item to the menu

def add_menu_item(item_name, price):
db = connect_to_db()
cursor = db.cursor()
query = "INSERT INTO MenuItems (item_name, price) VALUES (%s, %s)"
cursor.execute(query, (item_name, price))
db.commit()
print(f"{item_name} has been added to the menu with price {price}")
db.close()

# View all menu items

def view_menu():
db = connect_to_db()
cursor = db.cursor()
cursor.execute("SELECT * FROM MenuItems")
items = cursor.fetchall()
print("\nCafe Menu:")
print(" ")
for item in items:
print(f"{item[0]}. {item[1]} - ${item[2]:.2f}")
print(" ")
db.close()

# Create a new order

def create_order():
db = connect_to_db()
cursor = db.cursor()

# Get current date and time for the order

order_date = datetime.now()
cursor.execute("INSERT INTO Orders (order_date, total_amount) VALUES (%s, %s)", (order_date, 0))
db.commit()

order_id = cursor.lastrowid
print(f"New Order Created with Order ID: {order_id}")

total_amount = 0.0
while True:
item_id = int(input("Enter item ID to add to order (0 to stop): "))
if item_id == 0:
break
quantity = int(input("Enter quantity: "))

# Get item price

cursor.execute("SELECT price FROM MenuItems WHERE item_id = %s", (item_id,))
item = cursor.fetchone()
if item:
price = item[0]
total_amount += price * quantity
cursor.execute("INSERT INTO OrderItems (order_id, item_id, quantity) VALUES (%s, %s, %s)",
(order_id, item_id, quantity))
db.commit()
print(f"Added {quantity} of item {item_id} to the order.")
else:
print("Invalid item ID. Please try again.")

# Update total order amount

cursor.execute("UPDATE Orders SET total_amount = %s WHERE order_id = %s", (total_amount, order_id))
db.commit()

print(f"Total Amount for Order {order_id}: ${total_amount:.2f}")

db.close()

# Main function to run the system

def main():
while True:
print("\n--- Cafe Management System ---")
 print("1. View Menu")
print("2. Add Item to Menu")
print("3. Create New Order")
print("4. Exit")

choice = input("Enter choice (1/2/3/4): ")

if choice == "1":
view_menu()
elif choice == "2":
item_name = input("Enter item name: ")
price = float(input("Enter item price: "))
add_menu_item(item_name, price)
elif choice == "3":
create_order()
elif choice == "4":
print("Exiting system...")
break
else:
print("Invalid choice! Please try again.")

# Run the program

if name == " main ":
main()
SQL
QUERY AND
TABLE :-
 Creation of
DATABASE and TABLE:-
INSERTION OF DATA IN TABLE
TABLE OUTPUT:-
 Output
The output of the “Cafe Management System” depends on the actions taken by the user
during the program's execution. Let's break down the possible outputs for each of the
actions and provide an example scenario based on the corrected code.

1. Initial Prompt:-

When you run the program, the following menu is displayed to the user :

--- Cafe Management System ---

1. View Menu
2. Add Item to Menu
3. Create New Order
4. Exit
Enter choice (1/2/3/4):

The user can then select one of the options (1, 2, 3, or 4) by entering the corresponding
number.

---

2. Option 1:- View Menu

If the user selects “1” (View Menu) and there are already items in the `MenuItems` table, the
system will display a list of available menu items:

Example output (assuming `MenuItems` has items like "Coffee" and "Tea"):

Cafe Menu:
--------------------------
1. Coffee - $2.50
2. Tea - $1.75
--------------------------

If no items have been added yet, the menu will be empty:

Cafe Menu:
--------------------------
(no items available)
--------------------------
---

3. Option 2:- Add Item to Menu

If the user selects “2” (Add Item to Menu), the program will prompt the user for the item
name and price. Here's an example:

Enter item name: Cappuccino

Enter item price: 3.50
Cappuccino has been added to the menu with price $3.50

This will insert the new item into the `MenuItems` table, and subsequent calls to **View
Menu** will show this new item.

---

4. Option 3:- Create New Order

If the user selects “3” (Create New Order), the system will create a new order and prompt
the user to enter the **item ID** and **quantity**. Here's an example scenario where the
user orders two coffees:

New Order Created with Order ID: 1

Enter item ID to add to order (0 to stop): 1
Enter quantity: 2
Added 2 of item 1 to the order.
Enter item ID to add to order (0 to stop): 0
Total Amount for Order 1: $5.00

- The order is created with an `order_id` (1 in this case).

- The user enters “item ID 1” (for Coffee) and chooses a quantity of 2.
- The system calculates the total amount (`2 * 2.50 = 5.00`).
- The details are saved in the `Orders` and `OrderItems` tables in the database.

---
5. Option 4:- Exit

If the user selects “4”(Exit), the program will print:

Exiting system...

The program then terminates.

---
 Summary of Outputs

-View Menu :- Displays a list of items in the menu.

- Add Item to Menu :- Prompts the user for item details and adds them to the database.

- Create Order :- Prompts the user for item ID and quantity, then calculates and displays the
total order amount.

- Exit :- Exits the program and prints "Exiting system...".

The system interacts with the MySQL database, saving the added menu items, created
orders, and order details in corresponding tables. The output of the program varies based on
the user's interactions, as described in the examples above.
 EXPLANATION:-
This system is designed to help manage a cafe's operations efficiently using a database (in this case, MySQL) for
storing data and Python for interacting with the database.

1. MySQL Database

The system stores all the necessary data in a MySQL database. A database is essentially a structured container
for data, and we use it to store information related to the cafe's operations. The database is organized into tables,
and each table contains rows and columns, much like a spreadsheet.

Here are the key tables that would be part of the cafe management system:

a. Menu Table

This table stores information about the items available for sale at the cafe, such as:

 Item Name (e.g., "Coffee", "Sandwich", "Cake")

 Price (e.g., $2.50 for coffee)

Each menu item is identified by a unique Item ID.

b. Orders Table

This table stores information about customer orders. When a customer places an order, the system creates a new
record in the orders table with:

 Order ID: A unique identifier for the order.

 Customer Name: The name of the person who placed the order.
 Total Amount: The total cost of the items ordered.
 Order Date: The date and time the order was placed.

c. Order Items Table

This table tracks the specific items within each order. Each record in this table links an order to the menu item(s)
purchased, and it contains:

 Order ID: The identifier linking the item to a specific order.

 Item ID: The identifier of the menu item.
 Quantity: How many of that item the customer ordered.

2. Operations of the Cafe Management System

The cafe management system performs several key operations to help run the business smoothly:
a. Adding and Managing Menu Items

The menu is the heart of the cafe, and it contains all the products that the cafe sells. A manager or admin can add
new items to the menu (e.g., new drinks, snacks, or meals). Each menu item is associated with a name (like
"Coffee") and a price (like "$2.50"). These items are stored in the Menu Table.

b. Taking Orders

When a customer arrives, they can place an order by selecting items from the menu. The system will:

 Create an order record in the Orders Table with the customer's name and the total amount for the items ordered.
 Record the individual items in the Order Items Table, along with their quantity and the specific menu item they
correspond to.

This allows the system to know exactly what each customer has ordered and the total cost of their order.

c. Generating Bills

Once the order has been placed and processed, the system can generate a bill for the customer. The bill will:

 List the items ordered by the customer (e.g., "2 Coffees", "1 Sandwich").
 Show the quantity and price of each item.
 Calculate the total amount due.

The system can fetch the order details from the Orders Table and the Order Items Table, compute the total cost,
and present it in an organized format.

d. Tracking Inventory and Sales

To keep the cafe running smoothly, it is important to manage inventory and sales. The system can help by:

 Tracking the stock of ingredients (e.g., how many cups of coffee beans are available).
 Recording sales data (e.g., how much revenue was generated from orders).
 Generating reports on sales performance, popular items, and other insights that help in decision-making.

This is particularly important for restocking items and maintaining the right balance of supplies.

e. Employee Management (Optional)

In a more advanced system, the cafe management software can also manage employee data. This would include:

 Employee Names and Roles (e.g., cashier, chef, waiter).

 Work Schedules (when they are working).
 Payroll (how much they are paid for their work).

This helps manage the cafe's workforce efficiently and ensures employees are paid accurately for their work.

3. Benefits of a Cafe Management System

Implementing such a system in a cafe can significantly improve the efficiency of operations. Here are some key
benefits:

 Faster Order Processing: By automating the ordering and billing process, staff can serve customers more quickly
and reduce human errors.
  Inventory Management: The system helps track inventory levels and sales, making it easier to restock ingredients
and manage resources effectively.
 Accurate Billing: The system automatically generates accurate bills based on the menu items ordered, avoiding
manual errors.
 Sales Insights: The system can generate reports on sales, helping the management make data-driven decisions about
which items to promote, discount, or discontinue.
 Employee Management: Efficient scheduling and payroll management help improve staff productivity and ensure
that employees are compensated correctly.

4. User Roles and Access

The system can have different types of user roles based on who is accessing it. Common roles might include:

 Admin: The person who has full control over the system. They can manage the menu, employees, and view sales
reports.
 Waiter/Server: The person who takes customer orders and generates bills. They can view the menu and create
orders but may not have access to administrative functions.
 Cashier: The person responsible for processing payments and managing financial transactions.

Each role can have specific permissions, ensuring that the system is used in a way that matches the needs of the
cafe.
 CONCLUSION:-
A Cafe Management System is an essential
tool for streamlining cafe operations. By
organizing key data (such as menu items, orders,
and inventory) in a MySQL database and
automating tasks using Python, cafes can run
more efficiently. Employees can focus on
serving customers while the system handles
routine tasks like billing, tracking inventory, and
generating reports. This makes it easier to
manage the cafe, improve customer service, and
make informed decisions based on data.
 BIBLIOGRAPHY:-

 www.Google.com
 CLASS 12 NCERT INFORMATION
PRACTICES BOOK.
 CLASS 12 INFORMATION
PRACTICES BY SUMITA ARORA.
 www.wikipedia.com