BAKERY MANAGEMENT

SYSTEM
 GT ALOHA VIDHYA MANDIR
Neelankarai, Chennai – 600 115

CLASS - XII

CBSE

COMPUTER SCIENCE PROJECT

2024 – 2025

NAME : ……………………………………………………………….

REG NO. :

……………………………………………………………….
 BONAFIDE CERTIFICATE

Certified that this is a bonafide project work

done by…………………………….……………. Reg.No………………………of Class XII,

GT ALOHA VIDHYA MANDIR, NEELANKARAI, CHENNAI - 600 115, during

the year 2024 – 2025.

Principal Teacher – In – charge

Submitted for SSCE Practical Examination held on.................................in

COMPUTER SCIENCE LABORATORY at GT ALOHA VIDHYA MANDIR,

CHENNAI – 600 115.

INTERNAL EXAMINER EXTERNAL EXAMINER

SCHOOL SEAL
 ACKNOWLEDGEMENT

I,...................................................of Std XII, express my gratitude to our

Principal, Dr.J.Sundar for his continuous support and encouragement.

I express my sincere thanks to my COMPUTER SCIENCE TEACHER,

Ms.N.Poonguzhali and Laboratory Teacher, Ms.Simi for helping me to

complete this project successfully.

Date:

Place: Chennai
 INDEX
TOPIC PG NO

SYNOPSIS 5

SOFTWARE USED 8

MODULUS USED 10

ALGORITHM 11

SOURCE CODE 13

OUTPUT 16

BIBLIOGRAPHY 19
 SYNOPSIS

INTRODUCTION

Introduction to Bakery Management System

Welcome to the Bakery Management System, an innovative solution designed to streamline

and enhance the operations of modern bakeries. In today’s fastpaced world, managing a
bakery efficiently requires more than just culinary expertise; it demands a robust system
that can handle various aspects of the business seamlessly. Our Bakery Management
System is developed to address this need by integrating all essential functions into a single,
userfriendly platform.

Key Features:

Inventory Management: Keep track of ingredients and supplies, monitor stock levels, and
receive notifications for low inventory to ensure you never run out of essential items.

Order Management: Simplify the process of taking and managing orders, whether they
come from walkin customers, phone calls, or online platforms. Our system ensures accurate
order processing and timely deliveries.

Sales and Reporting: Gain valuable insights into your bakery’s performance with detailed
sales reports and analytics. Understand customer preferences, peak sales times, and
product popularity to make informed business decisions.

Customer Management: Maintain a database of your customers, including their contact

details, order history, and preferences. Use this information to provide personalized service
and build longterm relationships.

Employee Management: Manage staff schedules, track working hours, and handle payroll
efficiently. Ensure your team is wellorganized and motivated to deliver the best service.

Recipe and Production Management: Store and manage your recipes, calculate production
costs, and plan production schedules to optimize resource usage and minimize waste.
Benefits:

Efficiency: Automate routine tasks, reduce manual errors, and free up time for your staff to
focus on creating delicious products.

Customer Satisfaction: Provide a seamless and enjoyable experience for your customers
with accurate orders and timely deliveries.

Cost Savings: Optimize inventory and production processes to reduce waste and control
costs.

Growth: Use datadriven insights to identify opportunities for growth and expansion.

Our Bakery Management System is designed with the specific needs of bakeries in mind,
ensuring that you have all the tools necessary to manage your business effectively. Whether
you are a small local bakery or a large chain, our system can be tailored to meet your
unique requirements.

Start your journey towards a more efficient and successful bakery today with our
comprehensive Bakery Management System.

OBJECTIVE OF THIS PROJECT

The objective of this project is to let the students apply their programming knowledge to a
real world situation/problem and expose the students to how programming skills help in
developing good software.
1. Write programs utilizing modern software tools

2. Write effective procedural code to solve small to medium size projects.

3. Students will demonstrate the ability to conduct a research or applied Computer
Science project, requiring writing and presentation skills that exemplify scholarly style
computer science.
The Bakery Management Python Program is an intricate and comprehensive software

solution designed to streamline the operations of a bakery, enhancing both efficiency and

productivity. This program meticulously integrates various aspects of bakery management,

ranging from inventory control and order processing to sales tracking and customer

management. At its core, the software employs a robust database system to maintain

realtime records of ingredients, baked goods, and supplies, ensuring that stock levels are

optimally managed to prevent both overstocking and shortages. The order processing

module is highly intuitive, allowing for seamless order entry, modification, and tracking,

whether for instore purchases or online orders. To facilitate smooth financial operations,

the program includes a sales tracking feature that generates detailed reports on daily,

weekly, and monthly sales, providing bakery owners with valuable insights into their

revenue streams and popular products. Additionally, the customer management system

enhances the customer experience by maintaining a database of customer preferences,

order histories, and loyalty rewards, thus enabling personalized service and targeted

marketing. The software is designed with a userfriendly interface, ensuring that even staff

with minimal technical expertise can navigate and utilize its full capabilities with ease.

