ONLINE CRIME REPORTING SYSTEM IN

PYTHON

A PROJECT REPORT

YSE701 Internship
Submitted by

RAGUL.P(116012351309)

In partial fulfillment for the under of the degree

of

MASTER OF SCIENCE

IN

SOFTWARE ENGINEERING

PERIYAR MANIAMMAI INSTITUTE OF SCIENCE & TECHNOLOGY

VALLAM, THANJAVUR–613403.

NOV 2019
DEPARTMENT OF SOFTWARE ENGINEERING
Periyar Nagar, Vallam Thanjavur-613 403, Tamil Nadu, India
Phone: +91- 4362 -264600 Fax: +91 - 4362-
264660
Email: headmsc@pmu.edu Web: http://www.pmu.edu

BONAFIDE CERTIFICATE

This is to Certified that this the work entitled “ONLINE CRIME REPORTING
SYSTEM IN PYTHON” is the bonafide work carried out by
RAGUL.P(116012351309), candidate of the M.Sc Software Engineering programme in
YSE701 Internship of the Periyar maniammai institute of Science and Technology,
vallam during the academic year 2019-2020.

Signature :

Name :
Head of the Department Supervisor

Date :

Submitted for Periyar Maniammai Institute of Science and Technology Project/

Thesis Viva-voce Examination held on...................................at University.

Signature :

Name :
External Examiner Internal Examiner
Date :
 DECLARATION

RAGUL P, hereby the Internship entitled “ONLINE CRIME REPORTING

SYSTEM IN PYTHON” submitted to the Periyar Maniammai Institute of
Science and Technology in partial Fulfillment of the requirements for the award
of the degree Master of Science in Software Engineering is a record of original
work carried out under the supervisor Of Ms.K.MEENA,M.E., , Assistant
Professor, Department of Software Engineering, PMIST, Vallam and that it has
nor formed Before the basis for the award of any Degree, Diploma or any other
similar work In this or any other Universities or Institution of higher education.

Place: Signature of the Candidate

Date:
ACKNOWLEDGEMENT
I would like to express my sincere thanks to the management for providing us various
facility needed for successful completion of my project work.

It’s my great pleasure to give sincere thanks to Dr. J. Jeyachitra, Dean(i/c), School of
Computing Sciences and Engineering (SCSE), PMIST provided the opportunity to complete
this project without hurdles.

It’s my great pleasure to give sincere thanks to Dr. P.Aruna , Head, Department of
Software Engineering, PMIST for leading us in to green pastures.

I extend my heartfelt gratitude to my Project Coordinator Mr. D.Magesh kumar, and

guide Ms.K.MEENA, Assistant Professor, Department of Software Engineering, PMIST for
her constant guidance for our project.

I express my sincere thanks to my friends who are helped us to do the project work in
various aspects. It is my duty and moral responsibility to express my praise and gratitude to
my parents who have encouraged me with good spirit by their motivational words to complete
this project.

RAGUL P
 TABLE OF ONTENT

CHAPTER NO. TITLE PAGE NO.

ABSTRACT i
LIST OF FIGURES ii
LIST OF TABLES iii
1 INTRODUCTION 1
2 SYSTEM ANALYSIS 2
2.1 Feasibility Study 2
2.2 Existing System 3
2.3 Proposed System 4
3 SYSTEM SPECIFICATION 5
3.1 Hardware Specification 5
3.2 Software Specification 5
3.3 Language Specification 6
4 SYSTEM DESIGN 21
4.1 Data Flow Diagram 21
4.2 UML Diagram 23
4.3 Use Case Diagram 24
4.4 DataBase Design 25
5 SYSTEM DEVELOPMENT 27
5.1 Module Identification 27
5.2 Module Description 28
6 SYSTEM TESTING 31
7 SYSTEM IMPLEMENTATION 33
8 RESULT AND DISCUSSION 47
9 SYSTEM MAINTENANCE 73
10 CONCLUSION 74
REFERENCES 75
 ONLINE CRIME REPORTING SYSTEM
Abstract
Crime is a part of illegal activities in human life. It is quite obvious that the rate of crimes
is increasing day by day in all societies across the world, but we do believe that there is a lot
which can be done by both the governments and the individuals to reduce the crimes in
communities. The rise of population and complex society raises the range of anti-social conducts
that must be restricted by the government through the military and different organization
particularly the Police Force. There are many current crime management systems which faces
several difficulties, as there is no means to report crime instantly other than phone calls,
messaging or face-to-face compliant filing. Crime Report and Missing Report and can see all the
status of what action has been taken by the admin. To file any of the above 3 complaints, the user
should register in to the system and provide his right credentials to file them. The crime reporting
system project also allows other users who don’t want to register but can check the crime
happening at his or any other area has to just provide the pin code and in return the system
displays the list of crimes if any filed. The offline i.e. the unregistered user can also take
advantage of checking the missing person details, but he is refrained from getting complaints
done by the users.

i
LIST OF FIGURES
FIGURE NO. TITLE PAGE NO.
3.3.1 Python Architecture 8
4.1.1 Data Flow Diagram 22
4.2.1 UML Diagram 23
4.3.1 Use Case Diagram 24

ii
 LIST OF TABLES
TABLE NO. TITLE PAGE NO.
4.4.1 Register 25
4.4.2 Crime 25
4.4.3 Criminal 26
4.4.4 Case 26
4.4.5 Users 26

iiii
 CHAPTER 1
INTRODUCTION

The main aim for this project is to provide all crime management solutions which are
easily accessible by everyone. The system starts with every people who want to login a
complaint through the internet so that it is very useful for police department and social worker to
find out the problem in the society without making people to come to police station every time.
The main purpose of the system is to manage criminal details in a centralized database and
provide solution for public to give complaint through online. This project provides lot of features
to manage all the data in well manner. The system has been developed to override the problems
prevailing in the manual system. The project is supported to eliminate and reduce the hardships
faced by the existing system. This system is designed for particular need of the company to carry
out operations in a smooth and effective manner. The application is reduced as much as possible
to avoid errors while entering the data, and it also provide error message while entering invalid
data. No formal knowledge is needed for the user to use this system and hence it proves it is user
friendly. Online crime reporting system can lead to error free, secure, reliable and fast
management system and it can assist the user to concentrate on the other activities rather than to
concentrate on the record keeping. The purpose of the project is to automate the existing manual
system with the help of computerized equipments and to fulfill the requirements so that the data
can be stored for long period with easy accessing and manipulation.
 CHAPTER 2
