TABLE OF CONTENTS

1. INTRODUCTION---------------------------------------------------------------*
2. ANALYSIS----------------------------------------------------------------------
**
2.1 EXISTING SYSTEM--------------------------------------------**
2.2 PROPOSED SYSTEM------------------------------------**
2.3 SYSTEM CONFIGURATION -----------------------------**

3. FEASIBILITY STUDY-------------------------------------------------------
**
3.1 TECHNICAL FEASIBILITY------------------------------------
**
3.2 ECONOMICAL FEASIBILITY---------------------------------
**
3.3 OPERATIONAL FEASIBILITY--------------------------------
**
4. DESIGN APPROACH-----------------------------------------------------**
4.1 INTRODUCTION TO DESIGN -------------------------------**
4.2 UML DIAGRAMS----------------------------------------------- **
4.3 DATA FLOW DIAGRAMS-------------------------------------**
4.4 E-R DIAGRAMS-------------------------------------------------**
5. PROJECT MODULES----------------------------------------------------**
6. IMPLEMENTATION-----------------------------------------------------**
6.1 CONCEPTS AND TECHNIQUES----------------------------**
7. TESTING--------------------------------------------------------------------**
7.1 TEST CASES-----------------------------------------------------**
8. SOURCE CODE------------------------------------------------------------**
9. OUTPUT SCREENS ------------------------------------------------------**
10. CONCLUSION------------------------------------------------------------**
11. FUTURE ENHANCEMENTS------------------------------------------**
12. BIBILIOGRAPHY--------------------------------------------------------**
INTRODUCTION

Online Event management system was web-based application that

enhanced project management to the creation and development of large
scale events such as festivals, conferences, ceremonies, weddings,
formal parties, concerts, or conventions. It involved studying the brand,
identifying its target audience, devising the event concept, and
coordinating the technical aspects before actually launching the event.
The Online Event management system (OEMS) enabled customers/
clients view various packages/products about the event and make
booking through the online platform. The process of planing and
coordinating the event is usually referred to as event planing and it
included budgeting, scheduling, site selection, acquiring necessary permits
and emergency plans. Each event was different in its nature so process
of planning & execution of each event differed on basis of type of event.
The system allows customers to send complaints and feedback and
generate transaction reports. The system allows the printing of transaction
reports and also sending notifications to the manager for approving
payments. One of the advantages of Fruitions Event Planners is
Reducing workload If you don't already use an online event management
system then chances are you spend most of your day tackling a mountain
of paperwork. From mailed in ( and frequently illegible) registration fonns
 needing to be entered onto your spreadsheet to invoices and confirmation
letters that need to be sent out, the paperwork seems never ending.

2.SYSTEM ANALYSIS

System analysis is for finding out what happens in existing

system deciding on what changes and new features are required and
defining exactly what the proposed system must be. The process of system
analysis is largely concerned with determining, developing and agreeing to
the user’s requirements. It provides prime opportunity to communicate
well with the user and conceive a joint understanding of what a system
should be doing together with a view of relative importance of the system
facilities using interactive techniques.

2.1 EXISTING SYSTEM

Currently Event Management system is manual and

only accessible to staff. The client has to travel to the company
offices in order to schedule, book and organize an event such as
Birthday Party, Marriage, Reception, Ring Ceremony. Clients pay
cash to book for an event which is inconveniencing when customers are
many at the company. It takes lots of time of customer because they
have to search such event organizer and contact them individually so
an online event management system is needed which will enable the
customer make booking, schedule events online at any preferred time

2.2 PROPOSED SYSTEM

The system will be beneficial in the following ways:
The company will be able to send notification to clients regarding status
of their events through email or short message system Customized alerts to
customers upon cancelled events Detailed event billing platform on various
products and packages Display view of Discounts detail on various products
Easy access to various event packages. Online payment platform which is fast
and secure Feedback to event manager has been made easy. Just send the email
to the service provider, quick secure and responsive The clients time lost
during the travelling to and fro the company to make reservation has been
solved. Thus creating ample time for the client to manage and schedule
events. Customers will have a data backup of their events stored to the
database for future reference.

2.3 SYSTEM CONFIGURATION

HARDWARE CONFIGURATION:

Processor - Inter i3
Memory - 512 MB RAM
Keyboard - 105 Keys
Monitor - CRT or LCD
Mouse - USB mouse or PS/2 mouse

SOFTWARE SPECIFICATION:
Operating System : Windows XP/NT,
Front End : HTML, CSS, JavaScript
Back End : DJANGO
Documentation : MS Word

3. FEASIBILITY STUDY:

Feasibility study is conducted once the problem is clearly

understood. Feasibility study is a high level capsule version of the entire system
analysis and design process. The objective is to determine quickly at a
minimum expense how to solve a problem. The purpose of feasibility is not to
solve the problem but to determine if the problem is worth solving.

The system has been tested for feasibility in the following points.
1. Technical Feasibility
2. Economical Feasibility
3. Operational Feasibility.

1. Technical Feasibility

The project entitles "Event Management System” is technically

feasibility because of the below mentioned feature. The project was developed
in Java which Graphical User Interface.
It provides the high level of reliability, availability and
compatibility. All these make Django an appropriate language for this
project. Thus the existing software Django is a powerful language.

2. Economical Feasibility

The computerized system will help in automate the

selection leading the profits and details of the organization. With this software,
the machine and manpower utilization are expected to go up by 80-90%
approximately. The costs incurred of not creating the system are set to be great,
because precious time can be wanted by manually.

3. Operational Feasibility

In this project, the management will know the

details of each project where he may be presented and the data will be
maintained as decentralized and if any inquires for that particular contract can
be known as per their requirements and necessaries.

4. DESIGN AND DEVELOPMENT

Software design sits at the technical kernel of the software engineering

process and is applied regardless of the development paradigm and area of
application. Design is the first step in the development phase for any engineered
product or system. The designer’s goal is to produce a model or representation
of an entity that will later be built. Beginning, once system requirement have
been specified and analyzed, system design is the first of the three technical
activities -design, code and test that is required to build and verify software.

