Online Fire Reporting System

Website---FireWatchDog

Project Synopsis
By
 Acknowledgement

In successfully completing this project, many people have helped me. I would like
to thank all those who are related to this project.
Primarily, I would thank God for being able to complete this project with success.
Then I will thank my project guide (name of guide) and HOD(name of HOD), under
whose guidance I learned a lot about this project. His suggestions and directions
have helped in the completion of this project.
Finally, I would like to thank my parents and friends who have helped me with
their valuable suggestions and guidance and have been very helpful in various
stages of project completion.
.

----------------------
 Abstract
“Online Fire Reporting System(FireWatchDog)”is web basedapplication which
manages the fire reporting incidents and sends the team accordingly. The main
purpose of OFRS is to systematically record, store and update the fire team
information and fire incidents.

The information from OFRS is used report fire incidents online. With the help of
this software person can report fire accidents online and get fire reliefs
immediately.
 Introduction
Introduction:-
Online Fire Reporting System is a web-based application. This application is used
to report fire incidents immediately.

In Online Fire Reporting System, we use Python and Sqlite database. This is the
project which keeps records of Fire Fighter Team. Online Fire Reporting System
has two modules i.e., admin and users.

User Module
Users can visit the website and report any fire incidents.
Users can also track the fire incident reporting Status.

Admin Module
Admin will be the user of this project who can control the whole website.

 Dashboard: In this section, the admin can briefly view information about
fire incidents.
 Teams: In this section, admin can mange Teams(Add/Update/Delete).
 Reports: In this section, the admin can view fire incidents in a particular
period and also search the fire reporting/incidents.
 Website Setting: In this section, the admin changes the setting of a website
like logos contents, etc.
 Admin can also manage own profile.
 Admin can also recover their own password.
Purpose:-
The purpose of developing Online Fire Reporting System is to report fire incidents
online without wasting a time. Another purpose for developing this application is
to generate the report automatically.

Scope:-
Online Fire Reporting Systemproject is developed as a web application and it will
work over web to report fire incidents online.
 Requirement Specification

Software Requirements:

 Technology: Python Django

 IDE : Pycharm/Atom
 Client Side Technologies: HTML, CSS, JavaScript , Bootstrap
 Server Side Technologies: Python
 Data Base Server: Sqlite
 Operating System: Microsoft Windows/Linux

Hardware Requirements:

 Processor: Pentium-III (or) Higher

 Ram: 64MB (or) Higher
 Hard disk: 80GB (or) Higher
Python

Python is a widely used general-purpose, high level programming language. It was initially designed by
Guido van Rossum in 1991 and developed by Python Software Foundation. It was mainly developed for
emphasis on code readability, and its syntax allows programmers to express concepts in fewer lines of
code.

Python is a programming language that lets you work quickly and integrate systems more efficiently.

Python is dynamically typed and garbage-collected. It supports multiple programming paradigms,

including procedural, object-oriented, and functional programming. Python is often described as a
"batteries included" language due to its comprehensive standard library.
HTML

HTML (Hypertext Markup Language) is the set of markup symbols or codes inserted in a file intended for
display on a World Wide Web browser page. The markup tells the Web browser how to display a Web
page's words and images for the user. Each individual markup code is referred to as an element (but
many people also refer to it as a tag). Some elements come in pairs that indicate when some display
effect is to begin and when it is to end.
CASCADING STYLE SHEET (CSS)

Cascading Style Sheets (CSS) are a collection of rules we use to define and modify web pages. CSS are
similar to styles in Word. CSS allow Web designers to have much more control over their pages look and
layout. For instance, you could create a style that defines the body text to be Verdana, 10 point. Later
on, you may easily change the body text to Times New Roman, 12 point by just changing the rule in the
CSS. Instead of having to change the font on each page of your website, all you need to do is redefine
the style on the style sheet, and it will instantly change on all of the pages that the style sheet has been
applied to. With HTML styles, the font change would be applied to each instance of that font and have
to be changed in each spot.

CSS can control the placement of text and objects on your pages as well as the look of those objects.

HTML information creates the objects (or gives objects meaning), but styles describe how the objects
should appear. The HTML gives your page structure, while the CSS creates the “presentation”. An
external CSS is really just a text file with a .css extension. These files can be created with Dreamweaver,
a CSS editor, or even Notepad.

The best practice is to design your web page on paper first so you know where you will want to use
styles on your page. Then you can create the styles and apply them to your page.
Javascript

JavaScript is a programming language commonly used in web development. It was originally

developed by Netscape as a means to add dynamic and interactive elements to websites. While
JavaScript is influenced byJava, the syntax is more similar to C and is based on ECMAScript, a
scripting language developed by Sun Microsystems.
JavaScript is a client-side scripting language, which means the source code is processed by the
client's web browser rather than on the web server. This means JavaScript functions can run after
a webpage has loaded without COMMUNICATING with the server. For example, a JavaScript
function may check a web form before it is submitted to make sure all the required fields have
been filled out. The JavaScript code can produce an error message before any information is
actually transmitted to the server.
Like server-side scripting languages, such as PHP and ASP, JavaScript code can be inserted
anywhere within the HTML of a webpage. However, only the output of server-side code is
displayed in the HTML, while JavaScript code remains fully visible in the source of the
webpage. It can also be referenced in a separate .JS file, which may also be viewed in a browser.
Django

Django is a web application framework written in Python programming language. It is based on