SYSTEM ANALYSIS

2.1 FEASIBILITY STUDY

Feasibility to a project determines whether it is possible to develop the project. There are
three main factors, which determine the feasibility of the projects. They are discussed as follows.
Operational Feasibility Study: The Operational Feasibility is the determination of your
system’s minimum configuration used and the machine’s eligibility. This study resultant we that
it requires a Web-browser, Pentium processer, a system with adequate peripherals, macromedia
or adobe Photoshop, etc.
Technical Feasibility Study: The study is related to any technical terms manner is to be
mentioned in the Technical Feasibility Study. It consists of all the database storage facility,
accessing facility, for the restore of data; etc. It needs a high speed processer in GHz with the
advent in technology. According to the entire infrastructure, the system seems to be Technically
Feasible.
Economic Feasibility Study: The main part of among all the three areas of Feasibility
Study is the Economic Feasibility Study. Whenever, anything is started one must see its benefits
and loses. To check such things we have to the related to the financial status of the project. The
developer has to be in the budget and has to develop the project. The additional cost incur is the
manpower.
2.2 EXISTING SYSTEM

Currently there is no online web application available to report crime online. In order
to report any complains related with crime, people have to contact nearest police station. People
of the particular city are not aware of crime related things such as list of most wanted criminals
of their city, latest crime related news, missing persons of their area etc. People have to view
News Channels or Read News Paper for such crime related information. Thus we can say that
existing system is manual and does not provide all the information from one source.

DISADVANTAGES
 More man power.

 Time consuming.

 Consumes large volume of paper work.

 Needs manual calculations.

 No direct role for the higher officials.

2.3PROPOSED SYSTEM

The main purpose of developing the online crime reporting system is for the
welfare and safety of the public. Due to some factors in today’s time public sometimes do not
trust the government officials, due to this they don’t ever want to go to the station and file a
report. So this system will reconstruct the bridge between the two - public and government
officials respectively. So now if anyone wants to file a complaint or misconduct, they can do it
easily from their home. This website is an easy to view type of a site. It is simply accessible to
anyone who is sixteen years and above and this is an example of a simple engineering which is
easy and can be used freely without complexion. This website will provide user with a profile
under which he/she can add anything and no misuse will be conducted as it has some eligible
criteria and which has to be taken care off, so the chances are less.

ADVANTAGES
 Minimize manual data entry.

 Minimum time needed for the various processing.

 Greater efficiency.

 Better service.

 User friendliness and interactive.

 Minimum time required.

 CHAPTER 3
SYSTEM SPECIFICATION

3.1 HARDWARE REQUIREMENTS

Processor : Intel Core i3

Speed : 3.7 GHz
RAM : 4 GB
Hard Disk : 500GB
Monitor : LED Monitor
Mouse : Wireless Mouse
Keyboard : Multi Type
Printer : Laser Printer

3.2 SOFTWARE REQUIREMENT

Operating System : Microsoft windows 10

Front End : Python
Back End : MY SQL
Documentation : Microsoft Word
3.3 LANGUAGE SPECIFICATION

PYTHON

Python is an open source programming language that was made to be easy-to-read and

powerful. Python is an interpreted language. Interpreted languages do not need to be compiled to
run. A program called an interpreter runs Python code on almost any kind of computer. This
means that a programmer can change the code and quickly see the results. This also means
Python is slower than a compiled language like C, because it is not running machine
code directly.

Python is a good programming language for beginners. It is a high-level language, which

means a programmer can focus on what to do instead of how to do it. Writing programs in
Python takes less time than in some other languages. Python is a computer programming
language designed for readability and functionality. One of Python’s design goals is that the
meaning of the code is easily understood because of the very clear syntax of the language.
Python programming language has a specific syntax (form) and semantics (meaning) which
enables it to express computations and data manipulations which can be performed by a
computer. Python’s implementation was started in 1989 by Guido van Rossum at CWI (a
national research institute in the Netherlands) as a successor to the ABC programming language
(an obscure language made more popular by the fact that it motivated Python!). Van Rossum is
Python’s principal author, and his continuing central role in deciding the direction of Python is
reflected in the title given to him by the Python community, Benevolent Dictator for Life
(BDFL). Python is an interpreted language, i.e., a programming language whose programs are
not directly executed by the host cpu but rather executed (or“interpreted”) by a program known
as an interpreter. The source code of a Python program is translated or (partially) compiled to a
“bytecode” form of a Python “process virtual machine” language.

This is in distinction to C code which is compiled to cpu-machine code before runtime.

Python is a “dynamically typed” programming language. A programming language is said to be
dynamically typed, when the majority of its type checking is performed at run-time as opposed to
at compile-time. Dynamically typed languages include JavaScript, Lisp, Lua, Objective-C,
Python, Ruby, and Tcl. Python is an object-oriented language. Object-oriented programming
(OOP) uses “objects” - data structures consisting of datafields and methods - to design computer
programs. For example, a matrix could be the “object” you want to write programs to deal with.
It could define a class of matrices and, for example, a method for that class might be addition
(representing ordinary addition of matrices). It will return to this example in more detail later in
the course.

PYTHON LIABRARY

Python is used by hundreds of thousands of programmers and is used in many places.

Sometimes only Python code is used for a program, but most of the time it is used to do simple
jobs while another programming language is used to do more complicated tasks. Its standard
library is made up of many functions that come with Python when it is installed. On
the Internet there are many other libraries available that make it possible for the Python language
to do more things. These libraries make it a powerful language; it can do many different things.

Some things that Python is often used for are:

 Web development
 Game programming
 Desktop GUIs
 Scientific programming
 Network programming.

Python also does something called "dynamic variable assignment". This means that when
a number or word is made in a program, the user does not have to say what type it is. This makes
it easier to reuse variable names, making fast changes simpler. An example of this is shown
below.

INPUT/OUTPUT
Sage is built on Python, so includes Python, but is designed for general purpose
mathematical computation (the lead developer of Sage is a numbertheorist). The interface to
Sage is IPython, though it has been configured in a customized way to that the prompt says sage:
as opposed to In or >>>. Other than this change in prompt, the command line interface to Sage is
similar to that if Python and SymPy. Sage sage: a = 3.1415 sage: print a 3.14150000000000
sage: type(a) Sage also include SymPy and a nice graphical interface called the Sage notebook.

FRAMEWORK

DATA TYPES