The importance can be stated with a single word “Quality”. Design is the
place where quality is fostered in software development. Design provides us
with representations of software that can assess for quality. Design is the only
way that we can accurately translate a customer’s view into a finished software
product or system. Software design serves as a foundation for all the software
engineering steps that follow. Without a strong design we risk building an
unstable system – one that will be difficult to test, one whose quality cannot be
assessed until the last stage. The purpose of the design phase is to plan a
solution of the problem specified by the requirement document. This phase is
the first step in moving from the problem domain to the solution domain. In
other words, starting with what is needed, design takes us toward how to satisfy
the needs. The design of a system is perhaps the most critical factor affection
the quality of the software; it has a major impact on the later phase, particularly
testing, maintenance. The output of this phase is the design document. This
document is similar to a blueprint for the solution and is used later during
implementation, testing and maintenance. The design activity is often divided
into two separate phases System Design and Detailed Design.
System Design also called top-level design aims to identify the modules
that should be in the system, the specifications of these modules, and how
they interact with each other to produce the desired results. At the end of
the system design all the major data structures, file formats, output formats,
and the major modules in the system and their specifications are decided.
During, Detailed Design, the internal logic of each of the modules specified
in system design is decided. During this phase, the details of the data of a
module is usually specified in a high-level design description language,
which is independent of the target language in which the software will
eventually be implemented.
In system design the focus is on identifying the modules, whereas during
detailed design the focus is on designing the logic for each of the modules.
In other works, in system design the attention is on what components are
needed, while in detailed design how the components can be implemented
in software is the issue.
 Design is concerned with identifying software components specifying
relationships among components. Specifying software structure and
providing blue print for the document phase. Modularity is one of the
desirable properties of large systems. It implies that the system is divided
into several parts. In such a manner, the interaction between parts is
minimal clearly specified.
During the system design activities, Developers bridge the gap between the
requirements specification, produced during requirements elicitation and
analysis, and the system that is delivered to the user.
Design is the place where the quality is fostered in development. Software
design is a process through which requirements are translated into a
representation of software.

4.2 Data Flow Diagrams:

A graphical tool used to describe and analyze the moment of data through a system manual or
automated including the process, stores of data, and delays in the system. Data Flow
Diagrams are the central tool and the basis from which other components are developed.
The transformation of data from input to output, through processes, may be described
logically and independently of the physical components associated with the system. The
DFD is also know as a data flow graph or a bubble chart.
DFDs are the model of the proposed system. They clearly should show the requirements on
which the new system should be built. Later during design activity this is taken as the
basis for drawing the system’s structure charts. The Basic Notation used to create a
DFD’s are as follows:

1. Dataflow: Data move in a specific direction from an origin to a destination.

2. Process: People, procedures, or devices that use or produce (Transform) Data. The
physical component is not identified.

3. Source: External sources or destination of data, which may be People, programs,

organizations or other entities.
4. Data Store: Here data are stored or referenced by a process in the System.

What is a UML Class Diagram?

Class diagrams are the backbone of almost every object-oriented method
including UML. They describe the static structure of a system.
Basic Class Diagram Symbols and Notations
Classes represent an abstraction of entities with common characteristics.
Associations represent the relationships between classes.
Illustrate classes with rectangles divided into compartments. Place the name of
the class in the first partition (centered, bolded, and capitalized), list the
attributes in the second partition, and write operations into the third.

Active Class
Active classes initiate and control the flow of activity, while passive classes
store data and serve other classes. Illustrate active classes with a thicker
border.

Visibility
Use visibility markers to signify who can access the information contained
within a class. Private visibility hides information from anything outside the
class partition. Public visibility allows all other classes to view the marked
information. Protected visibility allows child classes to access information
they inherited from a parent class. .
Associations
Associations represent static relationships between classes. Place association
names above, on, or below the association line. Use a filled arrow to
indicate the direction of the relationship. Place roles near the end of an
association. Roles represent the way the two classes see each other.
Note: It's uncommon to name both the association and the class roles.

Multiplicity (Cardinality)
Place multiplicity notations near the ends of an association. These symbols
indicate the number of instances of one class linked to one instance of the
other class. For example, one company will have one or more employees,
but each employee works for one company only.

Constraint
Place constraints inside curly braces {}.
 Simple Constraint
Composition and Aggregation
Composition is a special type of aggregation that denotes a strong ownership
between Class A, the whole, and Class B, its part. Illustrate composition
with a filled diamond. Use a hollow diamond to represent a simple
aggregation relationship, in which the "whole" class plays a more important
role than the "part" class, but the two classes are not dependent on each
other. The diamond end in both a composition and aggregation relationship
points toward the "whole" class or the aggregate

Generalization
Generalization is another name for inheritance or an "is a" relationship. It refers
to a relationship between two classes where one class is a specialized
version of another. For example, Honda is a type of car. So the class Honda
would have a generalization relationship with the class car.
In real life coding examples, the difference between inheritance and aggregation
can be confusing. If you have an aggregation relationship, the aggregate (the
whole) can access only the PUBLIC functions of the part class. On the other
hand, inheritance allows the inheriting class to access both the PUBLIC and
PROTECTED functions of the super class.
What is a UML Use Case Diagram?
Use case diagrams model the functionality of a system using actors and use
cases. Use cases are services or functions provided by the system to its
users.
Basic Use Case Diagram Symbols and Notations

System
Draw your system's boundaries using a rectangle that contains use cases. Place
actors outside the system's boundaries.

Use Case
Draw use cases using ovals. Label with ovals with verbs that represent the
system's functions.

Actors
Actors are the users of a system. When one system is the actor of another
system, label the actor system with the actor stereotype.
Relationships
Illustrate relationships between an actor and a use case with a simple line. For
relationships among use cases, use arrows labeled either "uses" or
"extends." A "uses" relationship indicates that one use case is needed by
another in order to perform a task. An "extends" relationship indicates
alternative options under a certain use case.

Sequence Diagram
Sequence diagrams describe interactions among classes in terms of an exchange
of messages over time.
Basic Sequence Diagram Symbols and Notations
Class roles
Class roles describe the way an object will behave in context. Use the UML
object symbol to illustrate class roles, but don't list object attributes.
Activation
Activation boxes represent the time an object needs to complete a task.