Furthermore, the Bakery Management Python Program incorporates advanced analytics

and reporting tools, empowering bakery owners with datadriven decisionmaking

capabilities to optimize their operations, forecast demand, and identify growth

opportunities. With its comprehensive suite of features, this program is an indispensable

tool for modern bakeries aiming to achieve operational excellence and deliver exceptional

service to their customers.

 SOFTWARE USED

Python IDLE (Integrated Development and Learning Environment) is a vital tool designed for

beginners and experienced developers alike, facilitating the process of writing, debugging,

and executing Python code. As the default IDE that comes bundled with Python, IDLE

provides an accessible entry point into programming with Python, making it an ideal choice

for educational environments and self-learners. The interface is straightforward and user-

friendly, featuring a multiwindow text editor with syntax highlighting, autocompletion, and

smart indenting, which collectively streamline the coding process. One of its core features is

the interactive Python shell, where users can execute code snippets and immediately see

the results, making it an excellent platform for experimenting with code and learning

through immediate feedback. In addition to these features, IDLE includes an integrated

debugger with stepping, persistent breakpoints, and call stack visibility, which aids

developers in identifying and fixing errors efficiently. This debugging tool is particularly

useful for newcomers who are learning how to trace through code execution and

understand the flow of a program.

IDLE also supports dynamic introspection, allowing users to explore modules and their

contents interactively. Despite its simplicity, IDLE is equipped with various customization

options, enabling users to tweak the environment to better suit their preferences, such as

changing fonts, colors, and window layouts. While IDLE is designed with simplicity and ease

of use in mind, making it perfect for small-scale projects and learning, it might not offer all

the advanced features required for large-scale software development projects. For such

purposes, developers often migrate to more sophisticated Integrated Development

Environments (IDEs) like PyCharm, Visual Studio Code, or Eclipse. However, IDLE remains an
essential tool in the Python ecosystem, providing a solid foundation for beginners and

serving as a reliable, lightweight option for quick scripting and testing tasks. Its role in the

educational sector is particularly noteworthy, as it helps demystify programming concepts

and promotes a hands-on approach to learning Python.

 MODULES USED

Customer Details: Storing all customer details, including name, address, contact
information, and order history.
Order Details: Used to store all types of order details, including order date, order status,
and order Total.
Product Details: Used to store all main product items, such as cakes, pastries, and bread.
Stock Details:Used to store all items details that are needed to make main product items,
such as ingredients and supplies.
Inventory Management: Used to manage the inventory of products and ingredients,
including tracking stock levels and reordering supplies.
Admin Login: Allows administrators log in and manage
Customer Login: Allows customers to log in and view their order history and account
information.
Payment Processing: Handles payment processing and transaction management.
Reporting: Generates reports on sales, inventory, and customer data.
Notification: Sends notifications to customers and administrators about order status and
promotions.
 ALGORITHM

In the bustling world of bakeries, managing operations efficiently is key to success. From
inventory tracking to customer orders and employee management, the intricacies of bakery
management require a robust system. Implementing an algorithmic approach using Python
and SQL can streamline processes, enhance productivity, and ensure seamless operations.
Let's delve into the algorithmic framework for a bakery management system.

1. Database Design: The foundation of any effective bakery management system lies in a
well structured database. Utilizing SQL, we can design tables to store crucial information
such as inventory details, customer orders, employee data, and sales records. Each table
should be normalized to minimize redundancy and ensure data integrity.

2. Inventory Management: One of the core functionalities of the system is inventory

management. The algorithm should include modules for tracking ingredient stock levels,
recording purchases, and updating inventory in real time. Using Python, we can develop
scripts to automate inventory updates based on factors like ingredient usage in recipes and
expiration dates.

3. Order Processing: Efficient order processing is essential to meet customer demands

promptly. The algorithm should incorporate features for capturing and processing customer
orders systematically. This includes functionalities like order placement, order status
tracking, and generating invoices. SQL queries can be utilized to retrieve order information
from the database, while Python can handle order processing logic.

4. Employee Scheduling: Managing staff schedules effectively ensures smooth operations

and optimal utilization of resources. The algorithm should include modules for creating
employee schedules, assigning shifts, and tracking attendance. Python can be used to
generate schedules based on factors like employee availability and workload, while SQL can
store and retrieve employee data for scheduling purposes.
5. Reporting and Analytics: Monitoring bakery performance through comprehensive
reporting and analytics is crucial for making informed business decisions. The algorithm
should include components for generating various reports such as sales reports, inventory
analysis, and financial statements. Python can be employed to process and analyze data,
while SQL can handle querying the database for relevant information.6. Customer
Relationship Management (CRM): Building and maintaining strong relationships with
customers is vital for business growth. The algorithm should incorporate CRM
functionalities such as capturing customer information, managing loyalty programs, and
tracking customer feedback. Python can be utilized to develop CRM modules, while SQL can
handle storing and retrieving customer data.

7. Integration and Scalability: To ensure flexibility and scalability, the algorithm should be
designed to integrate seamlessly with other systems and accommodate future growth.
Using Python's
modular approach and SQL's relational database capabilities, the system can be easily
expanded and