The data which a Python program deals with must be described precisely. This
description is referred to as the data type. In the case of Python, the fact that Python is
dynamically typed basically means that the interpreter or compiler will figure out for you what
type a variable is at run-time, so you don’t have to declare variable types yourself. Besides
numerical data types, such as int (for integers) and float (for reals), there are other types such as
tuple and list. A more complete list, with examples, is given below.

Type Description

 An immutable sequence "string", """\python of Unicode characters is great""", ’2012’

bytes An immutable sequence of bytes b’Some ASCII’.
 List Mutable, can contain mixed types [1.0, ’list’, True].
 Tuple Immutable, can contain mixed types (-1.0, ’tuple’, False) set, Unordered, contains
no duplicates set([1.2, ’xyz’, True]), frozenset frozenset([4.0, ’abc’, True]).
 Dict A mutable group of key {’key1’: 1.0, ’key2’: False} and value pairs int An
immutable fixed precision 42 number of unlimited magnitude float An immutable
floating point 2.71828 number (system-defined precision).
 Complex An immutable complex number -3 + 1.4j with real and imaginary parts
Boolean. An immutable Boolean value True, False.

STRUCTURE OF PYTHON
 Command-Line Application Layouts
 One-Off Script
 Installable Single Package
 Application with Internal Packages

 Web Application Layouts

 Django
 Flask
Python, though opinionated on syntax and style, is surprisingly flexible when it comes to
structuring your applications. On the one hand, this flexibility is great: it allows different use
cases to use structures that are necessary for those use cases. On the other hand, though, it can be
very confusing to the new developer. The Internet isn’t a lot of help either—there are as many
opinions as there are Python blogs.  Examples of common Python application structures,
including command-line applications (CLI apps), one-off scripts, installable packages, and web
application layouts with popular frameworks like Flask and Django.
COMMAND-LINE APPLICATION LAYOUTS

A lot of us work primarily with Python applications that are run via command-line
interfaces (CLIs). This is where you often start with a blank canvas, and the flexibility of Python
application layouts can be a real headache. Starting with an empty project folder can be
intimidating and lead to no shortage of coder’s block.

One-Off Script

The following layout will work for all of these cases and can easily be modified to reflect
whatever installation or other tools you use in your workflow. This layout will cover you
whether you’re creating a pure Python script (that is, one with no dependencies) or using a tool
like pip or Pipenv. That the exact location of the files in the layout matters less than the reason
they are placed where they are. All of these files should be in a project directory named after
your project. For this example, we will use (what else?) helloworld as the project name and root
directory.

Here’s the Python project structure I typically use for a CLI app:

This is pretty straightforward: everything is in the same directory. The files shown here are
not necessarily exhaustive, but I recommend keeping the number of files to a minimum if you
plan on using a basic layout like this. Some of these files will be new to you, so let’s take a quick
look at what each of them does.

 .gitignore: This is a file that tells Git which kinds of files to ignore, like IDE clutter or
local configuration files. Our Git tutorial has all the details, and you can find
sample .gitignore files for Python projects here.
 helloworld.py: This is the script that you’re distributing. As far as naming the main script
file goes, I recommend that you go with the name of your project (which is the same as
the name of the top-level directory).
 LICENSE: This plaintext file describes the license you’re using for a project. It’s always
a good idea to have one if you’re distributing code. The filename is in all caps by
convention.
  README.md: This is a Markdown (or reStructuredText) file documenting the purpose
and usage of your application. Crafting a good README is an art, but you can find a
shortcut to mastery here.
 requirements.txt: This file defines outside Python dependencies and their versions for
your application.
 setup.py: This file can also be used to define dependencies, but it really shines for other
work that needs to be done during installation. You can read more about
both setup.py and requirements.txt in our guide to Pipenv.
 tests.py: This script houses your tests, if you have any. You should have some.

Installable Single Package

Let’s imagine that helloworld.py is still the main script to execute, but you’ve moved all
helper methods to a new file called helpers.py. Now going to package the helloworld Python
files together but keep all the miscellaneous files, such as your README, .gitignore, and so on,
at the top directory.

Let’s take a look at the updated structure:

helloworld/
│
├── helloworld/
│ ├── __init__.py
│ ├── helloworld.py
│ └── helpers.py
│
├── tests/
│ ├── helloworld_tests.py
│ └── helpers_tests.py
│
├── .gitignore
├── LICENSE
├── README.md
├── requirements.txt
└── setup.py
The only difference here is that your application code is now all held in
the helloworldsubdirectory—this directory is named after your package—and that we’ve added a
file called __init__.py. Let’s introduce these new files: This layout is a stripped down version
of Kenneth Reitz’s samplemod application structure. It is another great starting point for your
CLI applications, especially for more expansive projects.

Application with Internal Packages

In larger applications, It has one or more internal packages that are either tied together
with a main runner script or that provide specific functionality to a larger library you are
packaging. It will extend the conventions laid out above to accommodate for this:

helloworld/
│
├── bin/
│
├── docs/
│ ├── hello.md
│ └── world.md
│
├── helloworld/
│ ├── __init__.py
│ ├── runner.py
│ ├── hello/
│ │ ├── __init__.py
│ │ ├── hello.py
│ │ └── helpers.py
│ │
│ └── world/
│ ├── __init__.py
│ ├── helpers.py
│ └── world.py
│
├── data/
│ ├── input.csv
│ └── output.xlsx
│
├── tests/
│ ├── hello
│ │ ├── helpers_tests.py
│ │ └── hello_tests.py
│ │
│ └── world/
│ ├── helpers_tests.py
│ └── world_tests.py
│
├── .gitignore
├── LICENSE
└── README.md

There’s a bit more to digest here, but as long as you remember that it follows from the previous
layout, you will have an easier time following along. I’ll go through the additions and
modifications in order, their uses, and the reasons you might want them. The top-level files
remain largely the same as in the previous layout. These three layouts should cover most use
cases for command-line applications, and even GUI applications with the caveat that you may
have to tinker with some things depending on the GUI framework you use.

WEB APPLICATION LAYOUTS

Another major use case of Python is web applications. Django and Flask are arguably the
most popular web frameworks for Python and thankfully are a little more opinionated when it
comes to application layout. In order to make sure this article is a complete, full-fledged layout
reference, I wanted to highlight the structure common to these frameworks.

Django
Let’s go in alphabetical order and start with Django. One of the nice things about Django
is that it will create a project skeleton for you after running django-admin startproject
project, where project is the name of your project. This will create a directory in your current
working directory called project with the following internal structure:

There aren’t even any tests! In Django, which ties together the other Django concept,
apps. Apps are where logic, models, views, and so on all live, and in doing so they do some task,
such as maintaining a blog.Django apps can be imported into projects and used across projects,
and are structured like specialized Python packages.

Like projects, Django makes generating Django app layouts really easy. After you set up
your project, all you have to do is navigate to the location of manage.py and run python
manage.py startapp app, where app is the name of your app.

This will result in a directory called app with the following layout:

app/
│
├── migrations/
│ └── __init__.py
│
├── __init__.py
├── admin.py
├── apps.py
├── models.py
├── tests.py
└── views.py
 Details on what these files do, how to harness them for your project, and so forth are
outside the scope of this reference, but you can get all that information and more in our Django
tutorial and also in the official Django docs. This file and folder structure is very barebones and
the basic requirements for Django. For any open-source Django project, you can (and should)
adapt the structures from the command-line application layouts

For a deeper discussion on more advanced Django application layouts, this Stack

Overflow thread has you covered. The django-project-skeleton project documentation explains
some of the directories you will find in the Stack Overflow thread. A comprehensive dive into
Django can be found in the pages of Two Scoops of Django, which will teach you all of the latest
best practices for Django development.

Flask
Flask is a Python web “microframework.” One of the main selling points is that it is very
quick to set up with minimal overhead. The Flask documentation has a web application example
that’s under 10 lines of code and in a single script. Of course, in practice, it’s highly unlikely
you’ll be writing a web application this small. Luckily, the Flask documentation swoops in to
save us with a suggested layout for their tutorial project (a blogging web application called
Flaskr), and we will examine that here from within the main project directory:

GUI CONCEPTS
Event-driven programming
Anything that happens in a user interface is an event. An event is fired whenever the user
does something – for example, clicks on a button or types a keyboard shortcut. Some events
could also be triggered by occurrences which are not controlled by the user – for example, a
background task might complete, or a network connection might be established or lost. Our
application needs to monitor, or listen for, all the events that we find interesting, and respond to
them in some way if they occur. To do this, we usually associate certain functions with particular
events. It call a function which performs an action in response to an event an event handler –
we bind handlers to events.
Tkinter basics
Tkinter provides us with a variety of common GUI elements which it can use to build
our interface – such as buttons, menus and various kinds of entry fields and display areas. It call
these elements widgets. It constructs a tree of widgets for our GUI – each widget will have a
parent widget, all the way up to the root window of our application. For example, a button or a
text field needs to be inside some kind of containing window. The widget classes provide us with
a lot of default functionality. They have methods for configuring the GUI’s appearance – for
example, arranging the elements according to some kind of layout – and for handling various
kinds of user-driven events. Once It has constructed the backbone of our GUI, It will need to
customise it by integrating it with our internal application class.

SQL SERVER
SQL Server is Microsoft's relational database management system (RDBMS). It is a full-
featured database primarily designed to compete against competitors Oracle Database (DB) and
MySQL.
Like all major RBDMS, SQL Server supports ANSI SQL, the standard SQL language.
However, SQL Server also contains T-SQL, its own SQL implementation. SQL Server
Management Studio (SSMS) (previously known as Enterprise Manager) is SQL Server's main
interface tool, and it supports 32-bit and 64-bit environments.
SQL Server is sometimes referred to as MSSQL and Microsoft SQL Server.
SQL Server is offered in several editions with different feature set and pricing options to
meet a variety of user needs, including the following:
 Enterprise: Designed for large enterprises with complex data requirements, data
warehousing and Web-enabled databases. Has all the features of SQL Server, and its
license pricing is the most expensive.

 Standard: Targeted toward small and medium organizations. Also supports e-commerce
and data warehousing.

 Workgroup: For small organizations. No size or user limits and may be used as the
backend database for small Web servers or branch offices.
  Express: Free for distribution. Has the fewest number of features and limits database size
and users. May be used as a replacement for an Access database.

Microsoft offers SQL Server in four primary editions that provide different levels of the
bundled services. Two are available free of charge: a full-featured Developer edition for use in
database development and testing, and an Express edition that can be used to run small databases
with up to 10 GB of disk storage capacity. For larger applications, Microsoft sells an Enterprise
edition that includes all of SQL Server's features, as well as a Standard one with a partial feature
set and limits on the number of processor cores and memory sizes that users can configure in
their database servers.

SQL IS WIDELY POPULAR BECAUSE IT OFFERS THE FOLLOWING

ADVANTAGES
 Allows users to access data in the relational database management systems.

 Allows users to describe the data.

 Allows users to define the data in a database and manipulate that data.

 Allows to embed within other languages using SQL modules, libraries & pre-compilers.

 Allows users to create and drop databases and tables.

 Allows users to create view, stored procedure, functions in a database.

 Allows users to set permissions on tables, procedures and views.

A BRIEF HISTORY OF SQL

 1970 − Dr. Edgar F. "Ted" Codd of IBM is known as the father of relational databases.
He described a relational model for databases.

 1974 − Structured Query Language appeared.

 1978 − IBM worked to develop Codd's ideas and released a product named System/R.
  1986 − IBM developed the first prototype of relational database and standardized by
ANSI. The first relational database was released by Relational Software which later came
to be known as Oracle.

SQL PROCESS
When you are executing an SQL command for any RDBMS, the system determines the
best way to carry out your request and SQL engine figures out how to interpret the task.
There are various components included in this process.
These components are
 Query Dispatcher

 Optimization Engines

 Classic Query Engine

 SQL Query Engine, etc.

A classic query engine handles all the non-SQL queries, but a SQL query engine won't handle
logical files.
DATABASE MANAGEMENT TOOLS
SQL Server comes with a number of tools to help you with your database administration
and programming tasks.
Some typical database administration and programming tasks could include:
 Create & maintain databases

 Create & maintain tables

 Create & maintain other database objects such as stored procedures, views, etc

 Create & maintain and schedule data backups

 Replication (eg, create a copy of the database)

 Create & maintain users, roles, etc

 Optimization tasks