Messages
Messages are arrows that represent communication between objects. Use half-
arrowed lines to represent asynchronous messages. Asynchronous messages
are sent from an object that will not wait for a response from the receiver
before continuing its tasks.

Various message types for Sequence and Collaboration diagrams

Lifelines
Lifelines are vertical dashed lines that indicate the object's presence over time.
Destroying Objects
Objects can be terminated early using an arrow labeled "<< destroy >>" that
points to an X.

Loops
A repetition or loop within a sequence diagram is depicted as a rectangle. Place
the condition for exiting the loop at the bottom left corner in square brackets
[ ].
Collaboration Diagram
A collaboration diagram describes interactions among objects in terms of
sequenced messages. Collaboration diagrams represent a combination of
information taken from class, sequence, and use case diagrams describing
both the static structure and dynamic behavior of a system.

Basic Collaboration Diagram Symbols and Notations

Class roles
Class roles describe how objects behave. Use the UML object symbol to
illustrate class roles, but don't list object attributes.

Association roles
Association roles describe how an association will behave given a particular
situation. You can draw association roles using simple lines labeled with
stereotypes.

Messages
Unlike sequence diagrams, collaboration diagrams do not have an explicit way
to denote time and instead number messages in order of execution.
Sequence numbering can become nested using the Dewey decimal system.
For example, nested messages under the first message are labeled 1.1, 1.2,
1.3, and so on. The a condition for a message is usually placed in square
brackets immediately following the sequence number. Use a * after the
sequence number to indicate a loop.
Learn how to add arrows to your lines.
Activity Diagram
An activity diagram illustrates the dynamic nature of a system by modeling the
flow of control from activity to activity. An activity represents an operation
on some class in the system that results in a change in the state of the
system. Typically, activity diagrams are used to model workflow or
business processes and internal operation. Because an activity diagram is a
special kind of state chart diagram, it uses some of the same modeling
conventions.

Basic Activity Diagram Symbols and Notations

Action states
Action states represent the non interruptible actions of objects. You can draw an
action state in Smart Draw using a rectangle with rounded corners.

Action Flow
Action flow arrows illustrate the relationships among action states.

Object Flow
Object flow refers to the creation and modification of objects by activities. An
object flow arrow from an action to an object means that the action creates
or influences the object. An object flow arrow from an object to an action
indicates that the action state uses the object.
Initial State
A filled circle followed by an arrow represents the initial action state.

Final State
An arrow pointing to a filled circle nested inside another circle represents the
final action state.

Branching
A diamond represents a decision with alternate paths. The outgoing alternates
should be labeled with a condition or guard expression. You can also label
one of the paths "else."

Synchronization
A synchronization bar helps illustrate parallel transitions. Synchronization is
also called forking and joining.

Swimlanes
Swimlanes group related activities into one column.
 State chart Diagram
A state chart diagram shows the behavior of classes in response to external
stimuli. This diagram models the dynamic flow of control from state to state
within a system.
Basic State chart Diagram Symbols and Notations
States
States represent situations during the life of an object. You can easily illustrate a
state in Smart Draw by using a rectangle with rounded corners.

Transition
A solid arrow represents the path between different states of an object. Label the
transition with the event that triggered it and the action that results from it.

Initial State
A filled circle followed by an arrow represents the object's initial state.

Final State
An arrow pointing to a filled circle nested inside another circle represents the
object's final state.

Synchronization and Splitting of Control

A short heavy bar with two transitions entering it represents a synchronization
of control. A short heavy bar with two transitions leaving it represents a
splitting of control that creates multiple states.

STATE CHART DIAGRAM:

What is a UML Component Diagram?
A component diagram describes the organization of the physical components in
a system.
Basic Component Diagram Symbols and Notations

Component
A component is a physical building block of the system. It is represented as a
rectangle with tabs.
Learn how to resize grouped objects like components.

Interface
An interface describes a group of operations used or created by components.

Dependencies
Draw dependencies among components using dashed arrows.
Learn about line styles in SmartDraw.
COMPONENT DIAGRAM:
What is a UML Deployment Diagram?
Deployment diagrams depict the physical resources in a system including
nodes, components, and connections.
Basic Deployment Diagram Symbols and Notations
Component
A node is a physical resource that executes code components.
Learn how to resize grouped objects like nodes.

Association
Association refers to a physical connection between nodes, such as Ethernet.
Learn how to connect two nodes.

Components and Nodes

Place components inside the node that deploys them.
Class Diagram
Use Case Diagram

Activity Diagram
Sequence Diagram
5. Project Modules

The system will provide the following functionalities;

o User registration: The system allows new users to register online and
provide registration form.
o User login: The system will allow user to login through its first page.
o Online reservation of services ( event scheduled): Customers will be able to
use the system to make booking, schedule events online.
o Event Creation : Managers can create events and schedule the events
according their schedule
o Customer complaints and feedback: The system will allow customers to
send
complaints and feedback.
o Report generation: The system will generate transaction reports.
o Report printing: The system will allow the printing of transaction reports
o Online Payments Approval: The system will send notifications to the
manager
for approving payments.
6. IMPLIMENTATION:

6.1 CONCEPTS AND TECHNIQUES:

PHP

PHP: Hypertext Preprocessor, is a widely used, general-purpose

scripting language that was originally designed for web development, to
produce dynamic web pages. It can be embedded into HTML and generally
runs on a web server, which needs to be configured to process PHP code and
create web page content from it. It can be deployed on most web servers and on
almost every operating system and platform free of charge.
PHP was originally created by Rasmus Lerdorf in 1995 and has been in
continuous development ever since. The main implementation of PHP is now
produced by The PHP Group and serves as the de facto standard for PHP as
there is no formal specification.PHP is free software released under the PHP
License, which is incompatible with the GNU General Public License (GPL)
because of restrictions on the use of the term PHP
PHP has evolved to include a command line interface capability and
can also be used in standalone graphical applications.

USAGE

PHP is a general-purpose scripting language that is especially suited