adapted to meet evolving business needs.

8. Security and Data Integrity: Protecting sensitive data and ensuring data integrity are

paramount in any management system. The algorithm should incorporate robust security
measures such as encryption, authentication, and access control. SQL provides features for
implementing security protocols, while Python can handle authentication and encryption
logic.
 SOURCE CODE

Import mysql.connector
from mysql. connector import error code

def connect_to_db():
""" Establishes a connection to the MySQL database."""
Try:
Cnx = mysql. connector.connect(user='root', password='gtavm@A3', host='localhost',
database='project')
return cnx
except for mysql.connector.Error as err:
if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
print("Something is wrong with your user name or password")
elif err.errno == errorcode.ER_BAD_DB_ERROR:
print("Database does not exist")
Else:
print(err)
return None

def fetch_all_items(cursor):
"""Fetches and prints all items from the schoolbakery table."""
cursor.execute("SELECT FROM schoolbakery")
for (itemno, item, pieces, price, type) in cursor:
print(f"Item Number: {itemno}, Item: {item}, Pieces: {pieces}, Price: ${price}, Type:
{type}")

def update_pieces(cursor, cnx, item, pieces, action):

"""Updates the number of pieces for a given item based on the specified action (add or
delete)."""
try:
if action == "add":
cursor.execute("UPDATE schoolbakery SET pieces = pieces + %s WHERE item = %s",
(pieces, item))
elif action == "delete":
cursor.execute("UPDATE schoolbakery SET pieces = pieces %s WHERE item = %s",
(pieces, item))
cnx.commit()
print("Pieces updated successfully!")
except mysql.connector.Error as err:
print(f"Error: {err}")

def add_or_delete_pieces(cursor, cnx):

"""Manages user input for adding or deleting pieces and calls update_pieces."""
while True:
action = input("Do you want to add or delete pieces? (add/delete): ").strip().lower()
if action not in ["add", "delete"]:
print("Invalid action, please enter 'add' or 'delete'.")
continue
 item = input("Enter the item name: ").strip()
pieces = int(input("Enter the number of pieces: "))

update_pieces(cursor, cnx, item, pieces, action)

choice = input("Do you want to continue? (yes/no): ").strip().lower()

if choice != "yes":
break

def calculate_total_cost(cursor, cart_items):

"""Calculates the total cost of the items in the cart."""
total_cost = 0
for item, pieces in cart_items:
cursor.execute("SELECT price FROM schoolbakery WHERE item = %s", (item,))
price = cursor.fetchone()[0]
total_cost += pieces price
return total_cost

def add_items_to_cart(cursor):
"""Manages the addition of items to a shopping cart, calculates the total cost, and applies
discounts if applicable."""
cart_items = []

while True:
item = input("Enter the item name: ").strip()
pieces = int(input("Enter the number of pieces: "))

cart_items.append((item, pieces))

action = input("Do you want to add more items? (yes/no): ").strip().lower()

if action == "no":
break

total_cost = calculate_total_cost(cursor, cart_items)

if len(cart_items) > 3:
total_cost = 0.8
print("You have added more than 3 items, so you get a 20% discount.")

print("Items in the cart:")

for item, pieces in cart_items:
cursor.execute("SELECT price FROM schoolbakery WHERE item = %s", (item,))
price = cursor.fetchone()[0]
print(f"{pieces} pieces of {item} at ${price:.2f} each")
print(f"Total price: ${total_cost:.2f}")

def identify_dessert_type(cursor):
"""Identifies and prints the type of a given dessert item from the database."""
while True:
 item = input("Enter the item name: ").strip()
cursor.execute("SELECT type FROM schoolbakery WHERE item = %s", (item,))
item_type = cursor.fetchone()
if item_type:
print(f"The type of {item} is {item_type[0]}")
else:
print(f"Item not found in the database")

choice = input("Do you want to select more items? (yes/no): ").strip().lower()

if choice != "yes":
break

def display_menu():
"""Displays the menu to the user."""
print("\nMenu:")
print("1. Display all items")
print("2. Add or delete pieces")
print("3. Add items to cart and calculate total price")
print("4. Identify dessert type")
print("5. Exit")

def main():
"""Main function that coordinates the above functions, handles the database cursor, and
ensures the connection is properly closed."""
cnx = connect_to_db()
if cnx is None:
return

cursor = cnx.cursor()

while True:
display_menu()
choice = input("Enter your choice: ").strip()

if choice == "1":
fetch_all_items(cursor)
elif choice == "2":
add_or_delete_pieces(cursor, cnx)
elif choice == "3":
add_items_to_cart(cursor)
elif choice == "4":
identify_dessert_type(cursor)
elif choice == "5":
break
else:
print("Invalid choice. Please try again.")

cursor.close()
cnx.close()

if __name__ == "__main__":
main()
OUTPUT
 BIBLIOGRAPHY

1. Computer science python from class XI and XII

2. Chatgpt

3. Online cord error founder