MVT (Model View Template) design pattern. The Django is very demanding due to its rapid
development feature. It takes less time to build application after collecting client requirement.

This framework uses a famous tag line: The web framework for perfectionists with deadlines.
 Analysis and Design

Analysis:

In present all fire incidents record work done on the paper. We can’t generate

reports as per our requirements because its take more time to calculate the fire

incidents record report.

Disadvantage of present system:

• Not user friendly: The present system not user friendly because data is not

stored in structure and proper format.

• Manual Control: All report calculation is done manually so there is a chance

of error.

• Lots of paper work: Fire incidents record maintain in the register so lots of

paper require storing details.

• Time consuming

Design 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:
Actor:
A coherent set of roles that users of use cases play when interacting with
the use `cases.

Use case: A description of sequence of actions, including variants, that a system

performs that yields an observable result of 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 from 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 need to be designed.

USECASE DIAGRAMS:

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

Use 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.

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 user’s perspective.
• An actor could be the end-user of the system or an external system.

USECASE DIAGRAM: A Use case is a description of set of sequence of actions.

Graphically it is rendered as an ellipse with solid line including only its name. 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.Use Case Diagrams:

Admin
 Dashboard

Add Team

Manage Team (Update/Delete)

Details)

Mange Fire Reports

Search(Fire Incidents)

Generate Reports

Update Profile

Change Password

Password Recovery
Users

Visit Website
User

Report Fire incidents

Check the status of fire

report
Class Diagram:

A description of set of objects that share the same attributes operations,

relationships, and semantics

ER Diagram:

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 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 specific database management
software.

ER Notation
There is no standard for representing data objects in ER diagrams. Each modeling
methodology uses its own notation. The original notation used by Chen is widely
used in academics texts and journals but rarely seen in either CASE tools or
publications by non-academics. Today, there are a number of 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
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
entity that is optional.
 Data Flow Diagram

DFD graphically representing the functions, or processes, which capture,

manipulate, store, and distribute data between a system and its environment and
between components of a system. The visual representation makes it a good
communication tool between User and System designer. Structure of DFD allows
starting from a broad overview and expand it to a hierarchy of detailed diagrams.
DFD has often been used due to the following reasons:
 Logical information flow of the system
 Determination of physical system construction requirements
 Simplicity of notation
 Establishment of manual and automated systems requirements

Zero Level DFD

Team Password
Management Management

OFRS

Website
Fire Report
Management Management

Login
Management
 First Level DFD

Password
Management
Team
Management

Generate
Reports
Fire Report OFRS
Management

Admin
Login Management
Management
 Second Level DFD

Check
Admin Login to Roles of
system access

Forgot Check Manage Fire

Password Credenti Team
al

Manage
Manage Fire Report
Modules

Generate Report

Manage Website Change Password Update Profile

 Users Check
Roles of
Report For Fire
access

Check
Credenti
al
Search the status of
fire

Manage
Modules

View Website
Database Tables:

Admin Table :(Table name is tbladmin)

This store admin personal and login details.

Fire Report Table: (Table name is tblfirereport)

This table store tee details of fire report by users

Request History Table: (Table name is tblfiretequesthistory)

This table store the details of request history of fire reporting.
Website Table: (Table name is tblsite)
This table store the details of website.

Fire Team Table: (Table name is tblsite)

This table store the details of fire team who handling fire incidents.
 Implementation and System Testing
After all phase have been perfectly done, the system will be implemented to the
server and the system can be used.

System Testing

The goal of the system testing process was to determine all faults in our project .The
program was subjected to a set of test inputs and many explanations were made and
based on these explanations it will be decided whether the program behaves as expected
or not. Our Project went through two levels of testing

1. Unit testing
2. Integration testing
UNIT TESTING
Unit testing is commenced when a unit has been created and effectively
reviewed .In order to test a single module we need to provide a complete
environment i.e. besides the section we would require

• The procedures belonging to other units that the unit under test calls

• Non local data structures that module accesses

• A procedure to call the functions of the unit under test with

appropriate parameters
1. Test for the admin module

• Testing admin login form-This form is used for log in of administrator of the
system. In this form we enter the username and password if both are
correct administration page will open otherwise if any of data is wrong it
will get redirected back to the login page and again ask the details.

• Report Generation: admin can generate report from the main database.

INTEGRATION TESTING

In the Integration testing we test various combination of the project module by

providing the input.

The primary objective is to test the module interfaces in order to confirm that no
errors are occurring when one module invokes the other module.
 Conclusion
This Application provides an online version of Online Fire Reporting System
which will benefit the fire handling team to maintain fire incidents details and
fire team details.

It makes entire process online and can generate reports.

The Application was designed in such a way that future changes can be
done easily. The following conclusions can be deduced from the development of
the project.

• Automation of the entire system improves the productivity.

• It provides a friendly graphical user interface which proves to be
better when compared to the existing system.
• It gives appropriate access to the authorized users depending on
their permissions.
• It effectively overcomes the delay in communications.
• Updating of information becomes so easier.
• System security, data security and reliability are the striking features.
• The System has adequate scope for modification in future if it is
necessary.
 References

 Wikipedia

 https://www.geeksforgeeks.org/python-django/

 https://www.javatpoint.com

 https://www.python.org/

 https://www.tutorialspoint/
 REFERENCE BOOKS

Two scoops of Django for 1.11 by Daniel Greenfeld’s and Audrey Greenfield

Lightweight Django by Elman and Mark Lavin