for web development. PHP generally runs on a web server. Any PHP code in a
requested file is executed by the PHP runtime, usually to create dynamic web
page content. It can also be used for command-line scripting and client-side
GUI applications. PHP can be deployed on most web servers, many operating
systems and platforms, and can be used with many relational database
management systems. It is available free of charge, and the PHP Group provides
the complete source code for users to build, customize and extend for their own
use.
PHP primarily acts as a filter, taking input from a file or stream
containing text and/or PHP instructions and outputs another stream of data;
most commonly the output will be HTML. Since PHP 4, the PHP parser
compiles input to produce byte code for processing by the Zend Engine, giving
improved performance over its interpreter predecessor
 Originally designed to create dynamic web pages, PHP now focuses
mainly on server-side scripting, and it is similar to other server-side scripting
languages that provide dynamic content from a web server to a client, such as
Microsoft's Active Server Pages, Sun Microsystems' JavaServer Pages and
mod_perl. PHP has also attracted the development of many frameworks that
provide building blocks and a design structure to promote rapid application
development (RAD). Some of these include CakePHP, Symfony, CodeIgniter,
and Zend Framework, offering features similar to other web application
frameworks.

HTML

HTML, which stands for Hyper Text Markup Language, is the

predominant markup language for web pages. It provides a means to create
structured documents by denoting structural semantics for text such as headings,
paragraphs, lists etc as well as for links, quotes, and other items. It allows
images and objects to be embedded and can be used to create interactive forms.
It is written in the form of HTML elements consisting of "tags" surrounded by
angle brackets within the web page content. It can include or can load scripts in
languages such as JavaScript which affect the behavior of HTML processors
like Web browsers; and Cascading Style Sheets (CSS) to define the appearance
and layout of text and other material. The W3C, maintainer of both HTML and
CSS standards, encourages the use of CSS over explicit presentational markup.

Hyper Text Markup Language(HTML) is the encoding scheme used

to create and format a web document. A user need not be an expert programmer
to make use of HTML for creating hypertext documents that can be put on the
internet.
Most graphical e-mail clients allow the use of a subset of HTML (often ill-
defined) to provide formatting and semantic markup not available with plain
text. This may include typographic information like coloured headings,
emphasized and quoted text, inline images and diagrams. Many such clients
include both a GUI editor for composing HTML e-mail messages and a
rendering engine for displaying them. Use of HTML in e-mail is controversial
because of compatibility issues, because it can help disguise phishing attacks,
because it can confuse spam filters and because the message size is larger than
plain text.

NAMING CONVENTION

The most common filename extension for files containing HTML

is .html. A common abbreviation of this is .htm, which originated because some
early operating systems and file systems, such as DOS and FAT, limited file
extensions to three letters.

HTML APPLICATION

An HTML Application is a Microsoft Windows application that uses

HTML and Dynamic HTML in a browser to provide the application's graphical
interface. A regular HTML file is confined to the security model of the web
browser, communicating only to web servers and manipulating only webpage
objects and site cookies. An HTA runs as a fully trusted application and
therefore has more privileges, like creation/editing/removal of files and
Windows Registry entries. Because they operate outside the browser's security
model, HTAs cannot be executed via HTTP, but must be downloaded (just like
an EXE file) and executed from local file system

ABOUT JAVASCRIPT

JavaScript is an object-oriented scripting language used to enable

programmatic access to objects within both the client application and other
applications. It is primarily used in the form of client-side JavaScript,
implemented as an integrated component of the web browser, allowing the
development of enhanced user interfaces and dynamic websites. JavaScript is a
dialect of the ECMAScript standard and is characterized as a dynamic, weakly
typed, prototype-based language with first-class functions. JavaScript was
influenced by many languages and was designed to look like Java, but to be
easier for non-programmers to work with.

PROTOTYPE-BASED
 JavaScript uses prototypes instead of classes for inheritance. It is
possible to simulate many class-based features with prototypes in JavaScript.
Functions double as object constructors along with their typical role.
Prefixing a function call with new creates a new object and calls that function
with its local this keyword bound to that object for that invocation. The
constructor's prototype property determines the object used for the new object's
internal prototype. JavaScript's built-in constructors, such as Array, also have
prototypes that can be modified.
Unlike many object-oriented languages, there is no distinction between a
function definition and a method definition. Rather, the distinction occurs
during function calling; a function can be called as a method. When a function
is called as a method of an object, the function's local this keyword is bound to
that object for that invocation.

USAGE

The primary use of JavaScript is to write functions that are embedded in

or included from HTML pages and interact with the Document Object Model
(DOM) of the page.
Because JavaScript code can run locally in a user's browser (rather than
on a remote server) it can respond to user actions quickly, making an
application feel more responsive. Furthermore, JavaScript code can detect user
actions which HTML alone cannot, such as individual keystrokes. Applications
such as Gmail take advantage of this: much of the user-interface logic is written
in JavaScript, and JavaScript dispatches requests for information (such as the
content of an e-mail message) to the server. The wider trend of Ajax
programming similarly exploits this strength.
A JavaScript engine (also known as JavaScript interpreter or
JavaScript implementation) is an interpreter that interprets JavaScript source
code and executes the script accordingly. The first JavaScript engine was
created by Brendan Eich at Netscape Communications Corporation, for the
Netscape Navigator web browser. A web browser is by far the most common
host environment for JavaScript. Web browsers typically use the public API to
create "host objects" responsible for reflecting the DOM into JavaScript.

ABOUT MySQL

MySQL Introduction
There are a large number of database management systems currently
available, some commercial and some free.
Some of them : Oracle, Microsoft Access, Mysql and PostgreSQL.
These database systems are powerful, feature-rich software, capable of
organizing and searching millions of records at very high speeds.

Understanding Databases, Records, and Primary Keys

Every Database is composed of one or more tables.

These Tables, which structure data into rows and columns, Impose organization
on the data.
The records in a table(below) are not arranged in any particular order.
To make it easy to identify a specific record, therefore, it becomes necessary

standing Relationships and Foreign Keys(RDBMS)

You already know that a single database can hold multiple tables.
In a Relational database management system(RDBMS), these tables can be
linked to each other by one or more common fields, called foreign keys.

What is Database administrator(DBA) ?

Database administrator is the super user of database, he has

unrestricted rights and privileges to access database, grant permission to other
database users.

What is Database user(DBU) ?

 Database user is the person who uses the database in a restricted
