MONARK UNIVERSITY

FACULTY OF COMPUTER APPLICATION

MASTEER OF COMPUTER APPLICATION

SEMSTER–III

MINOR PROJECT (12130102)

ONLINE TIFFIN SERVICE

Prepared By:
1. Student Name:ANPAT SHAILESH DILIP BHAI Roll No: (23162100010001)

2. Student Name:BARIA PRITESHKUMAR AJAYKUMAR Roll No: (23162100010002)

3. Student Name:RAVAT RAKESHBHAI SUKRAMBHAI Roll No: (23162100010029)

 College Certificate

MONARK UNIVERSITY
FACULTY OF COMPUTER APPLICATION

[OCT/NOV-2024]

This is to certify that this project entitled “online tiffin service " is carried out
by Anpat Shailesh Dilipbhai, Baria priteshkumar Ajaykumar, Ravat
Rakeshbhai Sukrambhai Studying at Master of Computer Application in 3rd
Semester (Faculty of Computer Application, Vahelal) for partial fulfillment
Master of Computer Application degree to be awarded by Monark University.

This project work has been carried out under faculty Guidance. The project is
fit to the considered at for evolution for the degree of Master of Computer
Application.

Place: Vahelal

Date:

Principal Name
Prof. Sudha Patel
Experience of Journey during Project
Duration

Developing the Online Tiffin Service System for your MCA 3rd-semester
project will be a blend of learning, challenges, problem-solving, and
achievements. Here's a detailed account of what your experience might look
like throughout the project:The journey of developing the Online Tiffin
Service System for your MCA 3rd-semester project will be a blend of
learning, challenges, problem-solving, and achievements. Here's a detailed
account of what your experience might look like throughout the project:This
project allowed me to use Python for different tasks, such as creating easy-
to use interfaces, managing large amounts of data, and organizing
workflows to make the system run smoothly.

I learned how to manage customer details, policies, and claims efficiently,

which gave me practical knowledge of how insurance systems operate. One
of the biggest lessons was learning how to manage resources like time,
tools, and teamwork effectively. It taught me the importance of planning
and coordinating tasks to meet deadlines. This experience not only
improved my technical skills but also helped me understand how to
approach and solve real-life challenges in a systematic way.

Overall, working on this project has been a great journey that combined
learning and application. It prepared me for future challenges in software
development and helped me grow both technically and personally.

Table of Contents
Chapter Chapter
Page No.
No. Name
1 Introduction 5

1.1 overview of the project

1.2 problem statement
1.3 Objective
1.4 scope
1.5 tools and technology
2 System Analysis and design 8

2.1 system required analysis

2.2 system architecture design
2.3 entity relationship diagram
3 Database design 11

3.1 database design

3.2 table description
3.3 SQL queries
4 System implementation 14

5 Testing and Debugging 19

6 Deployment 21

7 Conclusion and scope 32

8 Refrences 33
 Chapter 1
Introduction
1.1 Overview of the Project
The Online Tiffin Service System is a web-
based application that allows users to
subscribe for meal plans, order tiffins, and
manage subscriptions. The system helps users
easily access meal options and provides an
efficient way to manage the ordering and
delivery process. The admin side of the
system manages menus, user data, and
orders.

1.2 Problem Statement

With busy lifestyles and limited time for
cooking, many people seek convenient meal
solutions. The Online Tiffin Service System
provides a platform for ordering home-
cooked meals online, ensuring timely delivery
and an easy ordering process.
1.3 Objectives
The main objectives of this project are:

To develop a web platform where users can

order tiffins.
To provide a reliable system for managing
orders, payments, and deliveries.
To create an intuitive admin panel for
managing users, orders, and menus.

1.4 Scope
This system focuses on:

Online ordering of tiffins and subscription

management.
User authentication, payment processing, and
order history.
Admin management of users, menus, and
order status.

1.5 Tools and Technologies

The project uses the following technologies:

Frontend: HTML, CSS, JavaScript, Bootstrap.

Backend: PHP, MySQL.
Server: XAMPP/WAMP for local development.
Payment Integration: Razorpay API.
 Chapter 2
System Analysis and Design

2.1 System Requirement Analysis**

