BIODATA

NAME: - ARYAN KUMAR

CLASS: - 12-A (SCIENCE)

TOPIC: - Restaurant Management

SUBJECT TEACHER: - Mrs. Kiran

Sonone

1|Page
 CERTIFICATE

This is to certify that Mr. ARYAN KUMAR of class XII – Science,

Kendriya Vidayalaya N.A.D. Karanja has completed the project on
Restaurant Management of Mrs. Kiran Sonone, PGT – Computer
Science. This project is a requirement of All India Senior Secondary
Certificate Examination (AISSCE) as prescribed by CBSE for the year
2024-25.
CBSE Roll No. _________________

Internal Examiner External Examiner

(Mrs. Kiran Sonone)

Principal
2|Page
ACKNOWLEDGEMENT
I would like to express my heartfelt gratitude to my
Computer Science teacher, Mrs. Kiran Sonone. Her
invaluable guidance, expertise, and encouragement were
instrumental throughout the preparation of this project. Her
dedication and support have been a source of immense
inspiration.

I am also thankful to my respected teachers, who provided

valuable insights, and to the library and office staff for their
support and cooperation. Each of them contributed
significantly to making this project a learning experience.

A special thanks to my friends, classmates, and, most

importantly, my parents, whose unwavering encouragement
and belief in my abilities kept my confidence high and
motivated me to persevere through every challenge.
Without their collective support, completing this project
would not have been possible.

3|Page
 INDEX
1. Introduction
2. Requirements

3. Objective of project

4. Flow Of Programme

5. CODE

6. MySQL Database and Tables

7. Execution of programme

8. Output

9. Conclusion

10. Bibliography

4|Page
 INTRODUNCTION

The programming language used in the project is Python,

while MySQL serves as the database system.

Python's role includes handling modules for different

restaurant roles (e.g., admin, waiter, cook, and
storekeeper) and managing the program's main workflow.
Key libraries include mysql.connector for MySQL
interactions and prettytable for displaying data in tables.

The MySQL database contains structured tables for

various data aspects, including announcements,
complaints, menu, orders, requests, staff, and store
items, to support comprehensive management of the
restaurant's operations.

5|Page
 REQUIREMENTS

For this Python-based Restaurant Management program using MySQL, here are the
minimum and recommended system requirements:

Minimum System Requirements

 Operating System: Windows 7 / macOS 10.10 (Yosemite) / Ubuntu 16.04 or

equivalent Linux
 Processor: Dual-core CPU (2.0 GHz)
 RAM: 4 GB
 Storage: 500 MB free space
 Python Version: Python 3.6
 MySQL Version: MySQL 5.7
 Dependencies:
o MySQL Connector (pip install mysql.connector)
o PrettyTable (pip install prettytable)

Recommended System Requirements

 Operating System: Windows 10 or later / macOS 10.15 (Catalina) or later / Ubuntu

18.04 or later
 Processor: Quad-core CPU (2.5 GHz or faster)
 RAM: 8 GB or more
 Storage: 1 GB free space
 Python Version: Python 3.8 or higher
 MySQL Version: MySQL 8.0 or higher
 Additional Requirements: Stable internet connection for downloading dependencies,
administrative rights for installations

These requirements ensure the program runs smoothly, particularly during multi-role
operations and data-intensive tasks.

6|Page
 OBJECTIVE OF PROJECT
 Automate Restaurant Operations: Simplify daily tasks such as order
management, inventory tracking, and staff coordination through a
terminal-based interface.

 Enhance Role-Based Efficiency: Develop dedicated modules for

Admin, Cook, Waiter, and Storekeeper roles to streamline specific
tasks relevant to each position.

 Improve Order Processing: Enable quick order placement, status

checking, and order fulfilment, reducing wait times and enhancing
customer service.

 Streamline Inventory Management: Allow the storekeeper to track,

update, and manage inventory to maintain optimal stock levels and
reduce waste.

 Optimize Staff Management: Provide an Admin module for adding,

updating, and viewing staff details, ensuring efficient personnel
management and role-based access control.

 Facilitate Communication and Complaint Resolution: Include options

for staff to submit complaints or requests and for Admin to view and
address these, fostering better internal communication.

 Ensure Data Security: Implement password encryption to secure

access and ensure sensitive information is protected.

 Centralize Data Storage: Maintain organized tables for menu items,

staff details, announcements, orders, complaints, and requests
within a MySQL database for easy data retrieval and management.

7|Page
8|Page
 FLOW OF PROGRAME