privileges, provided by database administrator.

Download MySQL Database

If you have installed PHP’s WAMP or XAMPP server, then mysql

database already exists. if you don’t have then download mysql database from
herehttp://www.mysql.com

Implementation:

Implementation is the stage where the theoretical design is turned into a

working system. The most crucial stage in achieving a new successful system
and in giving confidence on the new system for the users that it will work
efficiently and effectively.

The system can be implemented only after thorough testing is done and if it is
found to work according to the specification.

It involves careful planning, investigation of the current system and its

constraints on implementation, design of methods to achieve the change over
and an evaluation of change over methods a part from planning. Two major
tasks of preparing the implementation are education and training of the users
and testing of the system.

The more complex the system being implemented, the more involved will
be the systems analysis and design effort required just for implementation.

The implementation phase comprises of several activities. The required

hardware and software acquisition is carried out. The system may require some
software to be developed. For this, programs are written and tested. The user
then changes over to his new fully tested system and the old system is
discontinued.
Maintenance and environment:

AS the number of computer based systems, grieve libraries of computer

software began to expand. In house developed projects produced tones of
thousand soft program source statements. Software products purchased from the
outside added hundreds of thousands of new statements. A dark cloud appeared
on the horizon. All of these programs, all of those source statements-had to be
corrected when false were detected, modified as user requirements changed, or
adapted to new hardware that was purchased. These activities were collectively
called software Maintenance.
The maintenance phase focuses on change that is associated with error
correction, adaptations required as the software's environment evolves, and
changes due to enhancements brought about by changing customer
requirements. Four types of changes are encountered during the maintenance
phase.

Correction
Adaptation
Enhancement
Prevention

Correction:

Even with the best quality assurance activities is lightly that the
customer will uncover defects in the software. Corrective maintenance
changes the software to correct defects.

Maintenance is a set of software Engineering activities that occur

after software has been delivered to the customer and put into operation.
Software configuration management is a set of tracking and control
activities that began when a software project begins and terminates only
when the software is taken out of the operation.
 We may define maintenance by describing four activities that are
undertaken after a program is released for use:

Corrective Maintenance
Adaptive Maintenance
Perfective Maintenance or Enhancement
Preventive Maintenance or reengineering

Only about 20 percent of all maintenance work are spent "fixing

mistakes". The remaining 80 percent are spent adapting existing systems
to changes in their external environment, making enhancements requested
by users, and reengineering an application for use.

Adaptation:

Over time, the original environment (E>G., CPU, operating system,

business rules, external product characteristics) for which the software was
developed is likely to change. Adaptive maintenance results in modification to
the software to accommodate change to its external environment.

Enhancement:

As software is used, the customer/user will recognize additional functions

that will provide benefit. Perceptive maintenance extends the software beyond
its original function requirements.

Prevention :
Computer software deteriorates due to change, and because of this,
preventive maintenance, often called software re engineering, must be
conducted to enable the software to serve the needs of its end users. In
essence, preventive maintenance makes changes to computer programs so
that they can be more easily corrected, adapted, and enhanced. Software
configuration management (SCM) is an umbrella activity that is applied
throughout the software process. SCM activities are developed to
SOFTWARE METHODOLOGY

The software methodology followed in this project includes the object-

oriented methodology and the application system development methodologies.
The description of these methodologies is given below.

Application System Development – A Life cycle Approach

Although there are a growing number of applications (such as decision

support systems) that should be developed using an experimental process
strategy such as prototyping, a significant amount of new development work
continue to involve major operational applications of broad scope. The
application systems are large highly structured. User task comprehension and
developer task proficiency is usually high. These factors suggest a linear or
iterative assurance strategy. The most common method for this stage class of
problems is a system development life cycle modal in which each stage of
development is well defined and has straightforward requirements for
deliverables, feedback and sign off. The system development life cycle is
described in detail since it continues to be an appropriate methodology for a
significant part of new development work.

The basic idea of the system development life cycle is that there is a well-
defined process by which an application is conceived and developed and
implemented. The life cycle gives structure to a creative process. In order to
manage and control the development effort, it is necessary to know what should
have been done, what has been done, and what has yet to be accomplished. The
phrases in the system development life cycle provide a basis for management
and control because they define segments of the

flow of work, which can be identified for managerial purposes and specifies the
documents or other deliverables to be produced in each phase.

The phases in the life cycle for information system development are
described differently by different writers, but the differences are primarily in the
amount of necessity and manner of categorization. There is a general agreement
on the flow of development steps and the necessity for control procedures at
each stage.

The information system development cycle for an application consists of three

major stages.

1)Definition.
2)Development.
3)Installation and operation.

The first stage of the process, which defines the information requirements for a
feasible cost effective system. The requirements are then translated into a
physical system of forms, procedures, programs etc., by the system design,
computer programming and procedure development. The resulting system is test
and put into operation. No system is perfect so there is always a need for
maintenance changes. To complete the cycle, there should be a post audit of the
system to evaluate how well it performs and how well it meets the cost and
performance specifications. The stages of definition, development and
installation and operation can therefore be divided into smaller steps or phrases
as follows.

Definition

Proposed definition : preparation of request for proposed applications.

Feasibility assessment : evaluation of feasibility and cost benefit of proposed
system.
Information requirement analysis : determination of information needed.

Design
Conceptual design : User-oriented design of application development.
Physical system design : Detailed design of flows and processes in
applications processing system and preparation of program specification.
Development
Program development : coding and testing of computer programs.
Procedure development : design of procedures and preparation of user
instructions.

Installation and operation

Conversion : final system test and conversion.

Operation and maintenance : Month to month operation and maintenance
Post audit : Evaluation of development process,application
system and results of use at the completion of the each phase, formal approval
sign-off is required from the users as well as from the manager of the project
development.

7. TESTING:
Testing is a process of executing a program with the indent of finding an
error. Testing is a crucial element of software quality assurance and presents
ultimate review of specification, design and coding.

System Testing is an important phase. Testing represents an interesting

anomaly for the software. Thus a series of testing are performed for the
proposed system before the system is ready for user acceptance testing.

A good test case is one that has a high probability of finding an as

undiscovered error. A successful test is one that uncovers an as undiscovered
error.

