I.

INTRODUCTION

Canteen management system (EatSmart) is a mobile application designed to streamline and

automate the day-to-day operations of the canteen. This application will help the canteen
managers to efficiently manage inventory, track sales, and handle transactions.

Currently, the way schools/college canteens work is that you pay for the food and you wait for
the food in line but the problem is that all the students in a facility have the same time slot for
the break hence a group of people end up rushing towards the canteen at the same time this
creates a lot of inconvenience for the canteen staff as well as the students and since the time is
limited some students end up not eating food or wasting their food.

This is where EatSmart helps in streamlining the whole process wherein students can order their
food via their phones beforehand from the app in which the user has to enter the email id and
then they are ready to order via e-menu and do the payments as well and this helps the college to
keep a track on the canteens transactions.

The digitalization of the canteen system will help provide better service to the users and the time
consumption will be reduced. The updation and deletion of any item can be done. The online
system will be helpful for the food makers to prepare the food as early as possible. As a result,
there will be quick service to the customers. No queues will be formed waiting for the food. The
update of the data to the database will be monitored by the admin.

Flutter for Frontend:

Flutter is an open-source UI framework developed by Google. It enables the creation of
beautiful, fast, and cross-platform applications for mobile, web, and desktop using a single
codebase. Flutter's key feature is its reactive framework, allowing for real-time updates and
smooth user experiences. By using Flutter for the frontend of a canteen management app,
developers can build visually appealing and responsive interfaces that can be deployed on both
iOS and Android devices. The advantage of using Flutter is the ability to write code once and
deploy it across multiple platforms, reducing development time and effort.

BATCH - G10 1 EATSMART

Firebase for Backend Services:
Firebase is a comprehensive mobile and web development platform offered by Google. It
provides a suite of services that simplify the backend infrastructure required for app
development, including authentication, real-time database, cloud storage, and hosting. Firebase's
backend services eliminate the need for complex server-side coding, making it an ideal choice for
developing a canteen management app. The seamless integration of Firebase services allows
developers to focus on building the core features of the app without worrying about the
underlying infrastructure.

BATCH - G10 2 EATSMART

Firestore as a Database:
Firestore is a NoSQL cloud-based database provided by Firebase. It offers real-time data
synchronization, scalability, and offline support, making it a robust choice for mobile and web
applications. In the context of a canteen management app, Firestore can be used to store and
manage crucial data such as customer information, menu items, orders, and inventory levels.
With Firestore's real-time capabilities, any updates or changes made to the database are instantly
reflected across all connected devices. This enables real-time monitoring of stock levels, order
statuses, and other critical data, ensuring efficient management and smooth operation of the
canteen.

By combining Flutter for the frontend and Firebase with Firestore for the backend, a canteen
management app can offer a range of features and benefits. Users can easily place orders, make
payments, view menus, and track their order status through a user-friendly and intuitive interface
developed with Flutter. The integration with Firebase and Firestore ensures secure data storage,
seamless synchronization, and real-time updates, enhancing the overall user experience and
simplifying the canteen management process.

BATCH - G10 3 EATSMART

 II. SCOPE AND OBJECTIVE

The objective of EatSmart is to efficiently and effectively manage the operations of a canteen or
cafeteria The system aims to streamline various processes involved in running a canteen,
including food ordering, inventory management, payment handling, and reporting. The specific
objectives are -

1. Order management: Simplify the process of placing food orders by providing an online or
automated system for customers to place their orders, specifying the items, quantity .

2. Menu planning: Help canteen managers plan and organize menus based on popular choices,
dietary requirements, and availability of ingredients. This can lead to a more diverse and
balanced menu offering.

3. Efficient payment processing: Enable convenient and cashless payment options for customers,
such mobile payment.This reduces the need for manual cash handling and increases transaction
efficiency.

4.Cost control: Monitor and control costs associated with food procurement, waste management,
and pricing. By analyzing data on expenses and revenue, the system can help identify areas for
cost reduction or revenue improvement.

5. Customer satisfaction: Enhance the overall customer experience by providing a user-friendly

interface for placing orders, ensuring prompt service, maintaining food quality, and
accommodating special dietary needs.

BATCH - G10 4 EATSMART

 III . SYSTEM PROJECT FLOW

1. USE CASE DIAGRAM --

