A

PROJECT REPORT
ON
“BAKERY MANAGEMENT SYSTEM”

SUBMITTED BY
AAKIF AHMED KHAN
Seat No: 1624

PROJECT GUIDANCE
PROF. JAWED KHAN

SUBMITTED TO
SAVITRIBAI PHULE PUNE UNIVERSITY

IN PARTIAL FULFILLMENT OF
MASTER OF COMPUTER APPLICATION
2ST YEAR (SEM-IV)

M.C.E SOCIETY’S
ALLANA INSTITUTE OF MANAGEMENT SCIENCES,
PUNE 411001
ACADEMIC YEAR: 2023-2024
 DECLARATION

I certify that the work contained in this report is original and has been done by me under
the guidance of my supervisor(s).

• The work has not been submitted to any other Institute for any degree or
diploma.
• I have followed the guidelines provided by the Institute in preparing the
report.
• I have conformed to the norms and guidelines given in the Ethical Code of
Conduct of the Institute.
• Whenever I have used materials (data, theoretical analysis, figures, and text)
from other sources, I have given due credit to them by citing them in the text
of the report and giving their details in the references.

Sr.No. Seat No. Name of students Signature of students

1 1536 AAKIF AHMED KHAN

 ACKNOWLEDGEMENT

We take this occasion to thank God, almighty for blessing us with his grace
and taking our endeavor to a successful culmination. We extend our sincere
thanks to our esteemed guide, Prof. JAWED KHAN for providing us with
the right guidance and advice at crucial junctures and for showing us the
right way.
We extend our sincere thanks to our respected Mr. Roshan Kazi Sir,
Director in charge of Allana Institute of Management Sciences for providing
all the necessary facilities of library and laboratory and allowing us to use
the facilities available. We would like to thank the other faculty members
also, on this occasion. Last but not least, we would like to thank our friends
for the support and encouragement they have given us during the course of
our work.

Mr. AAKIF AHMED KHAN

 INDEX

CHAPTER NO TOPIC PAGE NO

CHAPTER 1 INTRODUCTION AND SYNOPSIS 1-5
1.1 ABSTRACT 2
1.2 EXISTING SYSTEM AND NEED FOR SYSTEM 3
1.3 SCOPE OF WORK 4
OPERATING ENVIRONMENT- HARDWARE SOFTWARE
1.4 AND LIBRARIES USED 4-5
SOFTWARE REQUIREMENT SPECIFICATION AND
CHAPTER 2 PROPOSED SYSTEM 6-10
2.1 PROPOSED SYSTEM 7
2.2 SRS 8-10
CHAPTER 3 ANALYSIS & DESIGN 11
3.1 CLASS DIAGRAM / OBJECT DIAGRAM 11-15
3.2 USE CASE DIAGRAM 16
3.3 ACTIVITY DIAGRAM 17
3.4 SEQUENCE DIAGRAM 18
3.5 COMPONENT DIAGRAM 19
3.6 DEPLOYMENT DIAGRAM 20-25
CHAPTER 4 IMPLEMENTATION & DATABASE 25
USER INTERFACE DESIGN(SCREEN - INPUT FORMS WITH
4.1 DATA ) 26
4.2 OUTPUT REPORTS WITH DATA 26-36
4.3 DATABASE STRUCTURES - DATA DICTIONARY 37-41
4.4 CODE SNIPPET 42-57
CHAPTER 5 TESTING 58
5.1 TEST STRATEGY 59-61
5.2 UNIT TESTING 62
5.3 ACCEPTANCE TESTING 63
CHAPTER 6 DRAWBACKS AND LIMITATION 64-67
CHAPTER 7 PROPOSED EHANCEMENT 68-71
CHAPTER 8 CONCLUSION 72-74
CHAPTER 1
1.1 Introduction
Project Introduction: Online Cake Bakery System for a Russian Bakery using
Python, Django, and SQLite

Introduction

In the rapidly evolving digital age, the demand for online services is at an all-time
high. Traditional businesses, including bakeries, are increasingly recognizing the
importance of establishing an online presence to stay competitive and meet
customer expectations. This project involves the development of an Online Cake
Bakery System specifically tailored for a renowned Russian bakery, utilizing
Python, Django, and SQLite.

Background

The client, a prominent bakery in Russia, is well-known for its wide variety of
cakes, pastries, and other baked goods. With a strong reputation for quality and
craftsmanship, the bakery seeks to expand its customer reach and enhance
convenience by offering an online platform for ordering cakes. The bakery aims to
provide an intuitive, efficient, and secure online service that aligns with its brand
values and commitment to customer satisfaction.

1
 1.1 ABSTRACT

The online Cake Bakery System provides convenience for the customers. It
overcomes the disadvantages of the traditional queuing system. This system
increases the takeaway of cakes than visitors. Therefore, this system enhances the
speed and standardization of taking the order from the customer. It provides a
better communication platform. the user’s details are noted electronically.

The online Cake Bakery System set up menu online and the customers easily
places the order with a simple mouse click. Also with a cake menu online you can
easily track the orders, maintain customer's database and improve your cake
delivery service. This system allows the user to select the desired cake from the
displayed menu. The user orders the cakes. The payment can be made online or
pay-on-delivery system. The user’s details are maintained confidential because it
maintains a separate account for each user. An id and password is provided for
each user. Therefore it provides a more secured Bakery.

2
1.2 Existing System
In an existing system for giving any orders, users should visit bakery to
learn about cake items and then give order and pay advance. In this
method time and manual work is required. Maintaining critical
information in the files and manuals is full of risk and a tedious process.

1.3 OBJECTIVE
The primary objective of the Online Cake Bakery System is to develop a
comprehensive, user-friendly, and efficient web application tailored specifically
for a Russian bakery. This system will streamline the process of ordering cakes
online, providing customers with a seamless experience while enabling the bakery
to manage orders, inventory, and customer relationships effectively. The system
will be built using Python, Django, and SQLite, ensuring robust functionality,
scalability, and ease of maintenance.

Specific Objectives:

• User-Friendly Interface:
Develop an intuitive and visually appealing user interface that allows customers to
easily navigate, browse different cake options, and place orders.

Provide language support for both Russian and English to cater to a broader
customer base.

• Product Catalog and Customization:

Create a dynamic product catalog that showcases a variety of cakes offered by the
bakery, including detailed descriptions, images, prices, and customization options.