VERSIONS OF SQL SERVER
Between 1995 and 2016, Microsoft released 10 versions of SQL Server. Early versions
were aimed primarily at departmental and workgroup applications, but Microsoft expanded SQL
Server's capabilities in subsequent ones, turning it into an enterprise-class relational DBMS that
could compete with Oracle Database, DB2 and other rival platforms for high-end database uses.
Over the years, Microsoft has also incorporated various data management and  tools into SQL
Server, as well as functionality to support new technologies that emerged, including the web,
cloud computing and mobile devices.
DATABASE NORMALIZATION
Database normalization is the process of efficiently organizing data in a database. There are
two reasons of this normalization process
 Eliminating redundant data, for example, storing the same data in more than one table.

 Ensuring data dependencies make sense.

Both these reasons are worthy goals as they reduce the amount of space a database
consumes and ensures that data is logically stored. Normalization consists of a series of
guidelines that help guide you in creating a good database structure.
Normalization guidelines are divided into normal forms; think of a form as the format or
the way a database structure is laid out. The aim of normal forms is to organize the database
structure, so that it complies with the rules of first normal form, then second normal form and
finally the third normal form.
It is your choice to take it further and go to the fourth normal form, fifth normal form and
so on, but in general, the third normal form is more than enough.

USES OF DATABASES
TRADITIONAL USES:
 I Live Queries
 I Report Generation
 I Normalization, foreign keys, joins, etc.
NEWER USES:
 I Storage - data is extracted and analyzed in another
 Application
 I Backends to web sites

SOME RELATIONAL DATABASE CONCEPTS

 A database server can contain many databases
 Databases are collections of tables
 Tables are two-dimensional with rows (observations)
and columns (variables)
 Limited mathematical and summary operations available.
 Very good at combining information from several tables
 CHAPTER 4

SYSTEM DESIGN

INTRODUCTION

Systems design is the process of defining the architecture, modules,

interfaces, and data for a system to satisfy specified requirements. Systems design
could be seen as the application of systems theory to product development. There is
some overlap with the disciplines of systems analysis, systems architecture and
systems engineering.

4.1 DATA FLOW DIAGRAM

A data flow diagram (DFD) is a graphical representation of the "flow" of

data through an information system, modelling its process aspects. A DFD is often
used as a preliminary step to create an overview of the system without going into
great detail, which can later be elaborated. DFDs can also be used for the
visualization of data processing

A data flow diagram (DFD) maps out the flow of information for any
process or system. It uses defined symbols like rectangles, circles and arrows, plus
short text labels, to show data inputs, outputs, storage points and the routes between
each destination.

Data flowcharts can range from simple, even hand-drawn process overviews,
to in-depth, multi-level DFDs that dig progressively deeper into how the data is
handled. They can be used to analyze an existing system or model a new one. Like
all the best diagrams and charts, a DFD can often visually “say” things that would
be hard to explain in words, and they work for both technical and nontechnical
audiences, from developer to CEO.

That’s why DFDs remain so popular after all these years. While they work
well for data flow software and systems, they are less applicable nowadays to
visualizing interactive, real-time or database-oriented software or systems.
DATA FLOW DIAGRAM

Admin Add criminal and

crime registrations

View criminal and

crime registrations

Criminal report
Data Base

Change password

User Add and view

complaints

Add missing person

deails

Edit complaints

View complaint
status

Crime report

Edit account

Employee Authentication

Notifications
4.2 UML DIAGRAM

Unified Modeling Language (UML) is a standardized visual specification language

for object modeling. UML is a general-purpose modeling language that includes a graphical
notation used to create an abstract model of a system, referred to as a UML model.

ONLINE CRIME REPORTING SYSTEM

IN PYTHON

Home

Admin User Employee Register

Add criminal and Add and view Authentication

crime registrations complaints

View criminal and Add missing person Notification

crime registrations details

Criminal report Edit complaints Logout

Change password View complaint

status

Logout Logout
4.3 USE CASE DIAGRAM
Add criminal and crime registrations

View criminal and crime registrations

Criminal report

Admin Change password

Add and view complaints

Add missing person details

Edit complaints

View complaint status

Crime report User

Edit account

Authentication

Notifications

Employee
4.4 DATA BASE DESIGN

Register

Crime
Criminal

Case

Users
 CHAPTER 5
SYSTEM DEVELOPMENT

5.1 MODULES IDENTIFICATION:

 Home
 Admin
 User
 Employee
 Register
 About
5.2 MODULES DESCRIPTION

ADMIN:
This Module helps the admin to view and reply user’s complaints and crime details.
 Add Criminal and Crime registrations
 View Criminal and Crime registrations
 Criminal Report
 View Missing and Most wanted persons
 Change Password
 Logout
Add Criminal and Crime
The admin can add the details of the crime or the details about the criminal of any cases
filed.
View Criminal and Crime
The number of cases filed per day and the details of the cases can be viewed by the
admin.
Criminal Report
The admin will thoroughly review and evaluate the criminal details given by the user and
refer it to the appropriate crime branch/police station.
View Missing and Most wanted Persons
The admin can view the missing and most wanted person details uploaded by the user
and the employees. Here the admin can also edit the data.
Change Password
The password can be changed or modified by the admin in this module.
Logout
The Admin can logout his/her page with this module.

USER:
This module helps the user to report/register complaints in online.
  Add and View Complaints
 Add Missing Person
 Edit Complaint
 View Complaint Status
 Crime Report
 Edit Account
Add and View Complaints
The user can add detailed document about his complaint and he can also view the
complaints filed by him/her so far.
Add Missing Person
The System asks the user to enter all the details of the person with a photograph. The
system also allows the user to check the status his previous filed cases.
Edit Complaint
Complaints consist of basic details the system asks and the user has to fill in order to
register a complaint and check the status of his complaints.
View Complaint Status
The user can view his/her complaint status by this module at any anytime.
Crime Report
Crimes consist of all the details that the user has to fill in to register a complaint and
provide a picture, if he has one related to the crime, also can check the status of the crimes he has
filed.
Edit Account
The user can update his/her profile details in this module.

EMPLOYEE:
This Module helps the working Employee to view and access the registered complaints
by the user.
 Authentication
 Notification
Authentication
First the employee can check whether the complaints meets the authentication criteria or
not and then they will validate the complaints. So Admin, Headquarters and Users can enter the
application through login.
Notification
If the Status of the FIR(First Information Report) has been put on hold for the particular
period of time, the FIR Numbers whose status has not been modified should send as a
notification to the Higher Authority.
 CHAPTER 6
SYSTEM TEXTING
TESTING