Before starting development, understanding
the system requirements is crucial. This
section discusses both functional and non-
functional requirements:imp
- **Functional Requirements**: User
registration, login, menu management,
payment gateway integration, order history,
and admin management.
- **Non-Functional Requirements**: Security
(data encryption for user passwords, secure
payment), usability (user-friendly UI),
scalability (ability to handle more users).
2.2 System Architecture Design**
The system is based on a three-tier
architecture:
1. **Presentation Layer**: User interface built
with HTML, CSS, and JavaScript.
2. **Business Logic Layer**: PHP handles user
requests, authentication, order processing,
and payment.
3. **Data Layer**: MySQL database to store
user information, orders, and menus.
2.3 Entity Relationship Diagram (ERD)**
The ERD represents the relationships
between different entities like users, orders,
menus, and payments. This will help visualize
how the data is structured in the database.

---
 Chapter 3: Database Design**
3.1 Database Design**
This chapter focuses on designing the
database schema. It explains how each table
(e.g., Users, Orders, Menus, Payments) is
structured and how they relate to one
another.

3.2 Table Descriptions**

- **Users Table**: Stores user details (name,
email, password, etc.).
- **Menus Table**: Contains meal details (dish
name, price, description).
- **Orders Table**: Stores order information
(user_id, total_amount, order status).
- **Payments Table**: Stores payment details
(payment method, amount, status).
3.3 SQL Queries**
Sample SQL queries for creating tables and
inserting data:
```sql
CREATE TABLE users (
user_id INT PRIMARY KEY
AUTO_INCREMENT,
name VARCHAR(100),
email VARCHAR(100) UNIQUE,
password VARCHAR(255),
address TEXT
);
 Chapter 4: System Implementation**
4.1 User Registration and Authentication**
This section discusses how the user
registration and login process works. It
includes the use of PHP sessions for
authentication and password encryption
using `bcrypt`.
4.2 User Dashboard**
Once logged in, users can view their
dashboard, which displays their order history,
menu options, and payment status. This
section discusses how the dashboard is
implemented.
4.3 Menu Management**
Users can browse and filter available menus.
The frontend makes AJAX calls to fetch menu
data, and PHP handles the logic on the
backend
4.4 Order Management**
Users can place an order, select a subscription
plan, and proceed with payment. The system
also allows users to view the status of their
orders.
4.5 Payment Integration**
This chapter explains how the Razorpay API
(or other gateways) is integrated into the
system for secure payments. It includes the
steps for generating payment links, handling
payment success/failure, and storing payment
details in the database.
4.6 Admin Panel**
The admin panel allows admins to manage
users, menus, and orders. Admins can add or
delete menu items, view all orders, and
update their status. It also includes features to
generate reports on user activity and revenue.
 Chapter 5: Testing and Debugging**

5.1 Testing Methodology**

This section explains the testing approach
used to ensure that the system works as
expected. Different types of testing such as
unit testing, integration testing, and system
testing are discussed here.

#### **5.2 Test Cases**

Test cases for different modules of the system:
- **User Registration**: Verify that users can
register with valid details.
- **Order Placement**: Test the functionality
of placing an order, including payment
integration.
- **Admin Functions**: Test whether the
admin can view and manage orders.

#### **5.3 Bug Fixes**

Any bugs found during testing are logged here
along with their solutions.

---
 Chapter 6: Deployment**

#### **6.1 Deployment Process**This

chapter explains the process of deploying the
project to a live server (using cPanel or SSH
access for hosting). It includes uploading files,
configuring the database, and setting up
payment gateway credentials.

#### **6.2 Final System Setup**

The final system setup steps include
configuring domain settings, securing the
system with SSL, and ensuring that all server-
side configurations are correct.

---
Creating a codebase for an online tiffin service
requires developing a web or mobile
application that supports user registration,
menu browsing, order placement, payment
processing, and delivery tracking. Below is a
basic outline for a **Python Flask backend**
for a tiffin service. This is a simplified
implementation.

### Requirements
- Python
- Flask (`pip install flask`)
- Database (e.g., SQLite for simplicity)
- Frontend (React, Angular, or just
HTML/CSS/JS for the web interface)

---
### **1. Install Dependencies**
```bash
pip install flask flask_sqlalchemy
flask_marshmallow flask-cors
```

---

### **2. Backend Code (Flask)**

```python
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_marshmallow import
Marshmallow
from flask_cors import CORS
app = Flask(__name__)
CORS(app)