Allow customers to customize their orders (e.g., cake size, flavor, decorations,
personal messages) to suit their preferences.

• Secure User Authentication and Profile Management:

Implement secure user authentication mechanisms, including registration and login
functionalities.

Enable users to manage their profiles, view order history, and track order status.

3
 • Efficient Order Management:
Develop a streamlined order management system that allows customers to add
cakes to their cart, review their orders, and complete the purchase.

Integrate a secure and reliable payment gateway to handle online transactions.

• Admin Dashboard:
Provide an admin dashboard for bakery staff to manage products, monitor
inventory, view customer orders, and update order statuses.

Enable administrators to generate sales reports and customer insights to help in

strategic decision-making.

• Localization and Cultural Relevance:

Incorporate Russian cultural elements and design aesthetics in the website to make
it more appealing to the local market.

Include traditional Russian cake options and popular local flavors to cater to
customer preferences.

• Database Management with SQLite:

Utilize SQLite for database management to ensure lightweight, efficient, and
reliable storage of all necessary data, including user information, product details,
and order records.

4
1.4 HARDWARE AND SOFTWARE
REQUIREMENTS
Hardware Requirement:

• Hardware - Pentium
• Speed - 1.1 GHz
• RAM - 1GB
• Hard Disk - 20 GB
• Key Board - Standard Windows Keyboard
• Mouse - Two or Three Button Mouse

Software Requirements:

Technologies Used

• Backend: Python, Django

• Frontend: HTML, CSS, JavaScript, Bootstrap

• Database: SQLite

• Version Control: Git and GitHub

5
CHAPTER 2

6
2.1Proposed System:
This online application enables the end users to register online, select the cake
from the e-menu card, read the E-menu card, and order the cake online. By just
selecting the cake that the user wants to have. The results after selecting the cake
from the E-menu card will directly appear on the screen of the bakery admin. By
using this application the work of the men’s is reduced and we can also say that the
work is nullified. The benefit of this is that if there is a rush in the bakery then
there will be chances that the waiters will be unavailable and the users can directly
order the cake from the chef online by using this application. The user will be
given a username and a password to log in.

Module Description

1. Product Module: Manages cake listings, details, and customization

options.
2. Cart Module: Manages the user's cart, allowing additions, removals, and
updates.
3. Order Module: Handles order placement, tracking, and history.
4. Admin Module: Provides functionality for managing cakes, orders, and
users.

7
2.2 SRS

1.1 Purpose

The purpose of this document is to outline the software requirements for an Online
Cake Bakery System. This system is intended to provide customers with the ability
to browse, order, and pay for cakes online. The document will provide a detailed
description of the system's functionality, features, and constraints.

1.2 Scope

The Online Cake Bakery System will be a web-based application developed using
Python and Django. The system will allow users to:

Browse available cakes.

Add cakes to a shopping cart.

Place orders and make payments online.

Track the status of their orders.

Manage user profiles and view order history.

1.3 Definitions, Acronyms, and Abbreviations

SRS: Software Requirements Specification

HTTP: Hypertext Transfer Protocol

HTTPS: Secure Hypertext Transfer Protocol

UI: User Interface

CRUD: Create, Read, Update, Delete

8
1.4 References

Django Documentation: https://docs.djangoproject.com/

Python Documentation: https://docs.python.org/

Bootstrap Documentation: https://getbootstrap.com/docs/

2. Overall Description

2.1 Product Perspective

The Online Cake Bakery System is a standalone application designed for

customers to easily order cakes from an online catalog. It will also include
administrative functionality for managing the catalog, orders, and users.

2.2 Product Functions

User Registration and Authentication

Cake Catalog Browsing

Shopping Cart Management

Order Placement and Payment Processing

Order Tracking

Admin Panel for Managing Cakes, Orders

2.3 User Classes and Characteristics

Admin: Individuals responsible for managing the cake catalog, processing orders,
and managing user accounts.

2.4 Operating Environment

Server: Ubuntu 20.04 LTS, Nginx, Gunicorn

Client: Modern web browsers (Chrome, Firefox, Safari)

Database: PostgreSQL

9
2.5 Design and Implementation Constraints

The system must be developed using Django.

The front end should be responsive and user-friendly, implemented using

Bootstrap.

The system should ensure data security and privacy, complying with GDPR.

2.6 Assumptions and Dependencies

Users have internet access and a modern web browser.

Payment processing will be handled via a third-party service like Stripe or PayPal.

3. Specific Requirements

3.1 Functional Requirements

3.1.1 User Registration and Authentication

Admin must be able to register with an email and password.

Admin must be able to log in using their credentials.

Passwords must be stored securely using hashing.

3.1.2 Cake Catalog Browsing

Admin can view a list of cakes with basic information (name, price, thumbnail).

Admin can filter cakes by category, price, and popularity.

3.1.3 Cake Details Viewing

Users can view detailed information about a cake (description, ingredients, price,
reviews).

10
CHAPTER 3

11
INTRODUCTION:
Design is the first step in the development phase for any techniques and principles
for the purpose of defining a device, a process or system in sufficient detail to
permit its physical realization.

Once the software requirements have been analyzed and specified the software
design involves three technical activities - design, coding, implementation and
testing that are required to build and verify the software.

The design activities are of main importance in this phase, because in this activity,
decisions ultimately affecting the success of the software implementation and its
ease of maintenance are made. These decisions have the final bearing upon
reliability and maintainability of the system. Design is the only way to accurately
translate the customer’s requirements into finished software or a system.

Design is the place where quality is fostered in development. Software design is a

process through which requirements are translated into a representation of
software. Software design is conducted in two steps. Preliminary design is
concerned with the transformation of requirements into data.

UML Diagrams:

12
Actor:
A coherent set of roles that users of use cases play when interacting with the use
`cases.

Use case:

A description of the sequence of actions, including variants, that a system performs

that yields an observable result of the value of an actor.

UML stands for Unified Modeling Language. UML is a language for specifying,
visualizing, and documenting the system. This is the step while developing any
product after analysis. The goal of this is to produce a model of the entities
involved in the project which later need to be built. The representation of the
entities that are to be used in the product being developed needs to be designed.

There are various kinds of methods in software design:

They are as follows:

➢ Use case Diagram

➢ Sequence Diagram
➢ Collaboration Diagram
➢ Activity Diagram

13
 ➢ State chat Diagram

USE CASE DIAGRAMS:

Use case diagrams model behavior within a system and help the developers
understand what the user requires. The stick man represents what’s called an actor.

Using case diagram can be useful for getting an overall view of the system and
clarifying who can do and more importantly what they can’t do.

A use case diagram consists of use cases and actors and shows the interaction
between the use case and actors.

• The purpose is to show the interactions between the use case and actor.
• To represent the system requirements from the user’s perspective.
• An actor could be the end-user of the system or an external system.

USE CASE DIAGRAM:

A Use case is a description of the set of sequences of actions. Graphically it is

rendered as an ellipse with a solid line including only its name. A use case
diagram is a behavioral diagram that shows a set of use cases and actors and their
relationship. It is an association between the use cases and actors. An actor
represents a real-world object. Primary Actor – Sender, Secondary Actor
Receiver.

14
3.1 Class Diagram / Object Diagram

15
3.2 Admin

16
3.3 Activity Diagram

17
3.4 Sequence Diagram

18
3.5 Component Diagram

19
3.6 Deployment Diagram

20
3.7 E-R Diagrams
The Entity-Relationship (ER) model was originally proposed by Peter in 1976
[Chen76] as a way to unify the network and relational database views. Simply
stated the ER model is a conceptual data model that views the real world as entities

Manage Enquiry

and relationships. A basic component of the model is the Entity-Relationship

diagram which is used to visually represent data objects. Since Chen wrote his
paper the model has been extended and today it is commonly used for database
design For the database designer, the utility of the ER model is:

• it maps well to the relational model. The constructs used in the ER model
can easily be transformed into relational tables.

• it is simple and easy to understand with a minimum of training. Therefore,

the model can be used by the database designer to communicate the design
to the end user.

• In addition, the model can be used as a design plan by the database

developer to implement a data model in a specific database management
software.

21
Connectivity and Cardinality

The basic types of connectivity for relations are one-to-one, one-to-many, and
many-to-many. A one-to-one (1:1) relationship is when at most one instance of
entity A is associated with one instance of entity B. For example, "employees in
the company are each assigned their own office. For each employee, there exists a
unique office and for each office, there exists a unique employee.

A one-to-many (1:N) relationship is when for one instance of entity A, there are
zero, one, or many instances of entity B, but for one instance of entity B, there is
only one instance of entity A. An example of a 1:N relationship is

a department that has many employees each employee is assigned to one

department

A many-to-many (M: N) relationship, sometimes called non-specific, is when for

one instance of entity A, there are zero, one, or many instances of entity B and for
one instance of entity B there are zero, one, or many instances of entity A. The
connectivity of a relationship describes the mapping of associated

ER Notation

There is no standard for representing data objects in ER diagrams. Each modeling

methodology uses its notation. The original notation used by Chen is widely used
in academic texts and journals but rarely seen in either CASE tools or publications
by non-academics. Today, there are several notations used, among the more
common are Bachman, crow's foot, and IDEFIX.

All notational styles represent entities as rectangular boxes and relationships

as lines connecting boxes. Each style uses a special set of symbols to represent the

22
cardinality of a connection. The notation used in this document is from Martin. The
symbols used for the basic ER constructs are:

▪ Entities are represented by labeled rectangles. The label is the name of the

entity. Entity names should be singular nouns.

▪ Relationships are represented by a solid line connecting two entities. The

name of the relationship is written above the line. Relationship names should

be verbs

▪ Attributes, when included, are listed inside the entity rectangle. Attributes

which are identifiers are underlined. Attribute names should be singular

nouns.

▪ Cardinality of many is represented by a line ending in a crow's foot. If the

crow's foot is omitted, the cardinality is one.

▪ Existence is represented by placing a circle or a perpendicular bar on the

line. Mandatory existence is shown by the bar (looks like a 1) next to the

entity for an instance is required. Optional existence is shown by placing a

circle next to the optional entity

23
24
CHAPTER 4

25
4.1Project Output Screens
Home Page

26
Login Page

Products

27
Add New Product

Add Supplier

28
Add Details Of Supplier

29
Sales

30
Find Customer

Add New Customer

31
Orders Status

Create Order

32
Orders

33
Confirm Order

34
Home Delivery Orders

Invoice

35
Invoice Print

36
4.2Database Design
The data in the system has to be stored and retrieved from the database. Designing

the database is part of system design. Data elements and data structures to be stored

have been identified at the analysis stage. They are structured and put together to

design the data storage and retrieval system.

A database is a collection of interrelated data stored with minimum redundancy to

serve many users quickly and efficiently. The general objective is to make database

access easy, quick, inexpensive, and flexible for the user. Relationships are

established between the data items and unnecessary data items are removed.

Normalization is done to get an internal consistency of data and to have minimum

redundancy and maximum stability. This ensures minimizing data storage required,

minimizing chances of data inconsistencies, and optimizing for updates. The MS

Access database has been chosen for developing the relevant databases.

Cake Bakery System (CBS) contains 10 SQLite tables:

admin: This table stores the admin login details

37
category: This table stores the cake category

contact: This table stores the inquiry details of users.

blood: This table stores the cake details (used for the cake menu)

38
tblfoodtracking: This table stores the cake tracking data.

tblorderaddresses: This table stores the delivery address.

tblorders: This table stores the cake order details.

39
page: This table stores the details of the contact us and About Us page.

tbluser: This table stores the user details.

TBL subscriber: This table stores the subscriber emails.

40
Tables Relationship Diagram

41
4.3 Code Snippet

4.3.1 Admin
from django.contrib import admin

from .models import *

admin.site.register(Customer)
admin.site.register(Product)
admin.site.register(Order)
admin.site.register(HomeDelivery)
admin.site.register(Discount)
admin.site.register(Invoice)
admin.site.register(Bill)
admin.site.register(Supplier)
admin.site.register(OrderList)

4.3.2 Login Page

{% load static %}
<!DOCTYPE html>
<html>

<head>
<title>Login</title>
<link rel="stylesheet"
href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css"
integrity="sha384-
MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdk
nLPMO" crossorigin="anonymous">
<script
src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>

42
<link rel="stylesheet"
href="https://use.fontawesome.com/releases/v5.6.1/css/all.css" integrity="sha384-
gfdkjb5BdAXd+lj+gudLWI+BXq4IuLW5IT+brZEZsLFm++aCMlF1V92rMkPaX
4PP" crossorigin="anonymous">

<style>
body,
html {
margin: 0;
padding: 0;
height: 100%;
}
.user_card {
position: absolute;
width: 557px;
left: 459px;
top: 61px;

background: #3A3A3C;
border-radius: 9px;
display: flex;
justify-content: center;
flex-direction: column;
padding: 10px;
box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2), 0 6px 20px 0 rgba(0, 0, 0, 0.19);
-webkit-box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2), 0 6px 20px 0 rgba(0, 0, 0,
0.19);
-moz-box-shadow: 0 4px 8px 0 rgba(0, 0, 0, 0.2), 0 6px 20px 0 rgba(0, 0, 0, 0.19);
border-radius: 9px;

.form_container {
margin-top: 20px;
}

#form-title{
color: #fff;

43
}

.login_btn {
width: 100%;
background: #33ccff !important;
color: white !important;
}
.login_btn:focus {
box-shadow: none !important;
outline: 0px !important;
}
.login_container {
padding: 0 2rem;
}
.input-group-text {
background: #18A0FB;
color: white !important;
border: 0 !important;
border-radius: 0.25rem 0 0 0.25rem !important;
}
.input_user,
.input_pass:focus {
box-shadow: none !important;
outline: 0px !important;
}

#messages{
background-color: grey;
color: #fff;
padding: 10px;
margin-top: 10px;
}
</style>

</head>
<body>
{% load static %}
<img src="{% static '0.jpg' %}" alt="My image" style="position: absolute;
width:1450px;">
<div class="container h-100">
44
<div class="d-flex justify-content-center h-100">
<div class="user_card">
<div class="d-flex justify-content-center">
<img src="{% static 'logofull2.jpeg' %}" alt="" width="300px">
</div>
<div class="d-flex justify-content-center form_container">
<h3 id="form-title"> LOGIN</h3>
</div>
<div class="d-flex justify-content-center form_container">

<form method="POST" action="">

{% csrf_token %}
<div class="input-group mb-3">
<div class="input-group-append">
<span class="input-group-text"><i class="fas fa-user"></i></span>
</div>
<input type="text" name="username" placeholder="Username..." class="form-
control">
</div>
<div class="input-group mb-2">
<div class="input-group-append">
<span class="input-group-text"><i class="fas fa-key"></i></span>
</div>
<input type="password" name="password" placeholder="Password..."
class="form-control" >
</div>

<div class="d-flex justify-content-center mt-3 login_container">

<input class="btn login_btn" type="submit" value="Login">
</div>
<br>
<div class="justify-content-center">
{% for message in messages %}

<div class="alert alert-success">

<a class="close" href="#" data-dismiss="alert">×</a>

{{ message }}

</div>
45
</div>
</form>

{% endfor %}
</div>
</div>

<div class="mt-4">
<div class="d-flex justify-content-center links">
<i class="far fa-copyright"></i> 2021 | Bake My Day
</div>

</div>
</div>
</div>
</div>
</body>

</html>

46
4.3.3 Model
from django.db import models
from django.db.models.deletion import CASCADE

class Customer(models.Model):
c_phone=models.CharField(max_length=20)
c_fname = models.CharField(max_length=128)
c_lname = models.CharField(max_length=128)
c_address = models.CharField(max_length=256)
created = models.DateField(auto_now_add=True)

def __str__(self):
return self.c_phone

class Item(models.Model):
i_name=models.CharField(max_length=128)

def __str__(self):
return self.i_name

class Product(models.Model):
p_name = models.CharField(max_length=128)
p_price = models.FloatField(default=0)
p_descp = models.CharField(max_length=128,default='NULL')

def __str__(self):
return self.p_name

class ProductItem(models.Model):
UNITCHOICE = (
('g','g'),
('l','litres'),
('#','#'),
)
product = models.ForeignKey(Product,on_delete=CASCADE)
item = models.ForeignKey(Item,on_delete=CASCADE)
unit =models.CharField(max_length=128,choices=UNITCHOICE)
47
 quantity = models.FloatField(default=0)

def __str__(self):
return self.item.i_name

class Order(models.Model):
DELIVERY_CHOICE = (
('pick-up','Pick Up'),
('home-delivery','Home Delivery'),
)
customer = models.ForeignKey(Customer,on_delete=CASCADE)
order_amount=models.FloatField(default=0)
order_date=models.DateField(auto_now_add=True)
delivery_mode=models.CharField(max_length=128, choices=
DELIVERY_CHOICE)
feedback=models.CharField(max_length=128,default='NULL')

def __str__(self):
return self.customer.c_phone

class HomeDelivery(models.Model):
hd_address = models.CharField(max_length=128)
hd_date = models.DateField(auto_now=False, auto_now_add=False)
hd_time = models.TimeField(auto_now=False, auto_now_add=False)
hd_instruction = models.CharField(max_length=128)
order = models.ForeignKey(Order,on_delete=CASCADE)

class OrderList(models.Model):
order = models.ForeignKey(Order,on_delete=CASCADE)
product = models.ForeignKey(Product,on_delete=CASCADE)
ol_unit = models.IntegerField(default=1)
ol_cost = models.FloatField(default=0)
ol_exp_date=models.DateField()
created = models.DateField(auto_now_add=True)

def __str__(self):
return self.product.p_name

class Discount(models.Model):
48
 d_name = models.CharField(max_length=128)
d_percent = models.FloatField(default=0)

def __str__(self):
return self.d_name

class Bill(models.Model):
bill_date=models.DateField(auto_now_add=True)
order = models.ForeignKey(Order,on_delete=CASCADE)
extra_charge=models.FloatField(default=0)
bill_amt=models.FloatField(default=0)
discount = models.ForeignKey(Discount,on_delete=CASCADE)
bill_discount_amount=models.FloatField(default=0)
balance=models.FloatField(default=0)
pay_mode=models.CharField(max_length=128)

class Supplier(models.Model):
s_name=models.CharField(max_length=128)
s_phone=models.CharField(max_length=10)
s_address=models.CharField(max_length=128)

def __str__(self):
return self.s_name

class Invoice(models.Model):
supplier =models.ForeignKey(Supplier,on_delete=CASCADE)
order_date=models.DateField()
receive_date=models.DateField()
invoice_amount=models.FloatField()
invoice_num=models.CharField(max_length=128)
invoice_status = models.CharField(max_length=128,default='pending')

def __str__(self):
return self.supplier.s_name

49
4.3.4 Views
from django import forms
from django.contrib import messages
from django.shortcuts import redirect, render
from django.contrib.auth.decorators import login_required
from .forms import CustomerForm, HomeDeliveryForm,
InvoiceForm,ProductForm,OrderForm,OrderListForm, UpdateProductForm
from .models import Customer, Discount, HomeDelivery, Invoice, Order,Product,OrderList,Bill,
Supplier
from datetime import date
from django.db.models import Count,Sum
from django.views.generic import TemplateView

@login_required(login_url='login')
def add_customer(request,customer_id):
forms = CustomerForm()
customer = Customer.objects.get(id=customer_id)
if request.method == 'POST':
forms = CustomerForm(request.POST)
if forms.is_valid():
c_fname = forms.cleaned_data['c_fname']
c_lname = forms.cleaned_data['c_lname']
c_address = forms.cleaned_data['c_address']

#INSERT INTO bakerystore_customer (id,c_phone,c_fname,c_lname,c_address)

Customer.objects.filter(id=customer_id).update(c_fname=c_fname,
c_lname=c_lname,c_address=c_address)
customer = Customer.objects.get(id=customer_id)

#INSERT INTO bakerystore_order (id,customer.id,order_amount=0)

Order.objects.create(customer=customer,order_amount=0)

#SELECT * from bakerystore_order o,bakerystore_customer c WHERE

o.customer_id=c.id and o.order_amount=0
o=Order.objects.get(customer=customer,order_amount=0)
return redirect('take-order',o.id)

context = {
'form':forms,
'customer':customer
}
return render(request,'add_customer.html',context)

50
@login_required(login_url='login')
def add_product(request):
form1 = ProductForm()
if request.method == 'POST':
form1 = ProductForm(request.POST)
if form1.is_valid():
p_name = form1.cleaned_data['p_name']
p_price = form1.cleaned_data['p_price']
p_descp = form1.cleaned_data['p_descp']

#INSERT INTO bakerystore_product(id,p_name,p_price,p_descp)

Product.objects.create(p_name=p_name,p_price=p_price,p_descp=p_descp)
messages.success(request, 'Product details addedd.')
return redirect('homepage')
else:
messages.error(request, 'Invalid Details Entered.')
return redirect(request.META['HTTP_REFERER'])

context = {
'form1':form1
}
return render(request,'add_product.html',context)

@login_required(login_url='login')
def update_product(request):
p = Product.objects.all()
forms = UpdateProductForm()
if request.method == 'POST':
forms = ProductForm(request.POST)
if forms.is_valid():
#product = forms.cleaned_data['product']
product = request.POST.get('product_id')
req_product = Product.objects.get(id=product)
price = request.POST.get('price')
Product.objects.filter(req_product.id).update(p_price=price)
return redirect('homepage')
context = {
'forms':forms,
'p':p,
}
return render(request,'update_product.html',context)

@login_required(login_url='login')
def find_customer(request):

51
 if request.method=='POST':
number = request.POST.get('number')
if Customer.objects.filter(c_phone=number).exists():
c = Customer.objects.get(c_phone=number)
Order.objects.create(customer=c,order_amount=0)
o=Order.objects.get(customer=c,order_amount=0)
return redirect('take-order',o.id)
else:

new_customer=Customer.objects.create(c_phone=number,c_fname="",c_lname="",c_address="
")
return redirect('add-customer',new_customer.id)

context = {}
return render(request,'find_customer.html',context)

@login_required(login_url='login')
def take_order(request,order_id):

#SELECT * from bakerystore_order WHERE id=order_id;

o = Order.objects.get(id=order_id)

forms = OrderListForm()
if request.method == 'POST':
forms = OrderListForm(request.POST)
if forms.is_valid():
product= forms.cleaned_data['product']
unit = request.POST['ol_unit']
exp_date = request.POST['ol_exp_date']

#SELECT * from bakerystore_product WHERE id=product.id;

p = Product.objects.get(id=product.id)

#INSERT INTO bakerystore_orderlist (product_id,ol_unit,ol_cost,ol_exp_date) values

(product_id,ol_unit,ol_cost,ol_exp_date);

OrderList.objects.create(product=product,ol_unit=unit,order=o,ol_cost=0,ol_exp_date=exp_date
)

#SELECT * from bakerystore_orderlist ol, bakerystore_product p, bakerystore_order o

WHERE product_id=p.id and order_id=o.id;
ol = OrderList.objects.get(product=product,order=o)

#SELECT * from bakerystore_orderlist ol

OrderList.objects.filter(ol_cost=0).update(ol_cost=product.p_price*ol.ol_unit)

52
 ol = OrderList.objects.get(product=product,order=o)
Order.objects.filter(id=o.id).update(order_amount=o.order_amount+ol.ol_cost)
return redirect(request.META['HTTP_REFERER'])
o = Order.objects.get(id=order_id)
ol=OrderList.objects.filter(order=o)
context = {
'forms':forms,
'o':o,
'ol':ol,
}
return render(request,'take_order.html',context)

@login_required(login_url='login')
def delete_item(request,orderlist):
ol=OrderList.objects.get(id=orderlist)
o = Order.objects.get(id=ol.order_id)
Order.objects.filter(id=ol.order_id).update(order_amount=o.order_amount-ol.ol_cost)
OrderList.objects.filter(id=orderlist).delete()
return redirect(request.META['HTTP_REFERER'])

@login_required(login_url='login')
def view_order(request):
today = date.today()
o=Order.objects.all().order_by('-order_date')
#forms = findDate()
if request.method == 'POST':
orderdate=request.POST['orderdate']
o=Order.objects.filter(order_date=orderdate)
context = {
'o':o
}
return redirect(request.META['HTTP_REFERER'],context)
#forms = findDate(request.POST)
#if forms.is_valid():
#orderdate=request.POST['orderdate']
#o = Order.objects.filter(order_date=orderdate)
#return redirect(request.META['HTTP_REFERER'])
context = {
'o':o
}
return render(request,'view_order.html',context)

@login_required(login_url='login')
def view_order_specific(request,orderid):
ol = OrderList.objects.filter(order_id=orderid)
bill = Bill.objects.get(order_id=orderid)

53
 o = Order.objects.get(id=orderid)
context = {
'ol':ol,
'bill':bill,
'o':o
}
return render(request,'view_order_specific.html',context)

@login_required(login_url='login')
def take_home_delivery(request,order_id):
o = Order.objects.get(id=order_id)
forms = HomeDeliveryForm()
if request.method == 'POST':
forms = HomeDeliveryForm(request.POST)
if forms.is_valid():
address= forms.cleaned_data['hd_address']
date = request.POST['hd_date']
time = request.POST['hd_time']
instruction= forms.cleaned_data['hd_instruction']
HomeDelivery.objects.create(order=o,hd_address=
address,hd_date=date,hd_time=time,hd_instruction=instruction)
return redirect('confirm_order',o.id)
context = {
'forms':forms,
'o':o,
}
return render(request,'take_homedelivery.html',context)

@login_required(login_url='login')
def view_home_delivery(request):
h = HomeDelivery.objects.all().order_by('-hd_date')
if request.method == 'POST':
date_given = request.POST.get('date')
if HomeDelivery.objects.filter(hd_date=date_given).exists():
h = HomeDelivery.objects.filter(hd_date=date_given)
context= {
'h':h
}
return redirect(request,'view_homedelivery.html',context)
context = {
'h':h
}
return render(request,'view_homedelivery.html',context)

@login_required(login_url='login')
def comfirm_order(request,order_id):

54
 o = Order.objects.get(id=order_id)
d = Discount.objects.get(id=1)
if request.method == 'POST':
bill=Bill.objects.create(order=o,bill_amt=o.order_amount,discount=d)
extracharge=request.POST['extra_charge']
paymode=request.POST['paymode']
delivery_mode = request.POST['delivery_mode']
feedback =request.POST['feedback']
Order.objects.filter(id=o.id).update(delivery_mode=delivery_mode,feedback=feedback)

Bill.objects.filter(id=bill.id).update(extra_charge=extracharge,bill_amt=bill.bill_amt,pay_mode=
paymode,balance=0)
createdbill=Bill.objects.get(id=bill.id)

Bill.objects.filter(id=createdbill.id).update(bill_amt=createdbill.bill_amt+createdbill.extra_charg
e)
return redirect('printbill',bill.id)
context = {
'o':o
}
return render(request,'confirm_order.html',context)

@login_required(login_url='login')
def printbill(request,bill_id):
bill=Bill.objects.get(id=bill_id)
ol=OrderList.objects.filter(order_id=bill.order_id)
context = {
'bill':bill,
'ol':ol
}
return render(request,'printbillview.html',context)

@login_required(login_url='login')
def add_supplier(request):
if request.method == 'POST':
s_name = request.POST['s_name']
s_phone =request.POST['s_phone']
s_address = request.POST['s_address']
Supplier.objects.create(s_name=s_name,s_phone=s_phone,s_address=s_address)
return redirect('add-supply-order')

return render(request,'add_supplier.html')

@login_required(login_url='login')
def add_supply_order(request):
today = date.today()

55
 forms = InvoiceForm()
if request.method == 'POST':
forms = InvoiceForm(request.POST)
if forms.is_valid():
supplier= forms.cleaned_data['supplier']
order_date=request.POST['order_date']
#receive_date=request.POST['receive_date']
invoice_amount=request.POST['invoice_amount']
invoice_num=request.POST['invoice_num']

Invoice.objects.create(supplier=supplier,order_date=order_date,receive_date=today,invoice_amo
unt=invoice_amount,invoice_num=invoice_num)
return redirect('view-supply-order')

context = {
'forms':forms
}
return render(request,'add_supplyorder.html',context)

@login_required(login_url='login')
def view_supply_order(request):
ip = Invoice.objects.filter(invoice_status='pending').order_by('-order_date')
ir= Invoice.objects.all().order_by('-order_date')

context = {
'ir':ir,
'ip':ip
}
return render(request,'view_supplyorders.html',context)

@login_required(login_url='login')
def update_status(request,invoice_id):
i = Invoice.objects.get(id=invoice_id)
if request.method == 'POST':
r_date = request.POST.get('r_date')
Invoice.objects.filter(id=invoice_id).update(receive_date=r_date,invoice_status='received')
return redirect('view-supply-order')

context = {
'i':i
}

return render(request,'update_supply.html',context)

56
def dashboard_view(request):
today = date.today()
o=Order.objects.filter(order_date=today)
p = Product.objects.all()
pol = OrderList.objects.all().order_by('-ol_cost')[:5]
total_orders=Order.objects.filter(order_date=today).count()
customer = Customer.objects.filter(created=today).count()
total_products=OrderList.objects.filter(order=Order.objects.filter(order_date=today))
ps = OrderList.objects.annotate(number_of_units=Sum('ol_unit'))
olp=(OrderList.objects.values('product_id')).annotate(total=Sum('ol_unit'))[:5]
context = {
'order':total_orders,
'products':total_products,
'olp':olp,
'o':o,
'p':p,
'customer':customer,
'pol':pol,
'ps':ps,
}
return render(request,'dashboard.html',context)

57
CHAPTER 5

58
5.1 SYSTEM TESTING
Project Implementation & Testing

At the end of the system design, it is the beginning of the actual coding to develop
the proposed system. During the development phase, the table structure of the
database will be first built to provide suitable data types that suit the system back
end development, system connection, and data transfer. Next, the computer-side
client program will be developed follow by the web services that allow mobile
phone client programs to communicate with the server and lastly mobile phone
side client program will be developed. In the testing phase, several test cases will
be carried out to test the system to determine the system's reliability and system
accuracy. According to the test cases, a system testing report will be generated for
further review to figure out the system's weaknesses and make improvement
accordingly. In the deployment phase, several training will be provided for the
particular restaurant staff such as how to operate the system, the procedure of
handling different events, and several instructions that need to be followed when
operating the system.

Implementation Issues & Challenges

During the system implementation phase, several challenges need to be confronted

because it involve end users testing the production system in various situations.
The possible challenges that may face are as follows:

User without background

The users are required to have basic knowledge of how to operate a computer
system and Android mobile phone to use the system. This will be difficult to give
training to the user as the basic knowledge information can be obtained from the
internet easily.

The screen size of different device

This would be one of the issues that will be encountered while implementing the
system. Because users can download the mobile application from the official
website and use it as a client device to place orders. Therefore, if the user device
screen size is too small or too big. The content and interface of the application may
not consistence.

59
Server performance

During real-time system implementation, there would be a huge number of clients

that access the server at the same time. Therefore, it may slow down the
connection and performance of the system and even cause the server down if the
issue goes beyond the level of acceptance.

Development Tools

Database Environment

The proposed system will need a database system to support it in order to store a
huge amount of data. SQLite database system will be chosen to support the
proposed system because it is a well-known open-source relational database
management system. Other than that, SQLite database system provides software
developers with a client program with easy easy-to-understand graphical user
interface that can communicate to the SQLite database server named SQLite
Workbench 6.3 CE. By doing so, the software developer can interact with the
database system with the user-friendliness client program and without using the
command prompt, at the end, it may speed up the development progress.

Web Technology

The proposed system is a cross-platform system, which includes a Windows

desktop client and an Android mobile phone client. Therefore, it is required to
implement web services to support the Android mobile phone client device to fetch
data from the database server and store data back to the database server. In this
project, WampServer is used to support the issue mentioned earlier. Django and
SQLite databases. Furthermore, Python will be the programming language that is
used to create the web services that are stored in the server and it can be called by
the Android mobile phone client to perform particular tasks.

System Platform

The project is a cross-platform based system that includes a Windows desktop

client device and an Android mobile phone client device to operate the proposed
system

60
Therefore, the IOS mobile phone client device will not be compatible with the
proposed system.

Project Management Tool

For the rule of thumb to develop a system, it requires to have intact system
planning which serves as a guideline during the development phases. Microsoft
Project is a project management software program and it has been used in the
project to design the system planning, project timeline, managing of resources,
tracking development progress etc.

Visual Paradigm Community Edition

In this project, Visual Paradigm software has been used to create documents for
several system planning diagrams such as Use-Case diagrams, Activity diagrams,
Class diagrams etc. By doing so, software developers can visualize the system and
communicate information much more concisely and clearly.

Test Plan

After the system has been developed, it will move to the system testing phase. In
the system testing phase, the developed system is required to be installed on
appropriate devices for testing purposes. After the system installation has been
completed, the system testing task will be performed by different roles of users
such as manager role and staff role. The purpose of system testing is to identify
and determine the degree of system stability. At the same time, it gives an
opportunity for a developer to figure out errors or bugs that have not been raising
and encountered during the system development phase. That error or bugs that has
been found during the system testing activities will be solved before the system
release. Every testing before the system testing phase is tested by the system
developer itself. Therefore, it might cause some biases toward the testing due to the
system developer having knowledge about the system software logic and lead the
result to be inappropriate. Four types of testing will be used to test the developed
system which include unit testing, integration testing, system testing, and
acceptance testing.

61
5.2 Unit Testing
First of all, unit testing will be the first testing method used to test the developed
system. It consists of testing activities that test the system module by module
which has not been integrated as a whole. By doing unit testing, developers can
identify errors and bug easily since it is finding the error and bugs through a unit
part of the system rather than finding error through the complete system. In
addition, the developer will test the unit part of the system with the validation and
the correctness of data value. Valid and invalid input will be entered to test and
ensure the system processes perform with an expected result.

Functional Testing

After conducting the unit testing, functional testing will begin to test the developed
system. Functional testing is performed to verify that the system application
processes perform and function appropriately according to the design
specifications. In functional testing, the core system application functions will be
tested with several test cases to ensure that the entire system functions as a whole
and performs tasks that with the expected results.

Testing

System testing of the software and hardware is a testing conducted on a system that
is a complete, integrated system that works as a whole. System testing is a critical
testing procedure that must be conducted by a software developer before the
system is released. During system testing, it can evaluate the system’s compliance
with its specified requirements according to the system design. Furthermore,
several testing activities in system testing test not only the design of the system but
also the behavior and the believed expectations from the customer. In addition,
various complex test cases that are used to test the system are according to the
business process requirements which are collected from the user. Meanwhile,
errors or bugs that are detected during the testing require the software developer to
look into them from the initial step of the business process to the end of the process
to ensure it has the expected result to solve the errors or bugs to determine the
degree of system stability.

62
5.3 Acceptance Testing
Last but not least, acceptance testing also known as user acceptance testing would
be the final testing procedure that is performed to test the developed software
system. In acceptance testing, the testing activities are different compared to the
testing activities mentioned previously because the tester who tests the system will
be the final user who does not know the system logic. If the final user encounters
an error while using the system, system developers are required to maintain the
system as soon as possible and release a new patch for the existing system to
recover the error. Meanwhile, the final user will use the system that is visualized to
support their real business routine operation, therefore software support team is
required to stand by to provide technical support while the final user needs any
help or support regarding the system. If there are no errors detected by the final
user while using the system for a long period, the development job of the developer
is considered as complete and the system will be a final system product.

63
CHAPTER 6

64
7.0 Drawbacks and limitations:
1. Database Limitations
Scalability

SQLite: SQLite is not designed for high-concurrency, high-traffic applications. As

the number of users and transactions increases, performance may degrade. It is
suitable for low to medium-traffic websites but may struggle with scalability when
the application grows.

Concurrent Access

Single Write Limitation: SQLite allows only one write operation at a time.
Multiple concurrent write operations will lead to a bottleneck, which can be
problematic for an online ordering system that expects high traffic during peak
times.

2. Performance Issues

Limited Optimization

Query Performance: SQLite has limited optimization capabilities compared to

more robust databases like PostgreSQL or MySQL. Complex queries and large
datasets can lead to slower performance.

Memory Usage

In-Memory Database: While SQLite can be used in-memory for faster access, it
can consume significant RAM, which might not be feasible for large datasets or on
servers with limited resources.

3. Functional Limitations

Advanced Features

Lack of Advanced Features: SQLite lacks some advanced database features such as
stored procedures, native JSON support, and advanced indexing which can limit
the application's functionality and efficiency.

65
Limited User Management

Basic User Authentication: While Django provides built-in user authentication,

more advanced user management features (e.g., multi-factor authentication,
detailed user activity tracking) require additional implementation.

4. Deployment Challenges

Single-File Database

File-Based Storage: SQLite stores data in a single file, which can be a limitation in
distributed environments. Backup and recovery processes might be simpler with
file-based storage but can become cumbersome for larger applications.

Server Resources

Resource Intensive: While Django is efficient, it can be resource-intensive,

requiring adequate server resources (CPU, RAM) to handle multiple users
efficiently.

5. Security Concerns

Limited Security Features

Basic Security: While Django provides good security out of the box, SQLite lacks
advanced security features like encryption at rest, which could be crucial for
sensitive data.

Data Integrity

Data Integrity Issues: In high-concurrency environments, ensuring data integrity

with SQLite can be challenging. Transactions can sometimes lead to database
locks, affecting the user experience.

6. Development and Maintenance

Migration Handling

Database Migrations: While Django provides tools for database migrations,

managing these migrations with SQLite can be less flexible compared to other
databases, especially when dealing with complex schema changes.

66
Testing and Debugging

Debugging Limitations: Debugging performance issues in SQLite can be more

challenging due to the lack of advanced performance monitoring tools that are
available for other databases.

7. Integration Limitations

Third-Party Integrations

Limited Support for Extensions: SQLite has limited support for third-party
extensions and plugins compared to other databases, which might be necessary for
adding specific functionalities or integrations.

67
CHAPTER 7

68
7 SYSTEM EVALUATION AND DISCUSSION

Proposed System Completion

The proposed system is designed and developed to solve all the problem
statements that are stated in chapter one of this report. First of all, the developed
system provides a feature that can solve the problem of difficulties in cake order
ticket tracking and achieve the project objective of preventing cake serves from
being in sequence. By using the system, it allows staff to place order ticket through
using the system and the system will automatically queue the cake order
information according to a first come first serve basis and kitchen staff can follow
the cake queue to serve customers accordingly. It also eliminates all the manual
processes that involve in the traditional method of delivering cake order ticket. In
addition, the developed system allows managers to update all the cake information
as it is needed. This feature helps the restaurant eliminate duplicated physical menu
cards which contains misleading information and also allows staff and customers
to view the latest updated cake menu information through using the system. By
doing so, it helps the restaurant to solve the problem regarding difficulties in
updating menu card information, difficulties in providing appropriate updated cake
information, and the potential of increased cost of operation as the system will
automatically refresh all the updated information that is edited by the manager.
Furthermore, the project objective which provides convenience for both employees
and consumers has been achieved because the system allows consumer to view all
the updated information through mobile phone client devices and it reduces the
number of manual work that restaurant staff need to perform. Last but not least, the
project objective of assisting the restaurant to plan has been achieved due to the
system allow manager to generate several types of report in order to assist the
restaurant to plan ahead. By analyzing the generated report, manager is able to
carry out a planning for the next business routine of the restaurant in order to
improve the restaurant operation efficiency. In a nutshell, the system has fulfilled
all significant outcomes that according to all the problem statements and project
objectives that are stated.

69
System Strength and Limitation

System Strength

The system provide customer with good dine in experience as it allow customer to
view cake information and place order through using the mobile phone device. The
mobile application also provides ease of use because it has easy understandable
graphic user interface and minimal instruction to follow while place order through
the application. Next, it helps restaurant staff to serve their value customer in
minimal delay. Furthermore, the system can be implemented with low cost and is
affordable for most of the small medium enterprise restaurant, because the
hardware requirements are not required to be high end powerful in order to support
the system. Lastly, server and client are communicating within the restaurant
which is intranet therefore it does not need to have internet access.

System Limitation

The system is not compatible with IOS mobile devices as the mobile application is
developed in Android environment. Therefore, for IOS mobile phone user may not
able to install the application in their mobile phone and experience the system.
Meanwhile, the restaurant has prepared some Android mobile devices which are
used to resolve the issue that mention above. Next, due to the mobile phone client
devices are required to connect to the wireless intranet in order to communicate
with the server. It is very important to identify a suitable location that used to
install and set up the wireless access point in order to ensure the wireless signal
coverage is able to reach the entire restaurant area.

Future Enhancement

The system can implement a feature which is real time notification from the mobile
phone application to the service desk. This feature enable customer to request
customer service through using the mobile application rather than verbally call
restaurant staff to approach them. In addition, the mobile application also can
implement a feature that allow customer to update the cake serve status. For
example, customers fine dining at the restaurant they can request the cake to be
serve through using the mobile application and if the customer finish the main
course and feeling full, the customer may request do not serve the following cake
through using the mobile application. Last but not lease, the mobile application

70
may implement some mini game that is able to entertain customers while they are
waiting for the cake to be served.

71
CHAPTER 8

72
8.0 CONCLUSION
After a decade, the advancement and innovation of technology help people to
manage their tasks easily and efficiently. In many other industry area have been
used management system to assist their business grow long time ago, therefore it is
also a trend that cause F&B industry to make use of a management system for their
business. At the end of this project, the system can reduce and replace the human
manpower task, reduce the time consumed for each transaction, and generate
reports for further management purpose by fully utilizing the system.
The proposed system can help improve the productivity of the restaurant and thus
directly did impact the profitability of the restaurant. Furthermore, it can also help
restaurants to reduce the cost of operation in terms of manpower, because the
system has already facilitated a majority of the business process by using the
system. Therefore, it is believed that the system can lead the restaurant’s business
to grow from time to time.
On the other hand, the technology nowadays makes the portability requirement
easy to achieve. Therefore, portability has become one of the factors that have to
be taken into consideration in the system development process. Portability bring a
lot of benefits to users while they using the system such as it provide convenience,
accessibility, easy of communication and etc. Hence, portability has made an
impact to the social that everybody is much more likely to complete their task with
a portable device.
To fulfill these requirements, our proposed method is to combine the cake Bakery
system which is on a mobile platform with the restaurant management system
which is on a computer platform. The integration of both features develop a system
that can let users to have an experience of portability which is user can process
their cake Bakery using their smartphone or tablet. Besides, restaurant manage
their daily operations management through using the computer platform it is
because computers have some other features such as it has a wider screen, other
compatible systems that can help to manage the restaurant, and some other drivers
that need to communicate with that necessary hardware.

73
References
• Django Documentation: https://docs.djangoproject.com/
• SQLite Documentation: https://www.sqlite.org/docs.html
• Bootstrap Documentation: https://getbootstrap.com/docs/
• Python Documentation: https://docs.python.org/3/

74