Figure 3.1

From above use case diagram we can understand that customer base consists of student and faculty
which are actors and they perform task of viewing menu , placing Order and finally making payment
and use cases in application are following :- Menu , Order , Payment . Admin i another actor which
accepts payment
and can edit menu.

BATCH - G10 5 EATSMART

 2. DATA FLOW DIAGRAM --

Figure 3.2

A data flow diagram (DFD) for a canteen management system represents the flow of
information within the system, illustrating how data is processed and transformed. Here is a
short description of a typical DFD for a canteen management system:
The DFD for the canteen management system consists of several components, including external
entities, processes, data stores, and data flows. The primary external entities are the canteen
staff, customers, and the inventory supplier.

BATCH - G10 6 EATSMART

 3. CLASS FLOW DIAGRAM –

Figure 3.3

In above class diagram we can observe various classes like Customer, order, person , menu,
canteen_admin and bill which has methods and variables that define them and they are related to each
other via relation shown in diagram.

BATCH - G10 7 EATSMART

 IV. CODE AND SNAPSHOT

Figure 4.1 Figure 4.2 Figure 4.3

SIGN UP SIGN IN HOME SCREEN

here in Fig 4.1 User will register himself to app on sign up page by providing some details or User
which has already registered will login through login page shown in Fig 4.2 , from there user will be
directed to Home page where he can have look at all products and sales etc Shown in Fig 4.3.

BATCH - G10 8 EATSMART

 Figure 4.4 Figure 4.5 Figure 4.6

ALL PRODUCTS ON SALE PRODUCTS CATEGORIES

In Fig 4.4 and Fig 4.5 User can access various products and products on sale and From Fig 4.6 User can
Select Categories from where he/she wishes to buy

BATCH - G10 9 EATSMART

 Figure 4.7 ADMIN DASHBOARD

Figure 4.8 ADMIN MENU

BATCH - G10 10 EATSMART

 Figure 4.9 ADMIN ADD PRODUCT

Fig 4.7,4.8,4.9 shows web application of Admin Panel which is accessible by admin only and
from where admin can make changes in menu like add items , delete items modify items as per
availability and the order placed by user is also visible here and as per order Id generated for
each order and admin panel will authenticate order for user and provide order accordingly .

BATCH - G10 11 EATSMART

 CODE

//main.dart
import 'package:firebase_core/firebase_core.dart';
import 'package:flutter/material.dart';
import 'package:grocery/inner_screens/on_sale_screen.dart';
import 'package:grocery/provider/dark_theme_provider.dart';
import 'package:grocery/providers/orders_provider.dart';
import 'package:grocery/providers/products_provider.dart';
import 'package:grocery/screens/home_screen.dart';
import 'package:grocery/screens/viewed_recently/viewed_recently.dart';
import 'package:provider/provider.dart';

import 'consts/theme_data.dart';
import 'fetch_screen.dart';
import 'inner_screens/cat_screen.dart';
import 'inner_screens/feeds_screen.dart';
import 'inner_screens/product_details.dart';
import 'providers/cart_provider.dart';
import 'screens/auth/forget_pass.dart';
import 'screens/auth/login.dart';
import 'screens/auth/register.dart';
import 'screens/btm_bar.dart';
import 'screens/orders/orders_screen.dart';
import 'screens/wishlist/wishlist_screen.dart';

void main() {
runApp(const MyApp());
}

class MyApp extends StatefulWidget {

const MyApp({Key? key}) : super(key: key);

@override
State<MyApp> createState() => _MyAppState();
}