Testing Objectives:

1.Testing is a process of executing a program with the intent of finding

an error
2.A good test case is one that has a probability of finding an as yet
undiscovered error
 3.A successful test is one that uncovers an undiscovered error

Testing Principles

1. All tests should be traceable to end user requirements

2.Tests should be planned long before testing begins

3. Testing should begin on a small scale and progress towards testing in

large

4.Exhaustive testing is not possible

5.To be most effective testing should be conducted by a independent

third party

The primary objective for test case design is to derive a set of tests that has
the highest livelihood for uncovering defects in software.

Testing strategies:

A strategy for software testing must accommodate low-level tests that are
necessary to verify that all small source code segment has been correctly
implemented as well as high-level tests that validate major system functions
against customer requirements.

Testing fundamentals:

Testing is a process of executing program with the intent of finding error.

A good test case is one that has high probability of finding an undiscovered
error. If testing is conducted successfully it uncovers the errors in the software.
Testing cannot show the absence of defects, it can only show that software
defects present.

Testing Information flow:

 Information flow for testing flows the pattern. Two class of input
provided to test the process. The software configuration includes a software
requirements specification, a design specification and source code.

Test configuration includes test plan and test cases and test tools. Tests
are conducted and all the results are evaluated. That is test results are compared
with expected results. When erroneous data are uncovered, an error is implied
and debugging commences.

Unit testing:

Unit testing is essential for the verification of the code produced during
the coding phase and hence the goal is to test the internal logic of the modules.
Using the detailed design description as a guide, important paths are tested to
uncover errors with in the boundary of the modules. These tests were carried
out during the programming stage itself. All units of ViennaSQL were
successfully tested.

Integration testing :
Integration testing focuses on unit tested modules and build the program
structure that is dictated by the design phase.
System testing:
System testing tests the integration of each module in the system. It also
tests to find discrepancies between the system and it’s original objective, current
specification and system documentation. The primary concern is the
compatibility of individual modules. Entire system is working properly or not
will be tested here, and specified path ODBC connection will correct or not, and
giving output or not are tested here these verifications and validations are done
by giving input values to the system and by comparing with expected output.
Top-down testing implementing here.
Acceptance Testing:

This testing is done to verify the readiness of the system for the implementation.
Acceptance testing begins when the system is complete. Its purpose is to
provide the end user with the confidence that the system is ready for use. It
involves planning and execution of functional tests, performance tests and stress
tests in order to demonstrate that the implemented system satisfies its
requirements.
Tools to special importance during acceptance testing include:

Test coverage Analyzer – records the control paths followed for each test case.

Timing Analyzer – also called a profiler, reports the time spent in various
regions of the code are areas to concentrate on to improve system performance.

Coding standards – static analyzers and standard checkers are used to inspect
code for deviations from standards and guidelines.

WHITE BOX TESTING (CODE TESTING)

The code-testing strategy examines the logic of the program. To follow

this testing method, the analyst develops test cases that result in executing
every instruction in the program or module so that every path through the
program is tested. A path is a specific combination of conditions that is
handled by the program. Code testing does not check the range of data that
the program will accept.
 Exercises all logical decisions on their true or false sides.
 Executes all loops at their boundaries and within these operational
bounds.

BLACK BOX TESTING (SPECIFICATION TESTING)

To perform specification testing, the analyst examines the

specification, starting from what the program should do and how it should
perform under various conditions. Then test cases are developed for each
condition or combinations of conditions and submitted for processing. By
examining the results, the analyst can determine whether the programs
perform according to its specified requirements. This testing strategy
sounds exhaustive. If every statement in the program is checked for its
validity, there doesn’t seem to be much scope for errors.

FUNCTIONAL TEST

In this type of testing, the software is tested for the functional requirements.
The tests are written in order to check if the application behaves as
expected. Although functional testing is often done toward the end of the
 development cycle, it can—and should, —be started much earlier.
Individual components and processes can be tested early on, even before it's
possible to do functional testing on the entire system. Functional testing
covers how well the system executes the

functions it is supposed to execute—including user commands, data

manipulation, searches and business processes, user screens, and
integrations. Functional testing covers the obvious surface type of
functions, as well as the back-end operations (such as security and how
upgrades affect the system).

PERFOMANCE TEST

In software engineering, performance testing is testing that is performed,

from one perspective, to determine how fast some aspect of a system
performs under a particular workload. It can also serve to validate and
verify other quality attributes of the system, such as scalability, reliability
and resource usage. Performance testing is a subset of Performance
engineering, an emerging computer science practice which strives to build
performance into the design and architecture of a system, prior to the onset
of actual coding effort.
Performance testing can serve different purposes. It can demonstrate that
the system meets performance criteria. It can compare two systems to find
which performs better. Or it can measure what parts of the system or
workload cause the system to perform badly. In the diagnostic case,
software engineers use tools such as profilers to measure what parts of a
device or software contribute most to the poor performance or to establish
throughput levels (and thresholds) for maintained acceptable response time.
It is critical to the cost performance of a new system; the performance test
efforts begin at the inception of the development project and extend through
to deployment. The later a performance defect is detected, the higher the
cost of remediation. This is true in the case of functional testing, but even
more so with performance testing, due to the end-to-end nature of its scope.
In performance testing, it is often crucial (and often difficult to arrange) for
the test conditions to be similar to the expected actual use. This is, however,
not entirely possible in actual practice. The reason is that production
systems have a

random nature of the workload and while the test workloads do their best to
mimic what may happen in the production environment, it is impossible to
exactly replicate this workload variability - except in the simplest system.

STRESS TEST

The application is tested against heavy load such as complex numerical

values, large number of inputs, large number of queries etc. which checks
for the stress/load the applications can withstand. Stress testing deals with
the quality of the application in the environment.   The idea is to create an
environment more demanding of the application than the application would
experience under normal work loads. A test environment is established with
many testing stations. At each station, a script is exercising the system.
These scripts are usually based on the regression suite. More and more
stations are added, all simultaneous hammering on the system, until the
system breaks. The system is repaired and the stress test is repeated until a
level of stress is reached that is higher than expected to be present at a
customer site. Race conditions and memory leaks are often found under
stress testing. A race condition is a conflict between at least two tests. Each
test works correctly when done in isolation. When the two tests are run in
parallel, one or both of the tests fail. This is usually due to an incorrectly
managed lock. A memory leak happens when a test leaves allocated
memory behind and does not correctly return the memory to the memory
allocation scheme. The test seems to run correctly, but after being exercised
several times, available memory is reduced until the system fails.