Testing is a process of running software in an intention to find errors the software, which
has been developed, has to be tested to prove its validity. Testing is considered to be the least
creative phase of the whole cycle of system design. In the real sense it is the phase, which helps
to bring out the creativity of the phases.
Testing program is the first step in the debugging process. Some people idea of the testing a
program consists of running the program a few times to see what happens, each time using slightly
different input. This process can succeed when we have a short program, but it is not effective for a long
program. In any case, even for the simplest program the choice of test data is all-important.

A good testing suite is vital because the user must test all possible Execution paths inside
the code in order to have any hope it will be bug free. Testing program is an art, not a science.
Testing of the system is done to ensure the integrity of the system. Testing is vita for the success
of the project, which is the last stage of development. The aim of testing is to prove that the
development system addresses the predefined processing requirements and will perform reliably
and efficiently during time.
Testing is the process of creating a program with the explicit information of finding error
that makes a program fail. Successful test finds the error yet undiscovered. As an additional
benefit, testing demonstrates that a software function appear to be working according to the
specifications.

PURPOSES OF TESTING

 To affirm the quality of the project.

 To find and eliminate any errors from previous stages.
 To validate the software and to eliminate the operation.
 Reliability of the system.
TYPES OF TESTING

The software, which has been developed, has to be tested to prove its validity.
Testing is considered to be the least creative phase of the whole cycle of system design. In the
real sense it is the phase, which helps to bring out the creativity of the phases.
The “Time Assessment for molding of casting” was tested along the following
guidelines to prove its validity. It was tested using two techniques of software testing.

UNIT TESTING
In the lines of this strategy all the individual functions and modules were put to the
test independently. By following this strategy all the error in coding were identified and
corrected. This method was applied in combination with the white and Black box testing
techniques to find the errors in each module.

SYSTEM TESTING
The idea of applying this strategy was to put the system to a series of different test
whose primary purpose is to fully exercise the computer-based system. Although each test has a
different purpose, all work to verify that all system elements have been properly integrated and
perform allocated functions, security testing was conducted.

VALIDATION TESTING
The main aim of this testing is to verify that the software system does what it was
designed for Alpha testing and Beta testing were conducted to ensure the validity of the system.
A customer conducted the Alpha test at the developer’s site. The end user of the software
conducted the Beta test at one or more of the customer site
 CHAPTER 7
SYSTEM IMPLEMENTATION
SOURCE CODE

Crime\urls.py
from django.contribimport admin
from django.urlsimport path,include
from home import views
urlpatterns = [
path('',include('home.urls')),
path('adminlogin',views.adminlogin,name='adminlogin'),
path('userlogin',views.userlogin,name='userlogin'),
path('employeelogin',views.employeelogin,name='employeelogin'),
path('register1',views.register1,name='register1'),
path('addcriminal',views.addcriminal,name='addcriminal'),
path('addcrime',views.addcrime,name='addcrime'),
path('addcase',views.addcase,name='addcase'),
path('addusers',views.addusers,name='addusers'),
path('userreport',views.userreport,name='userreport'),
path('employeereport',views.employeereport,name='employeereport'),
path('criminalreport',views.criminalreport,name='criminalreport'),
path('caserport',views.casereport,name='casereport'),
path('changepassword',views.changepassword,name='changepassword'),
path('crimelists',views.crimelists,name='crimelists'),
path('mycase',views.mycase,name='mycase'),
path('addcase1',views.addcase1,name='addcase1'),
path('changepassword1',views.changepassword1,name='changepassword1'),
path('addcriminal2',views.addcriminal2,name='addcriminal2'),
path('addcrime2',views.addcrime2,name='addcrime2'),
path('addcase2',views.addcase2,name='addcase2'),
path('criminalreport2',views.criminalreport2,name='criminalreport2'),
path('caserport2',views.casereport2,name='casereport2'),
path('crimereport2',views.crimereport2,name='crimereport2'),
path('myacount',views.myaccount2,name='myaccount2'),
path('changepassword2',views.changepassword2,name='changepassword2'),
 path('admin/', admin.site.urls),
]
views.py
from django.shortcutsimport render
from django.contribimport messages
from home.formimport Studentform,Criminalform,Caseform,Crimeform,Usersform
from home.modelsimport register,case,crime,criminal,users
# Create your views here.
defhome(request):
return render(request,'homepage.html',{})
defadminlogin(request):
if request.method=="POST":
print(request.POST['t1'])
if request.POST['t1']=="admin":
if request.POST['t2']=="admin":
return render(request,'adminhome.html',{})
messages.info(request, 'Login Success')
else:
messages.info(request, 'Your Password is Wrong')
return render(request,'alogin.html',{})
else:
messages.info(request, 'Your Username is Wrong')
return render(request, 'alogin.html', {})
else:
return render(request, 'adminlogin.html', {})
defuserlogin(request):
if request.method=="POST":
name=request.POST['u11']
ab=register.objects.get(name=name)
if request.POST['u11']==ab.name:
if request.POST['u12']==ab.password:
return render(request, 'userhome.html', {})
messages.info(request, 'Login Success')
else:
 messages.info(request, 'Your Password is Wrong')
return render(request,'userlogin.html',{})
else:
messages.info(request, 'Your Username is Wrong')
return render(request, 'userlogin.html', {})
else:
return render(request, 'userlogin.html', {})
defemployeelogin(request):
if request.method=="POST":
name=request.POST['t1']
ab=register.objects.get(name=name)
if request.POST['t1']==ab.name:
if request.POST['t2']==ab.password:
request.session['name'] = name
return render(request, 'employeehome.html', {})
messages.info(request, 'Login Success')
else:
messages.info(request, 'Your Password is Wrong')
return render(request,'employeelogin.html',{})
else:
messages.info(request, 'Your Username is Wrong')
return render(request, 'employeelogin.html', {})
else:
return render(request, 'employeelogin.html', {})
defregister1(request):
if request.method=='POST':
form = Studentform(request.POST)
if form.is_valid():
form.save()
return render(request,'homepage.html',{})
else:
form=Studentform()
return render(request,'register.html',{'form':form})
defaddcriminal(request):
if request.method=='POST':
form = Criminalform(request.POST)
if form.is_valid():
form.save()
return render(request,'adminhome.html',{})
else:
form=Criminalform()
return render(request,'addcriminal.html',{'form':form})
defaddcrime(request):
if request.method=='POST':
form = Crimeform(request.POST)
if form.is_valid():
form.save()
return render(request,'adminhome.html',{})
else:
form=Crimeform()
return render(request,'addcrime.html',{'form':form})
defaddcase(request):
if request.method=='POST':
form = Caseform(request.POST)
if form.is_valid():
form.save()
return render(request,'adminhome.html',{})
else:
form=Caseform()
return render(request,'addcase.html',{'form':form})
defaddusers(request):
if request.method=='POST':
form =Usersform(request.POST)
if form.is_valid():
form.save()
return render(request,'adminhome.html',{})
else:
form=Usersform()
return render(request,'addusers.html',{'form':form})
defuserreport(request):
form= users.objects.all()
return render(request,'userreport.html',{'form':form})
defcasereport(request):
form= case.objects.all()
return render(request,'casereport.html',{'form':form})