class _MyAppState extends State<MyApp> {

DarkThemeProvider themeChangeProvider = DarkThemeProvider();

void getCurrentAppTheme() async {

themeChangeProvider.setDarkTheme =
await themeChangeProvider.darkThemePrefs.getTheme();
}

@override
void initState() {
getCurrentAppTheme();
super.initState();
}

BATCH - G10 12 EATSMART

final Future<FirebaseApp> _firebaseInitialization = Firebase.initializeApp();
@override
Widget build(BuildContext context) {
return FutureBuilder(
future: _firebaseInitialization,
builder: (context, snapshot) {
if (snapshot.connectionState == ConnectionState.waiting) {
return const MaterialApp(
debugShowCheckedModeBanner: false,
home: Scaffold(
body: Center(
child: CircularProgressIndicator(),
)),
);
} else if (snapshot.hasError) {
const MaterialApp(
debugShowCheckedModeBanner: false,
home: Scaffold(
body: Center(
child: Text('An error occured'),
)),
);
}
return MultiProvider(
providers: [
ChangeNotifierProvider(create: (_) {
return themeChangeProvider;
}),
ChangeNotifierProvider(
create: (_) => ProductsProvider(),
),
ChangeNotifierProvider(
create: (_) => CartProvider(),
),
ChangeNotifierProvider(
create: (_) => OrdersProvider(),
),
],
child: Consumer<DarkThemeProvider>(
builder: (context, themeProvider, child) {
return MaterialApp(
debugShowCheckedModeBanner: false,
title: 'Flutter Demo',
theme: Styles.themeData(themeProvider.getDarkTheme, context),
home: const FetchScreen(),
routes: {
OnSaleScreen.routeName: (ctx) => const OnSaleScreen(),
FeedsScreen.routeName: (ctx) => const FeedsScreen(),
ProductDetails.routeName: (ctx) => const ProductDetails(),
WishlistScreen.routeName: (ctx) => const WishlistScreen(),
BATCH - G10 13 EATSMART
 OrdersScreen.routeName: (ctx) => const OrdersScreen(),
ViewedRecentlyScreen.routeName: (ctx) =>
const ViewedRecentlyScreen(),
RegisterScreen.routeName: (ctx) => const RegisterScreen(),
LoginScreen.routeName: (ctx) => const LoginScreen(),
ForgetPasswordScreen.routeName: (ctx) =>
const ForgetPasswordScreen(),
CategoryScreen.routeName: (ctx) => const CategoryScreen(),
});
}),
);
});
}
}

BATCH - G10 14 EATSMART

 V. RESULT

Figure 5.1 Figure 5.2 Figure 5.3

Product Added in Cart Cart User Orders

The Fig 5.1 to 5.3 shows how User can add items he wish to buy in cart so that he can order all of theme
together and on clicking on cart icon user can view cart and after clicking on order now , order will be
placed and user can view order on your orders page

BATCH - G10 15 EATSMART

 Figure 5.4 Figure 5.5 Figure 5.6

Order Placed Empty Cart User Account

here in Fig 5.4 will show empty cart once user places order or if in case user didn’t add any item to cart
and Fig 5.6 shows account page where user can handle its account and make changes in account such as
editing password etc .

BATCH - G10 16 EATSMART

 Figure 5.7 RECENT ORDERS

Figure 5.8 ALL ORDERS

BATCH - G10 17 EATSMART

 VI . CONCLUSION AND FUTURE SCOPE

1. EatSmart is efficient in maintaining customer’s details and also works to handle the
information of the products available in a canteen.

2. It also saves a lot of time and reduces the chances of any errors that were possible with
the earlier system. This application also reduces the workload of the canteen.

FUTURE SCOPE OF THE PROJECT -

1. Users can customize food options.

2. AI and Machine learning can be used to analyze customer behavior

3. Same system can be used at various applications like Hotel management , grocery
ordering .

4. Integration with loyalty programs.

5. Voice-activated ordering

BATCH - G10 18 EATSMART

 VII. REFERENCES

1. TutorialPoint Documentation :

https://www.tutorialspoint.com/android/android_studio.html

2. Android Studio Tutorial :

:https://www.androidauthority.com/android-studio-tutorial-beginners-637572/

3. Flutter Official Documentation : https://docs.flutter.dev/get-started/install

4. Canteen Food Ordering Android System, Abhishek Singh, Amit Tanwar, Aditya

Sawant, Chaitanya Parulekar, Kunal Yadav, IT Department, MUMBAI University,

Journal on Recent and Innovation Trends in Computing and Communication, ISSN:

2321-8169

5. Shweta Shashikant Tanpure, Priyanka R. Shidankar, Madhura M. Joshi, “Automated

Food Ordering System with Real-Time Customer Feedback”, in International Journal

of Advanced Research in Computer S

6. Smart Canteen Management System by Sujata Joshi,Bivek Kasaju,Pratik Karki,Sagun

Kant Aryal,Sujan Bhuwanji Chhetri.

BATCH - G10 19 EATSMART