STRUCTURE TEST

White-box testing, on the other hand is concerned with testing

the implementation of the program. The intent of this testing is not to
exercise all the different input or output conditions but to exercise the
different programming structures and data structures used in the program.
 White-box testing is also called structural testing and we will use the two
terms interchangeable

VALIDATION TEST

After the culmination of black box testing, software is completely

assembled as a package, interfacing errors have been uncovered and
corrected and final series of software validation tests begin. Validation
testing can be defined as many, but a single definition is that validation
succeeds when the software functions in a manner that can be reasonably
expected by the customer. Validation refers to the process of using the
software in a live environment to find errors. During the course of
validation system may occur and the software will be changed.

OUTPUT TEST

In this output is tested by entering sample data and checking out for its
efficiency.

USER ACCEPTANCE TEST

In this type of testing, the software is handed over to the user in order to
find out if the software meets the user expectations and works as it is
expected to. In software development, user acceptance testing (UAT) - also
called beta testing, application testing, and end user testing - is a phase of
software development in which the software is tested in the "real world" by
the intended audience. UAT can be done by in-house testing in which
volunteers or paid test subjects use the software or, more typically for
widely-distributed software, by making the test version available for
downloading and free trial over the Web. The experiences of the early users
are forwarded back to the developers who make final changes before
releasing the software commercially
 CHANGE OVER PLAN

Testing commences with a test plan and terminates with acceptance testing.
A test plan is a general document for the entire project that defines the scope, approach
to be taken, and the schedule of testing as well as identifies the test items for the entire
testing process and the personnel responsible for the different activities of testing.

Test Cases:

Test cases are derived to ensure that all statements in the program have
been executed at least once during testing and that all logical conditions have
been executed.
Using White-Box testing methods, the software engineer can drive test cases
that
 Guarantee that logical decisions on their true and false sides.
 Exercise all logical decisions on their true and false sides.
 Execute all loops at their boundaries and with in their operational bounds.
 Exercise internal data structure to assure their validity.
The test case specification for system testing has to be submitted for review
before system testing commences.
SOURCE CODES

Index.php
<!DOCTYPE html>
<html lang="en">
<?php
session_start();
include('admin/db_connect.php');
ob_start();
$query = $conn->query("SELECT * FROM system_settings limit 1")-
>fetch_array();
foreach ($query as $key => $value) {
if(!is_numeric($key))
$_SESSION['system'][$key] = $value;
}
ob_end_flush();
include('header.php');

?>

<style>
header.masthead {
background: url(admin/assets/uploads/<?php echo
$_SESSION['system']['cover_img'] ?>);
background-repeat: no-repeat;
background-size: cover;
}

#viewer_modal .btn-close {
position: absolute;
 z-index: 999999;
/*right: -4.5em;*/
background: unset;
color: white;
border: unset;
font-size: 27px;
top: 0;
}
#viewer_modal .modal-dialog {
width: 80%;
max-width: unset;
height: calc(90%);
max-height: unset;
}
#viewer_modal .modal-content {
background: black;
border: unset;
height: calc(100%);
display: flex;
align-items: center;
justify-content: center;
}
#viewer_modal img,#viewer_modal video{
max-height: calc(100%);
max-width: calc(100%);
}
body, footer {
background: #000000e6 !important;
}

</style>
<body id="page-top">
<!-- Navigation-->
<div class="toast" id="alert_toast" role="alert" aria-live="assertive" aria-
atomic="true">
<div class="toast-body text-white">
</div>
 </div>
<nav class="navbar navbar-expand-lg navbar-light fixed-top py-3"
id="mainNav">
<div class="container">
<a class="navbar-brand js-scroll-trigger" href="./"><?php echo
$_SESSION['system']['name'] ?></a>
<button class="navbar-toggler navbar-toggler-right" type="button"
data-toggle="collapse" data-target="#navbarResponsive" aria-
controls="navbarResponsive" aria-expanded="false" aria-label="Toggle
navigation"><span class="navbar-toggler-icon"></span></button>
<div class="collapse navbar-collapse" id="navbarResponsive">
<ul class="navbar-nav ml-auto my-2 my-lg-0">
<li class="nav-item"><a class="nav-link js-scroll-trigger"
href="index.php?page=home">Home</a></li>
<li class="nav-item"><a class="nav-link js-scroll-trigger"
href="index.php?page=venue">Venues</a></li>
<li class="nav-item"><a class="nav-link js-scroll-trigger"
href="index.php?page=about">About</a></li>

</ul>
</div>
</div>
</nav>

<?php
$page = isset($_GET['page']) ?$_GET['page'] : "home";
include $page.'.php';
?>

<div class="modal fade" id="confirm_modal" role='dialog'>

<div class="modal-dialog modal-md" role="document">
<div class="modal-content">
<div class="modal-header">
<h5 class="modal-title">Confirmation</h5>
</div>
<div class="modal-body">
 <div id="delete_content"></div>
</div>
<div class="modal-footer">
<button type="button" class="btn btn-success" id='confirm'
onclick="">Continue</button>
<button type="button" class="btn btn-secondary" data-
dismiss="modal">Close</button>
</div>
</div>
</div>
</div>
<div class="modal fade" id="uni_modal" role='dialog'>
<div class="modal-dialog modal-md" role="document">
<div class="modal-content">
<div class="modal-header">
<h5 class="modal-title"></h5>
</div>
<div class="modal-body">
</div>
<div class="modal-footer">
<button type="button" class="btn btn-success" id='submit' onclick="$
('#uni_modal form').submit()">Save</button>
<button type="button" class="btn btn-secondary" data-
dismiss="modal">Cancel</button>
</div>
</div>
</div>
</div>
<div class="modal fade" id="uni_modal_right" role='dialog'>
<div class="modal-dialog modal-full-height modal-md" role="document">
<div class="modal-content">
<div class="modal-header">
<h5 class="modal-title"></h5>
<button type="button" class="close" data-dismiss="modal" aria-
label="Close">
<span class="fa fa-arrow-righ t"></span>
</button>
 </div>