defemployeereport(request):
form= users.objects.all()
return render(request,'employeereport.html',{'form':form})
defcriminalreport(request):
form= criminal.objects.all()
return render(request,'criminalreport.html',{'form':form})
defchangepassword(request):
if request.method=='POST':
name = request.POST['c1']
ab = users.objects.get(user_Name=name)
if(request.POST['c2']==ab.password):
p=request.POST['c3']
ab.password = p
ab.save()
return render(request,'changed.html',{})
else:
form=Usersform()
return render(request,'changepassword.html',{'form':form})
defcrimelists(request):
form= crime.objects.all()
return render(request,'crimelists.html',{'form':form})
defmycase(request):
form= case.objects.all()
return render(request,'mycase.html',{'form':form})
defaddcase1(request):
if request.method=='POST':
 form = Caseform(request.POST)
if form.is_valid():
form.save()
return render(request,'userhome.html',{})
else:
form=Caseform()
return render(request,'addcase1.html',{'form':form})
defchangepassword1(request):
if request.method=='POST':
name = request.POST['c1']
ab = register.objects.get(name=name)
if(request.POST['c2']==ab.password):
p=request.POST['c3']
ab.password = p
ab.save()
return render(request,'changed1.html',{})
else:
form=Usersform()
return render(request,'changepassword1.html',{'form':form})

defaddcriminal2(request):
if request.method=='POST':
form = Criminalform(request.POST)
if form.is_valid():
form.save()
return render(request,'employeehome.html',{})
else:
form=Criminalform()
return render(request,'addcriminal2.html',{'form':form})
defaddcrime2(request):
if request.method=='POST':
form = Crimeform(request.POST)
if form.is_valid():
form.save()
return render(request,'employeehome.html',{})
else:
form=Crimeform()
return render(request,'addcrime2.html',{'form':form})
defaddcase2(request):
if request.method=='POST':
form = Caseform(request.POST)
if form.is_valid():
form.save()
return render(request,'employeehome.html',{})
else:
form=Caseform()
return render(request,'addcase2.html',{'form':form})
defcasereport2(request):
form= case.objects.all()
return render(request,'casereport2.html',{'form':form})
defcrimereport2(request):
form= crime.objects.all()
return render(request,'crimereport2.html',{'form':form})
defcriminalreport2(request):
form= criminal.objects.all()
return render(request,'criminalreport2.html',{'form':form})
defmyaccount2(request):
name1 = request.session['name']
print(name1)
ab = register.objects.get(name='Arjun')
return render(request,'myaccount2.html',{'ab':ab})
defchangepassword2(request):
if request.method=='POST':
name = request.POST['c1']
ab = register.objects.get(name=name)
if(request.POST['c2']==ab.password):
p=request.POST['c3']
ab.password = p
ab.save()
return render(request,'changed2.html',{})
else:
form=Usersform()
return render(request,'changepassword2.html',{'form':form})
Models.py
fromdjango.dbimport models

# Create your models here.

class register(models.Model):
name = models.CharField(max_length=25)
age = models.CharField(max_length=3)
address = models.CharField(max_length=50)
mobile = models.CharField(max_length=10)
email = models.CharField(max_length=30)
password = models.CharField(max_length=25)
class Meta:
db_table='register'
class criminal(models.Model):
criminal_Name=models.CharField(max_length=30)
address=models.CharField(max_length=50)
city=models.CharField(max_length=20)
state=models.CharField(max_length=20)
country=models.CharField(max_length=20)
email=models.CharField(max_length=30)
mobile=models.CharField(max_length=10)
gender=models.CharField(max_length=10)
date_Of_Birth=models.CharField(max_length=20)
class Meta:
db_table='criminal'
class crime(models.Model):
criminal_Name=models.CharField(max_length=30)
crime_Title=models.CharField(max_length=30)
crime_Date=models.CharField(max_length=20)
 description=models.CharField(max_length=50)
class Meta:
db_table='crime'
class users(models.Model):
select_User_Role=models.CharField(max_length=10)
user_Name=models.CharField(max_length=30)
password=models.CharField(max_length=30)
mobile_no=models.CharField(max_length=10)
email=models.CharField(max_length=30)
city=models.CharField(max_length=30)
state=models.CharField(max_length=30)
country=models.CharField(max_length=30)
class case(models.Model):
case_Title=models.CharField(max_length=30)
case_Date=models.CharField(max_length=20)
description=models.CharField(max_length=50)
Form.py
from djangoimport forms
from django.contrib.auth.formsimport UserCreationForm
from django.contrib.auth.modelsimport User
from home.modelsimport register,criminal,crime,case,users
class Studentform(forms.ModelForm):
class Meta:
model=register
fields="__all__"
class Criminalform(forms.ModelForm):
class Meta:
model=criminal
fields="__all__"
class Crimeform(forms.ModelForm):
class Meta:
model=crime
fields="__all__"
class Caseform(forms.ModelForm):
class Meta:
model=case
fields="__all__"
class Usersform(forms.ModelForm):
class Meta:
model=users
fields="__all__"
Homepage.html
{% extends 'base.html' %}
{% load static %}
{% block title %}
<body bgcolor="#F4A460">
<font size=18 family="Times New Roman" color="#800000"><center>
ONLINE CRIME REPORTING SYSTEM
</center>
</font>
</body>
{% endblock title %}