# Configurations
app.config['SQLALCHEMY_DATABASE_URI'] =
'sqlite:///tiffin.db'
app.config['SQLALCHEMY_TRACK_MODIFICAT
IONS'] = False

db = SQLAlchemy(app)
ma = Marshmallow(app)

# Models
class Tiffin(db.Model):
id = db.Column(db.Integer,
primary_key=True)
name = db.Column(db.String(100),
nullable=False)
 price = db.Column(db.Float, nullable=False)
description = db.Column(db.String(200),
nullable=False)

class Order(db.Model):
id = db.Column(db.Integer,
primary_key=True)
tiffin_id = db.Column(db.Integer,
db.ForeignKey('tiffin.id'), nullable=False)
customer_name =
db.Column(db.String(100), nullable=False)
address = db.Column(db.String(200),
nullable=False)

# Schemas
class
TiffinSchema(ma.SQLAlchemyAutoSchema):
class Meta:
model = Tiffin
class
OrderSchema(ma.SQLAlchemyAutoSchema):
class Meta:
model = Order

tiffin_schema = TiffinSchema()
tiffins_schema = TiffinSchema(many=True)
order_schema = OrderSchema()
orders_schema = OrderSchema(many=True)

# Routes
@app.route('/tiffins', methods=['GET'])
def get_tiffins():
tiffins = Tiffin.query.all()
return tiffins_schema.jsonify(tiffins)
@app.route('/tiffin', methods=['POST'])
def add_tiffin():
name = request.json['name']
price = request.json['price']
description = request.json['description']
new_tiffin = Tiffin(name=name, price=price,
description=description)
db.session.add(new_tiffin)
db.session.commit()
return tiffin_schema.jsonify(new_tiffin)

@app.route('/order', methods=['POST'])
def place_order():
tiffin_id = request.json['tiffin_id']
customer_name =
request.json['customer_name']
address = request.json['address']
 new_order = Order(tiffin_id=tiffin_id,
customer_name=customer_name,
address=address)
db.session.add(new_order)
db.session.commit()
return order_schema.jsonify(new_order)

@app.route('/orders', methods=['GET'])
def get_orders():
orders = Order.query.all()
return orders_schema.jsonify(orders)

# Database Initialization
@app.before_first_request
def create_tables():
db.create_all()

if __name__ == '__main__':
 app.run(debug=True)
```

---

### **3. Frontend Outline**

You can create a simple frontend using React,
Angular, or plain HTML/CSS/JS that calls these
API endpoints:
- `/tiffins` - Get all available tiffins.
- `/tiffin` (POST) - Add a tiffin (admin
functionality).
- `/order` (POST) - Place an order.
- `/orders` - Get all orders (admin
functionality).

---
### **4. Database Initialization**
Run the Flask application once to create the
SQLite database (`tiffin.db`).

---

### **5. Example API Requests**

#### Add a Tiffin (POST to `/tiffin`)
```json
{
"name": "Veg Thali",
"price": 150,
"description": "Includes rice, dal, chapati,
and vegetables."
}
```

#### Place an Order (POST to `/order`)

```json
{
"tiffin_id": 1,
"customer_name": "John Doe",
"address": "123 Street, City"
}
```

---

This setup can be extended with:

- **Authentication:** Add user accounts with
Flask-JWT or Flask-Security.
- **Payment Integration:** Use Stripe or
Razorpay.
- **Advanced UI:** Build a React/Angular-
based frontend for a modern UX.
Let me know if you need more details!

Chapter 7: Conclusion and Future Scope**

#### **7.1 Summary of the Project**

This chapter summarizes the objectives and
accomplishments of the project. It revisits the
main features and their implementations,
such as user management, menu handling,
and payment integration.

#### **7.2 Limitations**

Discusses any limitations in the project, such
as scalability issues or missing features that
were not included due to time constraints.
7.3 Future Enhancements**
This section explores possible future
improvements, such as adding a mobile app
version of the system, implementing real-time
delivery tracking, or incorporating a
recommendation system based on user
preferences.
Chapter 8: References**

This chapter lists all the references and

resources used for the development of the
project, including textbooks, research papers,
online tutorials, and API documentation.

---

This chapter-wise breakdown should give you

a comprehensive understanding of how to
approach the development of your Online
Tiffin Service System project. Each chapter
can be expanded with specific code
implementations, test cases, and detailed
explanations as needed.