9|Page
 CODE
1st File: Create Database and Tables.py
import mysql.connector

def create_database_and_tables():

db = mysql.connector.connect(host="localhost", user="root",
password="octane", auth_plugin='mysql_native_password')
cursor = db.cursor()

# Create database
cursor.execute("CREATE DATABASE IF NOT EXISTS test3")
cursor.execute("USE test3")

# Create 'announcements' table

cursor.execute("""
CREATE TABLE IF NOT EXISTS announcements (
id INT NOT NULL,
message TEXT NOT NULL,
priority ENUM('Low', 'Medium', 'High') DEFAULT
'Low',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (id)
)
""")

# Create 'complaints' table

cursor.execute("""
CREATE TABLE IF NOT EXISTS complaints (
complaint_id INT NOT NULL,
waiter_name VARCHAR(50),
complaint TEXT NOT NULL,
date_submitted DATE,
status VARCHAR(20) DEFAULT 'Pending',
PRIMARY KEY (complaint_id)
)
""")
10 | P a g e
 # Create 'menu' table
cursor.execute("""
CREATE TABLE IF NOT EXISTS menu (
food_item VARCHAR(50),
price DECIMAL(5,2)
)
""")

# Create 'orders' table

cursor.execute("""
CREATE TABLE IF NOT EXISTS orders (
id INT NOT NULL,
items TEXT NOT NULL,
status ENUM('Pending', 'Accepted', 'Rejected',
'Completed') DEFAULT 'Pending',
reason VARCHAR(255),
time_required INT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (id)
)
""")

# Create 'requests' table

cursor.execute("""
CREATE TABLE IF NOT EXISTS requests (
request_id INT NOT NULL,
staff_name VARCHAR(50),
request TEXT NOT NULL,
date_submitted DATE,
PRIMARY KEY (request_id)
)
""")

# Create 'staff' table

cursor.execute(""" CREATE TABLE IF NOT EXISTS staff ( name
VARCHAR(50), employee_id INT NOT NULL, position VARCHAR(20),
salary DECIMAL(7,2), performance VARCHAR(20), password
VARCHAR(255), PRIMARY KEY (employee_id)) """)

# Create 'store' table

11 | P a g e
 cursor.execute("""
CREATE TABLE IF NOT EXISTS store (
item VARCHAR(50),
quantity INT,
MFG_Date_of_purchase DATE
)
""")

# Insert admin user into 'staff' table

cursor.execute("""
INSERT INTO staff (name, employee_id, position, salary,
performance, password)
VALUES ('admin', 1, 'Admin', NULL, 'Good', '123')
""")

db.commit() # Commit changes