{% block content %}
{% include 'navbar.html' %}
<br><br><br>
<p align="justify" style="background-image: linear-gradient(to top, rgba(255,0,0,0), rgb(153, 187, 255));
">
<h1></h1></p>
<p align="justify" style="background-image: linear-gradient(to top, rgba(255,0,0,0), #F4A460));">
<font size="5" style=face="Arial"; >
</font>
<imgsrc="{% static '5.jpg' %}" width="1450" height="200">
<marquee behavior="alternate">
<imgsrc="{% static '1.jpg' %}" width="400" height="300">
<imgsrc="{% static '4.jpg' %}" width="400" height="300">
<imgsrc="{% static '3.jpg' %}" width="400" height="300">
</marquee>
</p>
{% endblock content %}
Register.html
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://www.w3schools.com/w3css/4/w3.css">
</head>
<body style="background-image: linear-gradient(to top, rgba(255,0,0,0), #F4A460);">
<font size=12 family="Times New Roman" color="#800000"><center>
ONLINE CRIME REPORTING SYSTEM
</center>
</font>
{% include 'navbar.html' %}
<div style="margin-top:80px; width:900px; margin:80px auto;">
<form method="post" action="register1">
<center>
{% csrf_token %}
<table style="background-image: linear-gradient(to top, rgba(255,0,0,0),
#F4A460);"><thcolspan="2"><h1>Register Form</h1></th>
{% for field in form %}
<tr>
<td><h3><label for="{{ field.name}}">{{ field.label}}</label></h3></td><td>{{ field }}</td>
</tr>
{% endfor %}
<thcolspan="2"><button class="w3-button w3-blue" type="submit">Sign Up</button></th>
</table>
</center>
</form>
</div>
</body>
</html>
Setting.py
frompathlibimport Path
import os
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.1/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '&h4e)+0lx#+pw&bps8(gdbx7qey%d^qd__1woa*#k0*q3pg365'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'home',
'crispy_forms',
]

MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'crime.urls'
TEMPLATES = [
 {
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR,'template')],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'crime.wsgi.application'
# Database
# https://docs.djangoproject.com/en/3.1/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.mysql',
'NAME': 'crime',
'USER': 'root',
'PASSWORD': '',
'HOST': '127.0.0.1',
'PORT': '3306',
'OPTION': {'init_command':"SETsql_mode='STRICT_TRANS_TABLE',"},
}
}
# Password validation
# https://docs.djangoproject.com/en/3.1/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
 {
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.1/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.1/howto/static-files/
STATIC_URL = '/static/'
STATIC_ROOT=os.path.join(BASE_DIR,'assets')
STATICFILES_DIRS=[os.path.join(BASE_DIR,'static')]
 CHAPTER 8
RESULT AND DISCUSSION

HOME PAGE
ADMIN LOGIN
ADD CRIMINAL
ADD CRIME
ADD CASE
ADD USERS
USER REPORT
EMPLOYEE REPORT
CRIMINAL REPORT
CASE REPORT
CHANGE PASSWORD
USER LOGIN
CRIME LIST
MY CASE
ADD CASE
CHANGE PASSWORD
EMPLOYEE LOGIN
ADD CRIMINAL
ADD CRIME
ADD CASE
CRIMINAL REPORT
CASE REPORT
CRIME REPORT
MY ACCOUNT
CHANGE PASSWORD
REGISTER
 CHAPTER 9
SYSTEM MAINTENANCE
INTRODUCTION

System maintenance is an ongoing activity, which covers a wide variety of activities,

including removing program and design errors, updating documentation and test data and
updating user support. For the purpose of convenience, maintenance may be categorized into
three classes, namely:

i)Corrective Maintenance: This type of maintenance implies removing errors in a program,

which might have crept in the system due to faulty design or wrong assumptions. Thus, in
corrective maintenance, processing or performance failures are repaired.

ii)Adaptive Maintenance: In adaptive maintenance, program functions are changed to enable

the information system to satisfy the information needs of the user. This type of maintenance
may become necessary because of organizational changes which may include:
a) Change in the organizational procedures,
b) Change in organizational objectives, goals, policies, etc.
c) Change in forms,
d) Change in information needs of managers.
e) Change in system controls and security needs, etc.

iii)Perfective Maintenance: Perfective maintenance means adding new programs or modifying

the existing programs to enhance the performance of the information system. This type of
maintenance undertaken to respond to user’s additional needs which may be due to the changes
within or outside of the organization. Outside changes are primarily environmental changes,
which may in the absence of system maintenance, render the information system ineffective and
inefficient. These environmental changes include:
a) Changes in governmental policies, laws, etc.,
b) Economic and competitive conditions, and
c) New technology.
 CHAPTER 10

CONCLUSION

The Online Crime Reporting System is a web application system which is too much
helpful for all the common people, government organization and different societies. This is based
on a very simple and non-complex approach. This has been created as a safety measure for all
section of people and societies. Anything which is against the law or anyone who is violating the
law will now have some fear as now filing an FIR is much easier than it was before. The Online
Crime Reporting System is a success with satisfaction from both the people and government
organizations. This has been tested and is a success. So, this make it much more efficient.
 REFERENCE

[1]. Fensterstock, A. (2005), Credit scoring and the next step, Business Credit 107(3) 46-49.
[2]. Lee, T. S., Chiu, C.C., Chou, Y.C., Lu, C.J., (2006), Mining the customer credit using
classification and regression tree and multivariate adaptive regression splines,
Computational Statistics & Data Analysis 50 1113 – 1130
[3]. Leonard, K.J. (1995), The development of credit scoring quality measures for consumer
credit applications, International Journal of Quality and Reliability Management 12(4)
79-85.
[4]. Mester, L.J. (1997). What’s the point of credit scoring?, Business Review (September) 3-
16.
[5]. Rimmer, J. (2005), Contemporary changes in credit scoring, Credit Control 26(4) 56-60.
[6]. Wendel, C., și M. Harvey. (2003), Credit scoring: Best practices and approaches,
Commercial Lending Review 18(3) 4-7
[7]. Yobas, M.B, Crook, J.N., and Ross, P. (2000), Credit scoring using neural and
evolutionary techniques, IMA Journal of Mathematics applied in business and industry
11, 111-125.
[8]. J. Haywood Rolling Jr., ―Art + design practice as Global Positioning System,‖ Art Ed.,
vol. 70, no. 6, pp. 4-6, 2017. doi:10.1080/00043125.2017.1361756
[9]. X. Zhao, ―Road network and GPS tracking with data processing and quality
assessment,‖ [thesis], Dalarna University, Sweden, 2015. ISBN: 978-91-89020-92-4
[10]. B. Wukkadada and A. Fernandes, ―Vehicle tracking system using GSM and GPS

technologies,‖ IOSR J. of Comp. Eng., pp. 05-08, August 2005.

http://www.iosrjournals.org/iosr-jce/pages/Conf-16055-vol-1.htm