<div class="modal-body">
</div>
</div>
</div>
</div>
<div class="modal fade" id="viewer_modal" role='dialog'>
<div class="modal-dialog modal-md" role="document">
<div class="modal-content">
<button type="button" class="btn-close" data-dismiss="modal"><span
class="fa fa-times"></span></button>
<img src="" alt="">
</div>
</div>
</div>
<div id="preloader"></div>
<footer class=" py-5">
<div class="container">
<div class="row justify-content-center">
<div class="col-lg-8 text-center">
<h2 class="mt-0 text-white">Contact us</h2>
<hr class="divider my-4" />
</div>
</div>
<div class="row">
<div class="col-lg-4 ml-auto text-center mb-5 mb-lg-0">
<i class="fas fa-phone fa-3x mb-3 text-muted"></i>
<div class="text-success">+91 905 906 5724</div>
</div>
<div class="col-lg-4 mr-auto text-center">
<i class="fas fa-envelope fa-3x mb-3 text-muted"></i>
<a class="d-block text-success" href="mailto:<?php echo
$_SESSION['system']['email'] ?>">admin@bhaskarasai.in</a>
</div>
</div>
</div>
<br>
 </footer>

<?php include('footer.php') ?>

</body>

<?php $conn->close() ?>

</html>

Events.php
<?php include('db_connect.php');?>

<div class="container-fluid">

<div class="col-lg-12">
<div class="row mb-4 mt-4">
<div class="col-md-12">

</div>
</div>
<div class="row">
<!-- FORM Panel -->

<!-- Table Panel -->

<div class="col-md-12">
<div class="card">
<div class="card-header">
<b>List of Events</b>
<span class="float:right"><a class="btn
btn-success btn-block btn-sm col-sm-2 float-right" href="index.php?
page=manage_event" id="new_event">
<i class="fa fa-plus"></i> New Entry
</a></span>
</div>
<div class="card-body">
<table class="table table-condensed
table-bordered table-hover">
<colgroup>
 <col width="5%">
<col width="20%">
<col width="15%">
<col width="15%">
<col width="30%">
<col width="15%">
</colgroup>
<thead>
<tr>
<th class="text-
center">#</th>
<th
class="">Schedule</th>
<th
class="">Venue</th>
<th class="">Event
Info.</th>
<th
class="">Description</th>
<th class="text-
center">Action</th>
</tr>
</thead>
<tbody>
<?php
$i = 1;
$events = $conn-
>query("SELECT e.*,v.venue FROM events e inner join venue v on
v.id=e.venue_id order by e.id asc");
while($row=$events-
>fetch_assoc()):
$trans =
get_html_translation_table(HTML_ENTITIES,ENT_QUOTES);
unset($trans["\""],
$trans["<"], $trans[">"], $trans["<h2"]);
$desc =
strtr(html_entity_decode($row['description']),$trans);
 $desc=str_replace(array("<li>","</li>"), array("",","), $desc);
?>
<tr>
<td class="text-
center"><?php echo $i++ ?></td>
<td class="">
<p> <b><?php
echo date("M d, Y h:i A",strtotime($row['schedule'])) ?></b></p>
</td>
<td class="">
<p> <b><?php
echo ucwords($row['venue']) ?></b></p>
</td>
<td class="">
<p>Event:
<b><?php echo ucwords($row['event']) ?></b></p>

<p><small>Type: <b><?php echo $row['type'] == 1 ? "Public Event" : "Private

Event" ?></small></b></p>

<p><small>Fee: <b><?php echo $row['payment_type'] == 1 ? "Free" :

number_format($row['amount'],2) ?></small></b></p>

</td>
<td>
<p
class="truncate"><?php echo strip_tags($desc) ?></p>
</td>
<td class="text-
center">
<button
class="btn btn-sm btn-outline-warning view_event" type="button" data-id="<?
php echo $row['id'] ?>" >View</button>
<button
class="btn btn-sm btn-outline-success edit_event" type="button" data-id="<?
php echo $row['id'] ?>" >Edit</button>
 <button
class="btn btn-sm btn-outline-danger delete_event" type="button" data-id="<?
php echo $row['id'] ?>">Delete</button>
</td>
</tr>
<?php endwhile; ?>
</tbody>
</table>
</div>
</div>
</div>
<!-- Table Panel -->
</div>
</div>

</div>
<style>

td{
vertical-align: middle !important;
}
td p{
margin: unset
}
img{
max-width:100px;
max-height: :150px;
}
</style>
<script>
$(document).ready(function(){
$('table').dataTable()
})

$('.view_event').click(function(){
location.href ="index.php?page=view_event&id="+$
(this).attr('data-id')
 })
$('.edit_event').click(function(){
location.href ="index.php?page=manage_event&id="+$
(this).attr('data-id')

})
$('.delete_event').click(function(){
_conf("Are you sure to delete this event?","delete_event",[$
(this).attr('data-id')])
})

function delete_event($id){
start_load()
$.ajax({
url:'ajax.php?action=delete_event',
method:'POST',
data:{id:$id},
success:function(resp){
if(resp==1){
alert_toast("Data successfully
deleted",'success')
setTimeout(function(){
location.reload()
},1500)

}
}
})
}
</script>

9. Screentshots
10. Conclusion

ACHIEVEMENTS EXPECTED THROUGH THE PROJECT

 Comparing to existing manual system, it performs at a faster pace.

 System gives better feedback.
 Timely and accurate information are available.
 The system provides greater processing speed consistency.
 Chances of errors are much low.
 Provides high security the system and hence unauthorized user can be
prevented
 Time taken for overall process is reduced.
 Forms are very user friendly.
 Ease of operation.
 11. REFERENCES

1. An Integrated approach to Software Engineering: Pankaj Jalote

2. The Complete Reference PHP : Herbert Schildt

3. Software Engineering A practitioner’s approach : Roger S. Pressman

4. www.w3schools.com/

5. Tutorialspoint.com

6. Learncodeonline.com