print("Database, tables, and admin user created
successfully!")

# Close the connection

cursor.close()
db.close()

create_database_and_tables()

2nd File : Main.py

import mysql.connector
from admin import admin_module
from waiter import waiter_module
from cook import cook_module
from storekeeper import storekeeper_module

#connect to the database

def connect_to_db():
return mysql.connector.connect( host="localhost",
user="root", password="octane", database="archyansrestaurant",
auth_plugin='mysql_native_password')

12 | P a g e
def login_module(cursor):
try:
position = input("Enter your position (Waiter, Cook,
Admin, Storekeeper): ")
password = input("Enter your password: ")

#check if the position and password match

cursor.execute("SELECT name FROM Staff WHERE position='"
+ position + "' AND password='" + password + "'")
result = cursor.fetchone()

if result:
print("Welcome, " + result[0] + "!") # result[0] is
the name of the user
return position
else:
print("Invalid credentials!")
return None
except mysql.connector.Error as e:
print("Database error: " + str(e))
return None
except Exception as e:
print("An unexpected error occurred: " + str(e))
return None

def get_yes_no_input(prompt):
"""Utility function to get a valid 'Yes' or 'No' input."""
while True:
try:
choice = input(prompt).strip().title()
if choice not in ['Yes', 'No']:
raise ValueError
return choice
except ValueError:
print("Invalid input. Please enter 'Yes' or 'No'.")

def main():

13 | P a g e
 while True: # Loop for multiple logins
connection = connect_to_db()
cursor = connection.cursor()

role = login_module(cursor)

if role == "Waiter":
waiter_module(cursor, connection)
elif role == "Cook":
cook_module(cursor, connection)
elif role == "Admin":
admin_module(cursor, connection)
elif role == "Storekeeper":
storekeeper_module(cursor, connection)
else:
print("No valid role found.")

logout_choice = get_yes_no_input("Do you want to log

out? (Yes/No): ")

if logout_choice == 'Yes':
exit_choice = get_yes_no_input("Do you want to exit
the program? (Yes/No): ")

if exit_choice == 'Yes':
print("Exiting the Program!")
break # Exit the while loop and close the
program
else:
print("Logging out...\n")
# Reset the connection and cursor for the next
login
continue

# Cleanup before exiting

cursor.close()
connection.close()

main()
14 | P a g e
3rd file: Admin.py
import mysql.connector
from prettytable import PrettyTable #for tables

def admin_module(cursor, connection):

while True:
print("\n--- Admin Module ---")
print("1. Add Food Items to Menu")
print("2. Update Staff Details")
print("3. Delete food items from menu")
print("4. Make Announcements")
print("5. View Staff List")
print("6. Update existing Staff Details")
print("7. Update Staff password")
print("8. View and fix complaints")
print("9. View Requests from employees")
print("10. Delete Employees")
print("11. Exit")

while True: # This type of try_except will be found

almost in every input commnad as to avoid any mixup in inputs
try:

choice = int(input("Enter choice: "))

if choice not in [i for i in range(1,12)]:

raise ValueError

else:
break

except ValueError:
print("Invalid Input. Try again!")

if choice == 1:
add_food_items(cursor, connection)
elif choice == 2:

15 | P a g e
 add_staff(cursor, connection)
elif choice == 3:
delete_food_item(cursor, connection)
elif choice == 4:
make_announcement(cursor, connection)
elif choice == 5:
view_staff_list(cursor)
elif choice == 6:
update_staff_details(cursor, connection)
elif choice == 7:
update_staff_password(cursor, connection)
elif choice == 8:
view_and_fix_complaints(cursor, connection)
elif choice == 9:
view_requests(cursor)
elif choice == 10:
delete_employee(cursor, connection)
elif choice == 11:
break
else:
print("Invalid choice. Please try again.")

cursor.close() # Close the cursor

connection.close() # Close the connection

def view_staff_list(cursor):
print("\n--- Staff List ---")

try:
# get all staff details
cursor.execute("SELECT name, employee_id, position,
salary, performance, password FROM Staff")
staff_records = cursor.fetchall() # Fetch all records

if staff_records:
# Create Table
table = PrettyTable()
table.field_names = ["Name", "Employee ID",
"Position", "Salary", "Performance", "Password"]

# Add all staff records to the table

16 | P a g e
 for row in staff_records:
table.add_row(row)

# Print the table

print(table)
else:
print("No staff records found.")

except mysql.connector.Error as err:

print(f"Error: {err}")

def add_food_items(cursor, connection):

print("Enter food items in the format: item_name1:price1,
item_name2:price2, ...")
food_items_input = input("Enter multiple food items and
prices: ")

food_items = food_items_input.split(',')

for food_item in food_items:

try:
name, price = food_item.split(':')
name = name.strip()
price = float(price.strip())

cursor.execute("INSERT INTO Menu (food_item, price)

VALUES ('" + name + "', " + str(price) + ")")
print("Added " + name + " to the menu with price @"
+ str(price))
except ValueError:
print("Invalid format for " + food_item + ". Use
'item_name:price' format.")
except mysql.connector.Error as err:
print("Error: " + str(err))

# Commit changes to the database using the connection

connection.commit()
print("Menu updated successfully.\n")

def delete_food_item(cursor, connection):

17 | P a g e
 print("\n--- Delete Food Item from Menu ---")
food_item = input("Enter the name of the food item to
delete: ").strip()

cursor.execute("SELECT * FROM Menu WHERE food_item = '" +

food_item + "'")
result = cursor.fetchone()

if result:

cursor.execute("DELETE FROM Menu WHERE food_item = '" +

food_item + "'")
print("Deleted " + food_item + " from the menu.")
else:
print("Food item '" + food_item + "' not found in the
menu.")

connection.commit()
print("Menu updated successfully.\n")

def add_staff(cursor, connection):

print("\n--- Add Staff ---")

name = input("Enter staff name: ").title()

employee_id = input("Enter employee ID (unique): ")
position = input("Enter position: ").title()

while True:

try:

salary = float(input("Enter salary: "))

break
except ValueError:
print("Invalid input for salary. Please enter in
decimal format.")

performance = input("Enter performance: ")

# Password input
18 | P a g e
 while True:
password = input("Enter password: ")
break

try:
cursor.execute("INSERT INTO Staff (name, employee_id,
position, salary, performance, password) VALUES ('" + name + "',
'" + employee_id + "', '" + position + "', " + str(salary) + ",
'" + performance + "', '" + password + "')")
print("Staff details added successfully.\n")
except mysql.connector.Error as err:
print("Error: " + str(err))

# Commit changes to the database

connection.commit()

def make_announcement(cursor, connection):

print("\n--- Make an Announcement ---")
announcement = input("Enter the announcement message:
").strip()

# Let admin choose priority level

print("Select priority: 1. Low 2. Medium 3. High")
priority_choice = int(input("Enter priority (1-3): "))

priority_map = {1: 'Low', 2: 'Medium', 3: 'High'}

priority = priority_map.get(priority_choice)

cursor.execute("INSERT INTO Announcements (message,

priority) VALUES ('" + announcement + "', '" + priority + "')")

connection.commit()
print("Announcement made successfully.\n")

# Function to update staff details except password

def update_staff_details(cursor, connection):
try:
employee_id = input("Enter the Employee ID of the staff
to update details: ")

19 | P a g e
 # Fetch the current details of the staff
cursor.execute("SELECT name, position, salary,
performance FROM Staff WHERE employee_id = '" + employee_id +
"'")
result = cursor.fetchone()

if result:
print("Current Details: Name: " + result[0] + ",
Position: " + result[1] + ", Salary: " + str(result[2]) + ",
Performance: " + result[3])

#updated details
new_name = input("Enter new name (Leave blank to
keep as " + result[0] + "): ") or result[0]
new_position = input("Enter new position (Leave
blank to keep as " + result[1] + "): ") or result[1]
new_salary = input("Enter new salary (Leave blank to
keep as " + str(result[2]) + "): ") or str(result[2])
new_performance = input("Enter new performance
(Leave blank to keep as " + result[3] + "): ") or result[3]

# Update details in database

cursor.execute("UPDATE Staff SET name='" + new_name
+ "', position='" + new_position + "', salary=" + new_salary +
", performance='" + new_performance + "' WHERE employee_id='" +
employee_id + "'")
connection.commit()
print("Staff details updated successfully!")
else:
print("Staff with this Employee ID does not exist.")

except Exception as e:
print("An error occurred: " + str(e))

# Function to update password only

def update_staff_password(cursor, connection):
try:
employee_id = input("Enter the Employee ID of the staff
to update password: ")

# Fetch the staff's current password

20 | P a g e
 cursor.execute("SELECT name, password FROM Staff WHERE
employee_id = '" + employee_id + "'")
result = cursor.fetchone()

if result:
print("Current password for " + result[0] + " is
hidden for security purposes.")

#new password
new_password = input("Enter new password: ")

# Update the password in database

cursor.execute("UPDATE Staff SET password='" +
new_password + "' WHERE employee_id='" + employee_id + "'")
connection.commit()
print("Password updated successfully!")
else:
print("Staff with this Employee ID does not exist.")

except Exception as e:
print("An error occurred: " + str(e))

def view_and_fix_complaints(cursor, connection):

print("\n--- Complaints ---")
cursor.execute("SELECT complaint_id, waiter_name, complaint,
date_submitted, status FROM Complaints WHERE status='Pending'")
complaints = cursor.fetchall()

if not complaints:
print("No pending complaints.")
return

for complaint in complaints:

print("Complaint ID: " + str(complaint[0]) + ", Waiter:
" + complaint[1] + ", Complaint: " + complaint[2] + ", Date
Submitted: " + str(complaint[3]) + ", Status: " + complaint[4])

complaint_id = input("Enter the complaint ID to mark as

fixed: ")
update_query = "UPDATE Complaints SET status='Fixed' WHERE
complaint_id=" + complaint_id
21 | P a g e
 cursor.execute(update_query)
connection.commit()
print("Complaint " + complaint_id + " has been marked as
fixed.\n")

def view_requests(cursor):
print("\n--- View Requests ---")

# Query to retrieve all requests

cursor.execute("SELECT staff_name, request, date_submitted
FROM Requests")
requests = cursor.fetchall() # Fetch all requests instead
of fetchmany

if not requests:
print("No requests found.")
else:
# Create Table
table = PrettyTable()

# Define table columns

table.field_names = ["Staff Name", "Request", "Date
Submitted"]

# Add rows to the table

for rq in requests:
table.add_row(rq)

# Print the table

print(table)

def delete_employee(cursor, connection):

print("\n--- Delete Employee ---")
employee_id = input("Enter the Employee ID of the staff
member to delete: ").strip()

# Check if the employee exists in the staff table

cursor.execute("SELECT * FROM Staff WHERE employee_id = " +
employee_id)
result = cursor.fetchone()
22 | P a g e
 if result:
# Confirm before deletion
confirmation = input(f"Are you sure you want to delete
{result[0]} (Employee ID: {employee_id})? (yes/no): ").lower()
if confirmation == 'yes':
cursor.execute("DELETE FROM Staff WHERE employee_id
= " + employee_id)
print(f"Employee {result[0]} with Employee ID
{employee_id} has been deleted.")
connection.commit()
else:
print("Deletion cancelled.")
else:
print(f"No employee found with Employee ID:
{employee_id}.")

print("Staff table updated successfully.\n")

4th file: Waiter.py

def waiter_module(cursor, connection):

def display_announcement(cursor):
cursor.execute("SELECT message, priority, created_at
FROM Announcements ORDER BY created_at DESC LIMIT 1")
result = cursor.fetchone()

if result:
message = result[0]
priority = result[1]
created_at = result[2]
print("\n--- Announcement ---")
print("Priority: " + str(priority))
print("Date: " + created_at.strftime('%Y-%m-%d %H:
%M:%S'))
print("Message: " + message + "\n")
else:
print("\nNo announcements at this time.\n")

23 | P a g e
 display_announcement(cursor)

while True:
print("\n--- Waiter Module ---")
print("1. Place a new order")
print("2. Check order status")
print("3. Register a complaint")
print("4. Add Request")
print("5. Exit")

try:
choice = int(input("Enter your choice: "))
except ValueError:
print("Invalid input. Please enter a number.")
continue

if choice == 1:
# Place a new order
cursor.execute("SELECT * FROM Menu")
menu = cursor.fetchall()

if not menu:
print("No items in the menu.")
return

print("Menu:")
for item in menu:
print(str(item[0]) + ": @" + str(item[1]))

# Take order
order = input("Enter food items ordered (comma
separated): ").strip()

if not order:
print("No order was placed.")
return

# Insert the order into the Orders table with

'Pending' status

24 | P a g e
 cursor.execute("INSERT INTO Orders (items, status)
VALUES ('" + order + "', 'Pending')")
connection.commit()
print("Order has been placed and is pending for
cook's approval.")

# Call generate_bill to print the bill

def generate_bill(order, cursor, issued_by,
connection):
restaurant_name = "ARCHYAN'S RESTAURANT"

# Calculate the total bill and store item

details
total = 0
ordered_items = []

# Split the order items entered by the

waiter
items_ordered = order.split(',')

for item in items_ordered:

item = item.strip()
cursor.execute("SELECT price FROM Menu
WHERE food_item='" + item + "'")
result = cursor.fetchone()

if result:
price = result[0]
ordered_items.append((item, price))
# Store item and its price as a tuple
total += price
else:
print(item + " is not available on
the menu.")

# Print bill
print("\n" + "="*30)
print(restaurant_name)
print("-" * 30)
print("Items Ordered:")

25 | P a g e
 for item, price in ordered_items:
print(item + ": @" + str(price))

print("-" * 30)
print("Total: @" + str(total))
print("Issued by: " + issued_by)
print("="*30 + "\n")

connection.commit()

# Return the total

return total

generate_bill(order, cursor, issued_by="Waiter",

connection=connection)

elif choice == 2:
def check_order_status(cursor):
print("\n--- Check Order Status ---")

# Fetch all orders from the Orders table

cursor.execute("SELECT id, items, status,
time_required, reason FROM Orders")
orders = cursor.fetchall()

# Check if there are any orders

if orders:
for order in orders:
order_id = order[0]
items = order[1]
status = order[2]
time_required = order[3]
reason = order[4]

print("\nOrder ID: " + str(order_id))

print("Items: " + items)
print("Status: " + status)

if status == 'Accepted':
26 | P a g e
 print("Time required: " +
str(time_required) + " minutes")
elif status == 'Rejected':
print("Reason for rejection: " +
reason)
else:
# No orders found
print("No orders found.")

check_order_status(cursor)

elif choice == 3:
import datetime

def add_complaint(cursor, connection):

waiter_name = input("Enter your name: ")
complaint = input("Enter the customer's
complaint: ")
current_date = datetime.date.today()

try:

query = f"INSERT INTO Complaints

(waiter_name, complaint, date_submitted) VALUES
('{waiter_name}', '{complaint}', '{current_date}')"

cursor.execute(query)
connection.commit()
print("Complaint submitted successfully.")
except Exception as e:
print(f"Error submitting complaint: {e}")

add_complaint(cursor, connection)

elif choice == 4:
def add_request(cursor, connection):
print("\n--- Add Request ---")

# Take staff name as input from the user

staff_name = input("Enter your name: ")
27 | P a g e
 request = input("Enter your request: ")
date_submitted = "CURRENT_DATE"

query = "INSERT INTO Requests (staff_name,

request, date_submitted) VALUES ('" + staff_name + "', '" +
request + "', " + date_submitted + ")"

try:
cursor.execute(query)
connection.commit()
print("Request added successfully.\n")
except Exception as e:
print(f"An error occurred: {e}")

add_request(cursor, connection)

elif choice == 5:
print("Exiting")
break

else:
print("Invalid choice. Please try again.")

5th file: Cook.py

def cook_module(cursor, connection):

def display_announcement(cursor):
cursor.execute("SELECT message, priority, created_at
FROM Announcements ORDER BY created_at DESC LIMIT 1")
result = cursor.fetchone()

if result:
message = result[0]
priority = result[1]
created_at = result[2]
print("\n--- Announcement ---")
print("Priority: " + str(priority))

28 | P a g e
 print("Date: " + created_at.strftime('%Y-%m-%d %H:
%M:%S'))
print("Message: " + message + "\n")
else:
print("\nNo announcements at this time.\n")

display_announcement(cursor)
while True:

print("\n--- Cook Module ---")

print("1. View Pending Orders")
print("2. Accept/Reject Order")
print("3. Mark Order as Completed")
print("4. Add Request")
print("5. Exit") # Adding option to exit

try:
choice = int(input("Enter your choice (1, 2, 3, 4 or
5): "))

if choice not in [i for i in range(1,6)]:

raise ValueError

except ValueError:
print("Invalid input. Please enter a number (1, 2,
3, 4 or 5).")
continue

if choice == 1:
# View all pending orders
try:
cursor.execute("SELECT id, items, status FROM
Orders WHERE status='Pending'")
pending_orders = cursor.fetchall()

if not pending_orders:
print("*******************************
No pending orders. *******************************")
else:
print("Pending Orders:")
for order in pending_orders:
29 | P a g e
 print("Order ID: " + str(order[0]) + ",
Items: " + order[1] + ", Status: " + order[2])
except Exception as e:
print("Error fetching pending orders: " +
str(e))

elif choice == 2:
# Accept or reject an order
try:
cursor.execute("SELECT id, items FROM Orders
WHERE status='Pending'")
orders = cursor.fetchall()

if not orders:
print("No pending orders.")
continue

print("Pending Orders:")
for order in orders:
print("Order ID: " + str(order[0]) + ",
Items: " + order[1])

order_id = int(input("Enter the Order ID to

process: "))

cursor.execute("SELECT items FROM Orders WHERE

id=" + str(order_id) + " AND status='Pending'")
order = cursor.fetchone()

if not order:
print("Invalid Order ID or order is not
pending.")
continue

decision = input("Do you want to accept or

reject the order? (accept/reject): ").strip().lower()

if decision == 'accept':
try:
time_required = int(input("Enter time
required (in minutes) to prepare the order: "))
30 | P a g e
 cursor.execute("UPDATE Orders SET
status='Accepted', time_required=" + str(time_required) + "
WHERE id=" + str(order_id))
connection.commit()
print("Order " + str(order_id) + "
accepted. Time required: " + str(time_required) + " minutes.")
except ValueError:
print("Invalid input for time required.
Please enter a number.")
elif decision == 'reject':
reason = input("Enter the reason for
rejecting the order: ")
cursor.execute("UPDATE Orders SET
status='Rejected', reason='" + reason + "' WHERE id=" +
str(order_id))
connection.commit()
print("Order " + str(order_id) + " rejected.
Reason: " + reason)
else:
print("Invalid choice. Please enter 'accept'
or 'reject'.")
except Exception as e:
print("Error processing order: " + str(e))

elif choice == 3:
# Mark an order as completed
try:
cursor.execute("SELECT id, items, status FROM
Orders WHERE status='Accepted'")
accepted_orders = cursor.fetchall()

if not accepted_orders:
print("No accepted orders to mark as
completed.")
else:
print("Accepted Orders:")
for order in accepted_orders:
print("Order ID: " + str(order[0]) + ",
Items: " + order[1] + ", Status: " + order[2])

31 | P a g e
 order_id = int(input("Enter the Order ID to
mark as completed: "))

cursor.execute("UPDATE Orders SET

status='Completed' WHERE id=" + str(order_id) + " AND
status='Accepted'")
connection.commit()
print("Order " + str(order_id) + " has been
marked as completed.")
except Exception as e:
print("Error marking order as completed: " +
str(e))

elif choice == 4:
def add_request(cursor, connection):
print("\n--- Add Request ---")

# Take staff name as input from the user

staff_name = input("Enter your name: ")

request = input("Enter your request: ")

date_submitted = "CURRENT_DATE"

query = "INSERT INTO Requests (staff_name,

request, date_submitted) VALUES ('" + staff_name + "', '" +
request + "', " + date_submitted + ")"

try:
cursor.execute(query)
connection.commit()
print("Request added successfully.\n")
except Exception as e:
print(f"An error occurred: {e}")

add_request(cursor, connection)

elif choice == 5:
print("Exiting Cook Module.")
break

32 | P a g e
 else:
print("Invalid choice. Please try again.")

6th file: storekeeper.py

import mysql
from prettytable import PrettyTable
from datetime import datetime

def storekeeper_module(cursor, connection):

def display_announcement(cursor):
cursor.execute("SELECT message, priority, created_at
FROM Announcements ORDER BY created_at DESC LIMIT 1")
result = cursor.fetchone()

if result:
message = result[0]
priority = result[1]
created_at = result[2]
print("\n--- Announcement ---")
print("Priority: " + str(priority))
print("Date: " + created_at.strftime('%Y-%m-%d %H:
%M:%S'))
print("Message: " + message + "\n")
else:
print("\nNo announcements at this time.\n")

display_announcement(cursor)
while True:

print("\n--- Storekeeper Module ---")

# Prompt user to choose action: Update quantity or add a

new item
print("1. Update existing item quantity")
print("2. Add a new item")
print("3. Add Request")
print("4. Delete item from store") # Corrected option
number for exit

33 | P a g e
 print("5. View Items") # Corrected option number for
exit
print("6. Exit") # Corrected option number for exit
choice = input("Enter your choice: ")

if choice == '1':
# Update the quantity of an existing item
item = input("Enter item name to update: ")

cursor.execute("SELECT * FROM Store WHERE item='" +

item + "'")
result = cursor.fetchone()

if result:
while True:
try:
quantity = int(input("Enter new
quantity: "))
break
except ValueError:
print("Invalid input for quantity.
Please enter an integer.")

try:
cursor.execute("UPDATE Store SET quantity="
+ str(quantity) + " WHERE item='" + item + "'")
connection.commit()
print("Quantity of " + item + " updated to "
+ str(quantity) + ".")
except Exception as e:
print("Error updating item: " + str(e))
else:
print("Item '" + item + "' does not exist in the
store.")

elif choice == '2':

# Add a new item to the store
item = input("Enter new item name: ")

while True:
try:
34 | P a g e
 quantity = int(input("Enter quantity: "))
break
except ValueError:
print("Invalid input for quantity. Please
enter an integer.")

# Validate date format for MFG/Date of purchase

while True:
date_input = input("Enter MFG/Date of Purchase
(YYYY-MM-DD): ")
try:
date_of_purchase =
datetime.strptime(date_input, '%Y-%m-%d').date()
break
except ValueError:
print("Invalid date format. Please enter
date in YYYY-MM-DD format.")

try:
cursor.execute("INSERT INTO Store (item,
quantity, `MFG/Date_of_purchase`) VALUES ('" + item + "', " +
str(quantity) + ", '" + str(date_of_purchase) + "')")
connection.commit()
print("New item '" + item + "' added to the
store with quantity " + str(quantity) + " and date " +
str(date_of_purchase) + ".")
except Exception as e:
print("Error adding new item: " + str(e))

elif choice == '3':

def add_request(cursor, connection):
print("\n--- Add Request ---")

# Take staff name as input from the user

staff_name = input("Enter your name: ")

request = input("Enter your request: ")

date_submitted = "CURRENT_DATE"

35 | P a g e
 query = "INSERT INTO Requests (staff_name,
request, date_submitted) VALUES ('" + staff_name + "', '" +
request + "', " + date_submitted + ")"

try:
cursor.execute(query)
connection.commit()
print("Request added successfully.\n")
except Exception as e:
print(f"An error occurred: {e}")

add_request(cursor, connection)

elif choice == '4':

try:
item_name = input("Enter Name of Item to Delete:
")
query = "DELETE FROM store WHERE item = '" +
item_name + "'"
cursor.execute(query)
connection.commit()
if cursor.rowcount > 0:
print("Item '" + item_name + "' deleted
successfully!")
else:
print("Item '" + item_name + "' not found!")

except mysql.connector.Error as error:

print("Failed to delete item from store:
{}".format(error))

elif choice == '5':

try:
query = "SELECT * FROM store"
cursor.execute(query)

items = cursor.fetchall()

# Create Table
36 | P a g e
 table = PrettyTable()
table.field_names = ["Item", "Quantity",
"MFG/Date_of_purchase"]

# Add rows to the table

if items:
for row in items:
table.add_row([row[0], row[1], row[2]])
print(table)
else:
print("No items found in the store.")

except mysql.connector.Error as error:

print("Failed to retrieve store items:
{}".format(error))

elif choice == '6':

print("Exiting.......")
break
else:
print("Invalid choice. Please select either 1 or
2.")

37 | P a g e
 MySQL DATABASE AND TABLES

38 | P a g e
39 | P a g e
 Execution of Program
STEP 1:
This program is divided into several files. All the files will be executed through the file "main.py". Before that, the file
"create Database and tables.py" must be executed in order to create the database in MySQL. If the database is
already created, no need to run this file again.

STEP 2:
Requirements to run this program:

1. Python must be installed

2. MySQL must be installed

3. Few other Python libraries need to be installed, run all the commands in the command prompt as an
administrator:
(i) MySQL connector:
Run this command:
pip install mysql.connector
(ii) prettytable:
pip install prettytable

STEP 3:
First run the "create Database and tables.py" file to create a database in MySQL and create all the required tables. If
the database is already created, no need to run this file again. This file includes a user-defined function
"create_database_and_tables ()" which first creates the database, then uses it to create multiple tables as per the
requirements.

Tables included:

announcements
complaints
menu
orders
requests
staff
store

STEP 4:
To run the main program, the user needs to run the main file ("main.py").

40 | P a g e
STEP 5:
After running program, it takes you to login page where you have to login as "Admin" and default password will be
"123". After login you have to setup staff details for Cook, Waiter, Storekeeper. Make sure you enter
position first letter capital and rest as lower case. Only assign one person per position and while login
you should keep upper and lower case same as said earlier.

Precautions:
1.Make sure whenever you run Database file or try to connect to
database, you include this
auth_plugin='mysql_native_password' Otherwise it will
raise an error while executing.
It should look like this:
mysql. connector. Connect (host="localhost",
user="root",password="octane", database="ArchyansRestaurant",
auth_plugin='mysql_native_password')

2. Make sure all files are in same folder.

3. Make sure to change database name and password as

per your MySQL Database.

OUTPUT
---Login Interface---

41 | P a g e
--- Admin Module ---

42 | P a g e
---Waiter---

---Cook---

---Storekeeper---

Prettytable library to present output

in tabular format

43 | P a g e
 CONCLUSION
The project efficiently leverages Python and MySQL, creating a
powerful, user-friendly restaurant management system that
simplifies day-to-day operations. By employing Python's
versatility, the project uses multiple user-defined functions,
which modularize tasks such as adding, updating, and viewing
menu items, orders, staff details, and inventory, making the
code organized and easily maintainable. This structure not only
enhances readability but also promotes code reusability,
allowing each function to perform specific tasks without
redundancy.

MySQL's role in the project ensures efficient data handling,

storage, and retrieval, creating a centralized database that
keeps data well-organized and secure. User-defined SQL
commands and functions facilitate the creation of structured
tables—such as staff, orders, menu, and inventory—that
integrate seamlessly with the Python modules. The use of
MySQL connectors in Python ensures smooth database
communication, which, combined with Python's error-handling
capabilities, results in a system that is both reliable and
responsive. Together, Python and MySQL offer a scalable and
efficient backend for managing restaurant operations,
showcasing a robust design that could be effectively
implemented in real-world settings.

44 | P a g e
 Bibliography

 WEBSITE REFRENCES:
https://python4csip.com/
https://kvcoders.in/class-12-new-content/python-
project/
https://www.geeksforgeeks.org
https://www.w3schools.com/
https://stackoverflow.com/
 Book References:
Computer science with python – Sumit Arora

45 | P a g e
 THANK YOU

46 | P a g e