55064408 Airline Reservation Sysytem

INTERFACE SOFTWARE BPUT UNIVERSITY

BIJUPATNAIK UNIVERSITY OF TECHNOLOGY

A Project Report on

AIRLINE RESERVATION SYSTEM

Carried out at

INTERFACE SOFTWARE

BHUBANESWAR

Submitted By:

Khitish Kumar DasRegistration No:-0805266064

The project is submitted for The Partial Fulfillment of The Requirement for the degree of

MASTER IN COMPUTER APPLICATION (MCA)

Trident Academy of

Creative Technology

Under the guidance of

PARTHASARATHI DAS

PROJECT GUIDER OF INTERFACE SOFTWARE.

.

AIRLINE RESERVATION SYSTEM 1


ACKNOWLEDGEMENT

No project reaches its destination with individual effort, similarly in my case

I have been able to complete my project because of the support I have received

from different avenues.

This project would not have seen the light of day without the guidance of

my external guide

I extend my heartfelt thanks to him for offering his valued guidance in completing

the project and also thankful for his valuable suggestion and efficient supervision in

spite of having arduous schedule. The project would have ended in a prenatal stage

if not for this perseverance and firm belief in my potential. This project is certainly

a success because of his all around help and concern; any word of thanks would be

insufficient for the assistance imparted to me.

I am also immensely thankful to our internal guide Mr. Kartik Rana faculty

of MCA Department of “ TRIDENT ACADEMY OF CREATIVE TECHNOLOGY ”.

I would also like to extend our thanks to Mr.P.K Dixit for his help and also

whole Interface family whose support has made our project a memorable success.

I would like to express my gratitude to Archana Panda and Niranjan Nayak,

for their valuable technical assistance, and Mr. Ashish Das , Mr Raghunath Rana

for their help.

Truly every day has been a learning experience for me due to the presence of all the

people who have helped me to frame a better life.



ABSTRACT

The first and foremost objective of the project is to give a better service to the customer at the time of reserving the ticket of airline and eradicate the problems faced by the customer to some extent . The Airline Reservation System (ARS) was one of the earliest changes to improve efficiency. ARS eventually evolved into the Computer Reservation System (CRS)A Computer Reservation System is used for the reservation of a particular airline and interfaces with a Global Distribution System (GDS) which supports travel agencies and other distribution channels in making reservations for the most major airlines in a single system .Airline Reservation System contain airline schedule, fare traffics, passenger reservations and ticket records. An airline’s direct distribution works within their own reservation system, as well as pushing out information to the GDS. A second type of direct distribution channel is consumers who use the internet or mobile application to make their own reservations.

The projects has successfully implemented with proper authentication and services. There are 2 main development modules in the project. They are

1. Admin Module2. User/Customer Module

1. Admin Module: Admin plays the key role throughout the whole project.Admin having own username and password keeps track of the flight details and also about the customerHe can approve and can also reject the booking application of the customer.

2. User/Customer Modules: User also having his/her own username and password for log on. After log on he/she can view all the flights and their details and can book tickets as per the requirement. User can also view and edit his own profile.



TABLE OF CONTENTS

Index

1. INTRODUCTION

2. REQUIRED SPECIFICATIONS

2.1 System Study

2.2 System specification

2.3 System Requirement study

2.4 Software specification

a. Java Server Pages

b. Java Script

c. Struts Framework and Servlet.

d. HTML

e. introduction to SQL Server.

3. SYSTEM DESIGN

3.1 Date base Design

3.2 Table Structures.

3.3 Data Flow Diagram.

3.4 ER Diagram.

4. IMPLEMENTATION

5. TESTING

6. CODING

7. CONCLUSION

8. APPENDIX

9. BIBLIOGRAPHY



LIST OF TABLES

BOOKING_DETAILS

CUSTOMERDETAILS

FEEDBACK_DETAILS

FLIGHTDETAILS

LOGIN

NOTICE

PAYMENTDETAILS

REGISTRATION



LIST OF FIGURES

Data Flow Diagram

Entity Relationship Diagram



CHAPTER-1 INTRODUCTION



Introduction

Online Air Ticket Booking system is to provide an option to customers to book the tickets online and to check the confirmation online. This system will help the company to sell the flight tickets online. Unless like in the previous stage people as to walk into travel agency or this company ticket counter to buy the tickets and also to check the flight timings. This problem is over come introducing this system.

Existing System

Presently the company has ticket counters in the airport. Where people as to come to book the tickets or to check the flight timings. Also there are many travel agents take the advance booking. In turn these agents will check out with the main ticket counter officials for the ticket confirmation. This is very lengthy and tedious process.

Proposed System The proposed system will available online. So anybody who is interested in the flight timings and ticket booking they check online only.

Objectives of the project 1. Online air ticketing saves time by reducing the time involved in the

physical transportation of the customer to the reservation counter; online air ticketing process saves time in absolute terms.

2. It enables the customer to purchase tickets from the remote areas, thereby

increasing the customer-centricity of the services provided. 3. With a segment of customers opting for the online facilities, the pressure at

the reservation counter is substantially reduced. 4. Reduction in the pressure at the reservation counter creates scope to curtail

the number of employees at the reservation counters, contributing in cost-cut to the company.

5. With faster, easier and hassle-free services to the customer, the company is

poised for a better competitive advantage in face of the oligopolistic structure.


INTERFACE SOFTWARE BPUT UNIVERSITY6. Online portal can be used to ascertain any particular facilities that the

customer might be looking forward to during the journey. 7. The portal can also be used to inform the prospective customers about the

future economy option and other function benefits that the company could have planned; thereby, enabling the customer to plan in advance.

8. With the induction of the cash on delivery system, the customer can easily

deliver his air-tickets while being at home.



CHAPTER-2REQUIRED SPECIFICATIONS

2.1. System studyAIRLINE RESERVATION SYSTEM 10


System study is a process that is to be done before any project begins.

This will held to understand how the existing system is functioning and what are the

drawbacks in it once the drawbacks have been identified it will be easy to design

the new system avoiding these drawbacks also system study should explain what is

the need for computerization.

2.2 OVERVIEW OF THE SOFTWARE:

2.2.1. Overview of java technology

History of java:

Java language was developed by James Gosling and his team at sun micro

systems and released formally in 1995. Its former name is oak. Java Development

Kit 1.0 was released in 1996. To popularize java and is freely available on Internet.

Overview of java:

Java is loosely based on C++ syntax, and is meant to be Object-Oriented

Structure of java is midway between an interpreted and a compiled language. Java

programs are compiled by the java compiler into Byte Codes which are secure and

portable across different platforms. These byte codes are essentially instructions

encapsulated in single type, to what is known as a java virtual machine (JVM)

which resides in standard browser.

Jvm verifies these byte codes when downloaded by the browser for integrity.

Jvm available for almost all OS. JVM converts these byte codes into machine

specific instructions at runtime.

Features of java:


INTERFACE SOFTWARE BPUT UNIVERSITY• Java is object-oriented language and supports encapsulation,

inheritance, polymorphism and dynamic binding, but does not support

multiple inheritance. Every thing in java is an object except some

primitive data types.

• Java is portable architecture neutral that is java programs once

compiled can be executed on any machine that is enabled.

• JAVA is distributed in its approach and used for internet programming.

• Java is robust, secured, high performing and dynamic in nature.

• Java supports multithreading. There for different parts of the program

can be executed at the same time

Java and internet:

Java is strongly associated with internet and known as internet programming

language. Internet users can use java to create applet programs and run them locally

using java enabled browser search as hot java. Applets can be downloaded from

remote machine via internet and run it on local machine.

Java and World Wide Web:

World Wide Web is an open ended information retrieval system designed to

be used in the distributed environment. This system contains web pages that provide

both information and controls. We can navigate to a new web page in any direction.

This is made possible worth HTML java was meant to be used in distributed

environment such as internet. So java could be easily incorporated into the web

system and is capable of supporting animation graphics, games and other special

effect. The web has become more dynamic and interactive with support of java. We

can run a java program on remote machine over internet with the support of web.


INTERFACE SOFTWARE BPUT UNIVERSITYJava Environment:

Java environment includes a large no. of tools which are part of the system

known as java development kit (JDK) and hundreds of classes, methods, and

interfaces grouped into packages forms part of java standard library (JSL).

Java Architecture:

Java architecture provides a portable, robust, high performing environment

for development. Java provides portability by compiling the byte codes for the java

virtual machine which are then interpreted on each platform by the runtime

environment. Java also provides stringent compile and runtime checking and

automatic memory management in order to ensure solid code.

Java Virtual Machine:

When we compile the code, java compiler creates machine code (byte code)

for a hypothetical machine called java virtual machine (jvm). The jvm will execute

the byte code and overcomes the issue of portability. The code is written and

compile for one machine and interpreted all other machines. This machine is called

java virtual machine.

About html:

HTML (hyper text markup language) is a language used to create hyper text

documents that have hyper links embedded in them. It consists of tags embedded in

the text of a document with HTML. We can build web pages or web document s. it

is basically a formatting language and not a programming language. The browser

reading the document interprets mark up tags to help format the document for

subsequent display to a reader. HTML is a language for describing structured

documents. HTML is a platform independent. WWW (World Wide Web) pages are

written using HTML. HTML tags control in part the representation of the WWW

page when view with web browser. The browser interprets HTML tags in the web


INTERFACE SOFTWARE BPUT UNIVERSITYdocument and displays it. Different browsers show data differently. Examples of

browsers used to be web pages include:

• Netscape

• Internet Explorer

2.2.2. INTRODUCTION TO J2EE

Today, more and more developers want to write distributed transactional

applications for the enterprise and leverage the speed, security, and reliability of

server-side technology. If you are already working in this area, you know that in

today's fast-moving and demanding world of ecommerce and information

technology, enterprise applications have to be designed, built, and produced for less

money, faster, and with fewer resources than ever before.

To reduce costs and fast-track enterprise application design and development,

the Java TM 2 Platform, Enterprise Edition (J2EETM) technology provides a

component-based approach to the design, development, assembly, and

deployment of enterprise applications. The J2EE platform gives you a multitiered

distributed application model, the ability to reuse components, a unified security

model, and flexible transaction control. Not only can you deliver innovative

customer solutions to market faster than ever, but your platform-independent

J2EE component-based solutions are not tied to the products and APIs of any one

vendor.

This tutorial takes an examples-based approach to describing the features and

functionalities available in J2EE SDK version 1.4. Whether you are a new or an

experienced enterprise developer, you should find the examples and

accompanying text a valuable and accessible knowledge base for creating your

own enterprise solutions.



If you are new to J2EE applications development, this chapter is a good place

to start. Here you will learn the J2EE architecture, become acquainted with

important terms and concepts, and find out how to approach J2EE applications

programming, assembly, and deployment.

2.2.2.1 SERVLETS OVERVIEW

INTRODUCTION

Servlets extend the request-response-oriented servers, such as Java-

enabled Web servers. For example, a Servlet can retrieve data from an HTML

form and applying the business logic used to update Product database.

Applets used in browsers. Similarly Servlets for server.

The Servlet API assumes nothing about the server’s environment or

protocol. Therefore, Servlet can be embedded in many different servers.


Client System

HTTP Server

Servlet Product Database

15


Uses of Other Servlets:

A Servlet can handle multiple requests concurrently, it allows Servlets

to support systems and concurrently requests.

• Servlets can be used to balance load among several

servers that mirror the same content, and to partition a

single logical service over several servers, thus Servlets

can forward requests.

Web Servers:

A Web server receives the request it then springs into action.

Depending on the type of request, the webserver might look for a web page or it

might execute program on the server, usually, as discussed earlier, CGI script or

an advanced server-side program.

The Servlet API:

The two packages contains the code to build the Servlets: javax.servlet

and javax.servlet.http

The javax.servlet package:

The javax.servlet package contains a number of interfaces and classes

that establish the framework in which Servlets operate. The ServletRequest and

ServletResponse are also very important.

• The ServletRequest interface is used to read data from a client

request.


INTERFACE SOFTWARE BPUT UNIVERSITY• The ServletResponse interface is used to write data to a client

response.

The Servlet Interface:

All Servlets must implement the Servlet interface. Generic Servlet

must implements the Servlet and Servletconfig interface. HttpServlet extends

GenericServlet. It is commonly used to Servlets that receives and process HTTP

requests.


GenericServlets

ServletConfig

Servlet

HttpServlet

17


The ServletRequest Interface:

The server implements the ServletRequest interface. It enables to obtain about a

client request:

• The parameter of the names passed by the client, and the names of

the remote host that made the request.

• Servlets use to get data from clients that use application protocols

such as the HTTP POST and PUT methods in an InputStream such

as ServletInputStream.

• The HttpServletRequest interface contains methods for accessing

HTTP-specific header information.

The ServletResponse Interface:

The ServletResponse interface is implemented by the server. It enables

to obtain about a client response:

• It allows the Servlet to set the content length.

• Servlet can send the reply data which writer through n output

stream such as ServletOutputStream.

• The HttpResponse interface contains allow the Servlet to

manipulate HTTP-specific header information.

Hypertext Transfer Protocol (HTTP):

The Hypertext Transfer Protocol (HTTP) is used an application-level

protocol for distributed, collaborative, hypermedia information systems. A

feature of HTTP is the typing and negotiation of data representation, allowing

systems to be built independently of the data being transferred. The HTTP

protocol is a request/response protocol.


INTERFACE SOFTWARE BPUT UNIVERSITYThe javax.servlet.http Package:

The javax.servlet.http package contains several interfaces and classes

that are commonly used by Servlet developers.

Http Request and Responses:

The Http Requests and Responses contains in two arguments:

• An HttpServletRequest is used to enables Servlets to read

data from an HTTP request.

• An HttpServletResponse is used to enables Servlets to

write data to an HTTP response.

HttpServletRequest Object:

An HttpServletRequest Object provides to access the data from the

client:

• The getParameter method returns the value of a named

parameter and similarly the getParameterValues method

returns an array of values for the named parameter.

• The getReader method returns the BufferedReader to use

to read the data.

• The getInputStream method returns the

ServletInputStream to use to read the data.

HttpServletResponse Objects:

An HttpServletResponse object provides the HTTP method. To access

the data from the user:

• The getWriter method returns a Writer.

• The getOutputStream method returns the ServletOutputStream.



HTTP Header Data:

The HTTP header data means to access Writer or OutputStream. For

example, the GET and POST for HTTP requests to which the service method

includes:

• The handling for GET requests returns to doGet, Conditional

GET and HEAD requests.

• The handling for POST requests returns to doPost.

• The handling for PUT requests returns to doPut.

• The handling for DELETE requests returns to doDelete.

Servlets Features:

Servlets are efficient when compared to any other server-side

programs. They allow persistence of data to be maintained. More important is the

fact they are portable, robust security features.

Servlets Better than CGI:

Servlets offer advantages over CGI in the areas of performance,

portability and security. Each of these advantages will be discussed in turn:

• Performance is perhaps the most visible difference between Servlets

and CGI. Since most Servlets run in the same process space as the

server and are loaded only once, they are able to respond much more

quickly and efficiently to client requests. In contrast, CGI must create a

new process to service each new request. The overhead involved with

creating a new process incurs a significant performance penalty.

Unlike Servlets, CGI cannot share a single database connection across

multiple requests.


INTERFACE SOFTWARE BPUT UNIVERSITY• Portability is another strong advantage for Servlets. Unlike many CGI

applications, Servlets can be run on different servers and platforms

without modifications. This characteristic can be extremely important

when building enterprise-wide distributed applications.

• Servlets are much more secure than CGI. Though CGI scripts can be

written in Java, they are often written in more error-prone language

such as C, since C programs can inadvertently or maliciously access

invalid memory locations, CGI programs are less secure. Of course,

these restrictions can be lifted according to the security policies set by

the Java Security Manager.

Life Cycle of Servlet:

Each Servlet has the same life cycle:

• Sever loads and initializes the servlets calls the init () method.

• The sever handles zero or more client requests calls the service

() method.

• The server removes the servlets calls the destroy () method.

(Some servers do this step only when they shutdown Destroy ())



Initialization Parameters of Servlets:

Initialize the Servlet before client requests are handled and before the

Servlet is destroyed. The Servlet runs the init method. The Servlet calls the init

method when the server loads the Servlet, and similarly will not call the init

method again unless the server is reloading the Servlet. After initialization, the

Servlet able to handle client requests. Initialization can be accessed in two ways:

• The init method declared by the Servlet interface receives

ServletConfig object as its argument. This object provides

methods that enable you to read the initialization parameters.

• The getServletConfig method declared by the Servlet interface

returns a ServletConfig object.

Destroying Servlets:


Server

Server

Servlet code

Server

Servlet code

Servlet code

Client

Client

HandleClient

Request

22

INTERFACE SOFTWARE BPUT UNIVERSITYDestroys the Servlet runs the servlet’s destroy method. The method is

run once; similarly the server will not run the destroy method, when the server

calls the destroy method, another thread might be running a service request.

Servlets run until the server destroys them.

Communication of Servlets:

To communicate Servlets sometimes need to access network resources.

HTML pages, objects shared among Servlets at the same server and other

Servlets:

• The Request Dispatcher Object with other Server Resources

(JSDK 2.1) such as other Servlets with HTML pages and so on.

• The resource is an object in the JAVA programming language

such as Sharing Resources among Servlets (JSDK2.1).

• The other servlet’s Servlet object and calling its public such as

Calling Servlet from Servlets (JSDK2.0).

Utilities For Running Servlets:

The JSDK2.0 has a utility called Servletrunner. If you can test it with

the utility included in the JSDK, while JSDK2.1 comes with a small utility

server.

Properties of Servlets:

The Servlet requires initialization parameters, if you set this data before

starting the JSDK process that runs your Servlet.


INTERFACE SOFTWARE BPUT UNIVERSITYSTRUTS

Why struts?

We are using struts in this project. in the present scenario of web-technology, struts

plays a vital role. strut is a better structure. In standard mvc there is no clue

regarding the structure and designing. java pages being used, labels that has been

used so we found the previous mvc was not at it’s best to eradicate those

problems. We are using an api and a framework

In the name of struts designed by apache.it takes the help of standard servelet api

,jsp,java.

This frame work also follows mvc architecture means it has a model component. it

mix with some standard xml file. and struts defined java file.

It is a framework communication of apis, specification, where we found following

major specification.

1-- jsp specification

2 --servelet specification

3--java specification

4 --xml specification

5--struts specification

Struts basically drivn by the follwing major architecture

1-- mvc

2-- Front controller model

3 --data access object model

4 --data transfer



MVC ARCHITECTURE OVERVIEW

Browser Database

. In the MVC architecture, a central servlet, known as the Controller, receives all

requests for the application. The Controller then processes the request and works

with the Model to prepare any data needed by the View (which is usually a JSP)

and forwards the data to a JSP. The JSP then uses the data prepared by the

controller to generate a response to the browser. In this architecture, the business

and presentation logic are separated from each other. Having the separation of

business and presentation code accommodates multiple interfaces to the application,

be they web, wireless, or GUI (Swing). Additionally, this separation provides

excellent reuse of code.

A CLOSER LOOK AT THE MODEL-VIEW-CONTROLLER ARCHITECTURE

Understanding of the MODEL-View-Controller architecture is crucial to

understanding Struts, this section takes a closer look at each of its parts. As a point

of interest, MVC is based on an older graphical user interface (GUI) design pattern

that has been around for some time, with its origins in the Smalltalk world. Many


Controller(Servlet)Request Processing Data Validation

ModelBusiness Logic Data Manipulation

View(JSP)


of the some forces behind MVC for GUI development apply nicely to Web

development.

Model Components

In the MVC architecture, model components provide an interface to the data

and /or services used by an application. This way, controller components don’t

unnecessarily embed code for manipulating an application’s data. Instead, they

communicate with the model components that perform the data access and

manipulation. Thus, the model component provides the business logic. Model

components come in many different forms and can be as simple as a basic Java

bean or as intricate as Enterprise Java Beans (EJBs) or Web services.

View Components

View components are used in the MVC architecture to generate the response to the

browser. Thus, a view component provides what the user sees. Often times the

view components are simple JSPs or HTML pages. However, you can just as

easily use WML design advantages of MVC. You can use any view technology

that you’d like without impacting the Model layer of your application.

Controller Components

At the core of the MVC architecture are the controller components. The

controller is typically a servlet that receives requests for the application and

manages the flow of data between the Model layer and the View layer. Thus, it



controls the way that the Model and View layers interact. The Controller often uses

helper classes for delegating control over specific requests or processes.

Basic Components of Struts

The Struts framework is a rich collection of Java libraries and can be broken

down into the following major pieces:

Base framework

JSP tag libraries

Tiles plugin

Validator plugin

Base Framework

The base frame work provides the core MVC functionality and is comprised

of the building blocks for your application. At the foundation of the base

framework is the controller servlet ActionServlet. The rest of the base framework

is comprised of base classes. Most prominent among the base class are the Action

and ActionForm classes. These two classes are used extensively in all Struts

applications. Action classes are used by Action servlet to process specific requests.

Action Form classes are used to capture data from HTML forms and to be a conduit

of data back to the View layer for page generation.

JSP Tag Libraries

Struts comes packaged with several JSP tag libraries for assisting with

programming the View logic in JSPs. JSP tag libraries enable JSP authors to use

HTML-like tags to represent functionality that is defined by a java class.



Following is a listing of the libraries and their purpose;

HTML Used to generate HTML forms that interact with the Struts APIs.

Bean Used to work with Java bean objects in JSPs, such as accessing bean values.

Logic used to cleanly implement simple conditional logic in JSPs.

Nested Used to allow arbitrary levels of nesting of the HTML, Bean, and logic tags

that otherwise do not work.

Tiles Plug-in

Struts come packaged with the Tiles sub framework. Tiles is a rich JSP

templating framework that facilitates the reuse of presentation (JTML) code. With

Tiles, JSP pages can be broken up into individual tiles or pieces and then glued

together to create one cohesive page. Similar to the design principles that the core

Struts framework is built on, Tiles provides excellent reuse of View code

Validator Plug-in

Struts come packaged as of version 1.1, with the Validator sub framework for

performing data validation. Validate provides a rich framework for performing data

validation on both the server side and client side. Each validation is configured in

an outside XML file so that validations can easily be added to and removed from an

application declaratively versus being hard-coded into the application. Similar to

Tiles, prior to Struts 1.1, validator was a third party ass-on, but has since been

included in the project and is more tightly integrated.



STRUTS AND THE VIEW LAYER

Struts provide a rich set of functionality and features for developing the View

layer of MVC applications. There are several forms that the View layer of a Struts

application can take. It can be HTML/JSP (the most common case) or it can be

XML/XSLT, Velocity, Swing, or whatever your application requires. This is the

power of Struts and MVC. Because HTML/JSP is the typical view technology used

for Java-based Web applications Struts provides the most functionality and features

for developing your application this way. The remainder of this chapter focuses on

Struts support for creating the view layer using HTML/JSP.

Struts HTML/JSP view layer support can be broken down into the following

major components:

JSP pages

Form Beans

JSP tag libraries

Resource bundles

JSP PAGES

JSPs are the centerpiece of the Struts view layer. They contain the static

HTML and JSP library tags that generate dynamic HTML. Together the static and

dynamically generated HTML gets sent to the user’s browser for rendering. That is,

the JSPs contain the code for the user interface with which a user interacts. JSPs are

the centerpiece of the Struts View layer. They contain the static HTML and JSP

library tags that generate dynamic HTML. Together the static and dynamically


INTERFACE SOFTWARE BPUT UNIVERSITYgenerated HTML gets sent to the user’s browser for rendering. That is, the JSPs

contain the code for the user interface with which a user interacts.

JSPs in Struts applications are like JSPs in any other java-based Web

application. However, to adhere to the mvc paradigm, the JSPs should not contain

any code for performing business logic or code for directly accessing data sources.

Struts provide a set of tag libraries that supports displaying data and creating HTML

forms that capture data. Additionally, the tags support displaying content stored in

resource bundles. The JSP tag libraries glue those two together and the resource

bundles provide a means of content management.

FORM BEANS

Form Beans provide the conduit for transferring data between the view and

controller layers of Struts applications. When HTML forms are submitted to a

Struts application, Struts takes the incoming form data and uses it to populate the

form’s corresponding form Bean. The Struts Controller layer then uses the Form

Beans to access data that must be sent to the Model layer. On the flip side, the

Controller layer populates form Beans with Model layer data so that it can be

displayed with the View layer. Essentially, Form Beans are simple data containers.

They either contain data from an HTML form that is headed to the Model via the

controller or contain data from the Model headed to the View via the controller.

MODEL LAYER BREAKDOWN

The typical model layer of a correctly designed MVC application can be

broken down into three conceptual sublayers. Each sublayer can be thought of as a

component or responsibility of the Model. Figure3-1 illustrates this breakdown.


INTERFACE SOFTWARE BPUT UNIVERSITYEach sublayer does not necessarily represent a separate set of classes, but

rather the Model’s set of responsibilities. You may choose to house a specific

function’s code for all layers in one layer class, or you may break down each

sublayer into fine-grained objects. The level of object granularity is up to y9u and

what’s best and or necessary really depends on the size and complexity of your

application. The following are the three sublayers:

External interface Composed of code that provides and interface that external

code uses to interact with the Model.

Business logic encompasses the bulk of the Model code and provides the

business functionality for an application.

Data access Composed of code for communicating with an application’s data

sources such as a database.

STRUTS AND THE MODEL

The struts framework does not provide any specific features or constraints for

developing the Model layer of your application. At first glance this may seem odd,

or even a shortcoming, given that Struts is designed for building MVC applications.

However, it’s a actually a key design feature of struts and is a great benefit. By not

dictating how the Model layer should be bui9lt, struts gives your application the

flexibility to use any approach or technology for building the Model layer code.

Whether it be Enterprise java Beans, Java Data Objects (JDO), or the Data Access

Objects (DAO) pattern, struts will accommodate.

Because the model defines the business logic, the model is where struts ends

and your application code begins. Your Model code will be accessed from

subclasses of Struts Action object that are part of the Controller layer of the Struts


INTERFACE SOFTWARE BPUT UNIVERSITYframework. Action subclasses interact with the model via Action’s interfaces and

use its Data Transfer Objects to pass and retrieve data.

You should not place any business logic or data access code in Action objects.

Doing so would bypass the separation of the Model and the Controller. Similarly,

your Model code should not have any ref4erences to Struts code or objects.

Violating this rule unnecessarily couples your core application code to Struts.

STRUTS AND THE CONTROLLER LAYER:

Struts provide a robust Controller layer implementation that has been designed from

the ground up to be extensible. At its core is the Controller servlet, Action Servlet,

which is responsible for initializing a Struts application’s configuration from the

struts configuration file and for receiving all incoming requests to the application.

Upon receiving arequest, action Servlet delegates its processing to the Request

Processor class. The Request Processor class processes all aspects of the request,

including selecting the Form Bean associated with the request, populating the Form

Bean with data, validating the Form Bean, and then selecting the correct Action

class to execute for the request. The Action class is where the Struts framework

ends and your application code begins. Action classes provide the glue between the

View and Model layers.



UNDERSTANDING THE FLOW OF EXECUTION

1.HTTP request

7.Produce HTTP

Response2.Create Form Bean 5.Create Result Beans 4.Call DAO Method


Controller 3.Call Action with Form

View

6. Forward to JSP file

Model

DB

Struts Controller Action Servlet

ActionClass

Form bean Result bean Data Access Object (DAO)

JSP File


It is necessary to describe the way that execution takes place. Struts uses the

Model-View-Controller design pattern,. The MVC architecture defines a specific

flow of execution. An understanding of this flow of execution is crucial to and

overall unders6snding of struts. For Mine HR, execution proceeds in the following

way:

The flow of execution for any Struts application as shown here.

1. The browser makes a request to the Struts application that is processed

by Action Servlet (controller).

2. Action Servlet (Controller) populates the Action form (View) object

with HTML form data and invokes it’s validate () method.

3. Action Servlet (controller) executes the Action object (Controller)

4. Action (Controller) interfaces with model components and prepares

data for view.

5. Action (Controller) forwards control, to the JSP (VIEW).

6. JSP (View) uses model data to generate a response to the browser.


INTERFACE SOFTWARE BPUT UNIVERSITYJava database connectivity (jdbc)

Jdbc and Odbc in java:

Most popular and widely accepted database connectivity called Open

Database Connectivity (ODBC) is used to access the relational databases. It

offers the ability to connect to almost all the databases on almost all platforms.

Java applications can also use this ODBC to communicate with a database. Then

we need JDBC why? There are several reasons:

• ODBC API was completely written in C language and it makes an

extensive use of pointers. Calls from Java to native C code have a

number of drawbacks in the security, implementation, robustness and

automatic portability of applications.

• ODBC is hard to learn. It mixes simple and advanced features together,

and it has complex options even for simple queries.

• ODBC drivers must be installed on client’s machine.

Architecture of JDBC:

JDBC Architecture contains three layers:


JDBC Application

JDBC Drivers

JDBC Drivers

35

INTERFACE SOFTWARE BPUT UNIVERSITY Application Layer: Java program wants to get a connection to a

database. It needs the information from the database to display on the

screen or to modify the existing data or to insert the data into the table.

Driver Manager: The layer is the backbone of the JDBC architecture.

When it receives a connection-request form.

The JDBC Application Layer: It tries to find the appropriate driver by

iterating through all the available drivers, which are currently

registered with Device Manager. After finding out the right driver, it

connects the application to appropriate database.

JDBC Driver layers: This layer accepts the SQL calls from the

application and converts them into native calls to the database and

vice-versa. A JDBC Driver is responsible for ensuring that an

application has consistent and uniform m access to any database.

When a request received by the application, the JDBC driver passes the

request to the ODBC driver, the ODBC driver communicates with the database,

sends the request, and gets the results. The results will be passed to the JDBC driver

and in turn to the application. So, the JDBC driver has no knowledge about the

actual database, it knows how to pass the application request o the ODBC and get

the results from the ODBC.

The JDBC and ODBC interact with each other, how? The reason is both the

JDBC API and ODBC are built on an interface called “Call Level Interface” (CLI).

Because of this reason, the JDBC driver translates the request to an ODBC call. The

ODBC then converts the request again and presents it to the database. The results of

the request are then fed back through the same channel in reverse.



Structured Query Language (SQL):

SQL (Pronounced Sequel) is the programming language that defines and

manipulates the database. SQL databases are relational databases; this means

simply the data is store in a set of simple relations. A database can have one or

more table. You can define and manipulate data in a table with SQL commands.

You use the data definition language (DDL) commands to creating and altering

databases and tables.

You can update, delete or retrieve data in a table with data

manipulation commands (DML). DML commands include commands to alter and

fetch data.

The most common SQL commands include commands is the SELECT

command, which allows you to retrieve data from the database.

In addition to SQL commands, the oracle server has a procedural

language called PL/SQL. PL/SQL enables the programmer to program SQL

statement. It allows you to control the flow of a SQL program, to use variables, and

to write error-handling procedures



3. SYSTEM DESIGN AND DEVELOPMENT

3.1. System design:

The design of a system produces the details that state how a system

meet the requirements identified during system analysis. System specialists often

refer to this stage as logical design, in contrast to the process of developing program

software, which is referred to as physical design.

Data Flow Diagrams have been used in the design of the system. Data

Flow Diagram is a graphical tool used to describe and analyze the movement of

data. The transformation of data from input to output, through processes may be

described logically using these Data Flow Diagrams.

The DFD shown to the user must represent only the major functions

being performed by the system. This is called Top Level DFD. If this process is

complex enough, it can be broken further into different levels. This process can be

continued till the process is simple. This is called the leveling of DFD’s.

3.2. Database design:

The main objective of designing a database is

• Data Integration

• Data Integrity

• Data Independence

Data Integration:

In a database information from several files is co-ordinate, accessed and

operated upon a as through it is single file.



Data Integrity:

Data Integrity means storing all the data in a singly place and allow each

application to access it. This approach results in more consistent, on update being

sufficient to achieve a new record status for all the applications, which use it.

Data Independence:

Data Independence is the insulation of application programs from changing

aspects of physical data organization. This objective seeks to allow changes in the

content and organization of physical data with out reprogramming of applications

and to allow modifications to application programs with out reorganizing the

physical data.

3.2.1. Normalization:

Data structuring is refined through a process called normalization, is a formal

process of developing data structures in a manner that eliminates redundancy and

promotes integrity. It is a step-by –step decomposition of complex records into

simple records to reduce redundancy, inconsistency and removes anomalies.

There are several normal forms to be followed in the normalization

process .The most important and widely used are:

• First Normal Form

• Second Normal Form

• Third Normal Form

3.2.1.1 First Normal Form (1 NF):

A table is said to be in the first normal form, if the intersection of any column

and row contains only value.

Identify a suitable identifier from the pool of UN normalized data. Remove

any item that repeat with in a single value of this key to another relation bringing

with them .The identifier key to form part of a new composite key in the relation.


INTERFACE SOFTWARE BPUT UNIVERSITY3.2.1.2 Second Normal Form (2 NF):

For a table to be in the second normal form it should be in the first normal

form and the values in every column are functionally depend upon the primary key.

3.2.1.3 Third Normal Form (3 NF):

For a table to be in the third normal form it should be in the second normal

form and the values in every non-key column are not transitively depend upon on

the primary key

3.2 Table Structures

Table name : LoginPurpose : stores users name, password and typePrimary key : Slno

Column Name Data type Size

Slno Number 22

Username Varchar 4000

Password Varchar 4000

Type Varchar 4000



Table name : Booking_DetailsPurpose : stores booking detail.Primary key : Bid

Column Name Data type SizeBid Number 22Date_of_booking Varchar2 4000Date_of_journey Varchar2 4000Class Varchar2 4000No_of_seat Number 22Cid Number 22Fid Number 22Full Name Varchar2 4000Address Varchar2 4000Mob_no Number 22Dd/Cheque/Scrool no Varchar2 4000Flight_from Varchar2 4000Flight_to Varchar2 4000Flight_name Varchar2 4000Mode_of_payment Varchar2 4000

Table name : NoticePurpose : stores noticesPrimary key : Notice_no


Notice_no Number 22

Subject Varchar2 4000

Content Varchar2 4000

Date_of_notice Varchar2 4000

Receive_username Varchar2 4000


INTERFACE SOFTWARE BPUT UNIVERSITYTable name : Feedback_detailsPurpose : stores feedbacksPrimary key: Feedback_no


Feedback_no Number 22

Comments Varchar2 4000

Suggestion Varchar2 4000

Date_of_feedback Varchar2 4000

Name Varcahr2 4000

Table name : PaymentsdetailsPurpose : stores payments detailsPrimary key :pid



Pid Number 22

Bid number 22

Date_of_payments date 7

Paymentmode varchar 4000

Accountno number 22

42

INTERFACE SOFTWARE BPUT UNIVERSITYTable name : Customer_detailsPurpose : stores customer detailsPrimary key : Customerid


Customer_id number 22

Name Varchar2 4000

Address Datetime2 4000

Email Varchar2 4000

Gender Varchar2 4000

Phono Varchar2 4000

Cid number 22

Table name : FlightdetailsPurpose : stores flight detailsPrimary key : Fid

column Name Data type SizeFid number 22Fname Varchar2 4000Flt_from Varchar2 4000Flt_to Varchar2 4000

Deparature_time number 22

Arrival_time number 22

Available number 22

Price number 22

Class Varchar2 4000


INTERFACE SOFTWARE BPUT UNIVERSITYTable name : RegistrationPurpose : stores new user detailsPrimary key :Rid

Column Name Data type SizeRid number 22Fname Varchar2 4000Lname Varchar2 4000Gender Varchar2 4000Email Varchar2 4000Address Varchar2 4000Mob_no number 22Slno number 22

3.3 Data Flow Diagram



Definition:

A data flow diagram is a graphical technique that depicts information flow and the

transforms that applied as data move from input to output. The Data flow diagram

used to represent a system or software at any level of abstraction. In fact DFDs may

be portioned into levels.

A level of DFD, also called a context model, represents the entire software elements

as a single bubble with input and output by arrow. A level of DFD is portioned into

several bubbles with inter connecting arrows. Each of the process represented at

level one is sub function of the over all depicted in the context model.

The DFD Notations:

Hardware person and other program

Information of the system to be modeled.

Data Item(s): Arrowhead indicates the

direction of flow

Stored Information that is used by the s/w

Level 0:


External Entity

Process

Store


DATA FLOW DIAGRAM FOR OVERALL SYSTEM


AIRLINE RESRVATION SYSTEM

LOGIN

ADMIN USER

DATABASE


Level-0

INPUT

DATASTORE


(0.0) PROCESS OUTPUT


LEVEL - 1

1 ST LEVEL DFD (FOR LOGIN)

User Name

Password Type

LOGIN

1 ST LEVEL DFD (FOR REGISTRATION)

Customer Details

LOGIN REGISTRATION


(1.0)

LOGINLogin Successfully

(1.1)

REGISTRATION

Login Successfully


2 nd LEVEL DFD (FOR VALID ADMIN)

Flight Management (2.0.1)

View Customer(2.0.2)VALID ADMIN

View Booking(2.0.3) View Feedback(2.0.4) Give announcement(2.0.5)

2 nd LEVEL DFD (FOR FLIGHT MANAGEMENT)

ADD FLIGHT (2.0.1.0)FLIGHT MANAGEMENT EDIT FLIGHT(2.0.1.1)

DELETE FLIFHT(2.0.1.2)


(2.0)

PROCESS

(2.0.1)

PROCESS


2 nd LEVEL DFD (FOR ADD FLIGHT)

FLIGHT NAME FLIGHT NO

FROM TO ARRIVAL TIME DEPARATURE TIME CLASS SEAT AVAILABLE PRICE

FLIGHTDETAILS

2 nd LEVEL DFD (FOR EDIT FLIGHT)

SELECT FLIGHT VIEWED

FLIGHTDETAILS


(2.0.1.0)

ADD FLIGHT

SUCESSFULLY ADDED

(2.0.1.1)

SEARCH

UPDATED SUCCESSFULY

UPDATEFLIGHT


2 nd LEVEL DFD (FOR VIEW CUSTOMER)

SELECT CUSTOMER VIEWED

CUSTOMERDETAILS

2 nd LEVEL DFD (FOR VIEW BOOKING)

SELECT CUSTOMER VIEWED

BOKING_DETAILS


(2.0.2) VIEW CUSTOMER

VIEWEDSUCESSFULLY

(2.0.3)PROCESSVIEWBOOKING

VIEWED SUCCESSFULLY


2 nd LEVEL DFD (FOR VIEW FEEDBACK)

SELECT NAME VIEWED

NOTICE

2 nd LEVEL DFD (FOR ANNOUNCEMENT)

SELECT DATE VIEWED

NOTICE



FEEDBACKVIEWED SUCCESSFULLY


ANNOUNCEMENTVIEWED SUCCESSFULLY


3 rd LEVEL DFD (FOR VIEW BOOKING)

MY PROFILE (3.0.1)

CHANGE PASSWORD(3.0.2)

VIEW FLIGHT(3.0.3)VALID USER MY BOOKING(3.0.4)

CANCELLATION(3.0.5)

GIVE FEEDBACK(3.0.6)

VIEW ANNOUNCEMENT(3.0.7)

3 rd LEVEL DFD ( FOR MY PROFILE )

MY PROFILE EDIT PROFILE(3.0.1.0)

DELETE PROFILE(301.1)


(3.0)

PROCESS

(3.0.1)

PROCESS


3 RD LEVEL DFD (FOR EDIT PROFILE)

SELECT NAME EDITED

CUSTOMERDETAILS

3 RD LEVEL DFD (FOR DELETE PROFILE)

SELECT NAME DELETED

CUSTOMERDETAILS


(3.0.1.0)

PROCESSUPDATEDSUCCESSFULLY

(3.0.1.1)

PROCESSDELETEDSUCCESSFULLY


4 TH LEVEL DFD (FOR NOTICE MANAGEMENT)

ADD NOTICE(4.0.1)

ADMIN EDIT NOTICE(4.0.2)

DELETE NOTICE(4.0.3)

4 TH LEVEL DFD (FOR EDIT NOTICE)

SELECT NOTICE MODIFIED

NOTICE


(4.0)

PROCESS

(4.0.2)

PROCESS

NOTICEMODIFIEDSUCCESSFULLY


3.4 ER-DIAGRAM


LOGIN

SLNO

US

ERN

AM

E

PASS

WO

RD

TY

PE

CUSTOMERDETAILS

CUSTOMERID

NAME

ADDRESS

EMAIL

GENDER

PHONENO

CID

BOOKING_DETAILS

BID

CID

DATE_OF_BOOKINDATE_OF_JOURNY

CLASS NO_OF_SEATS

FID

FULL_NAME

ADDRESS

MOB_NO DDFLIGHTFRO

M

FLIGHTTO

FLIGHTNAME

MODE_OF_PAY

HAS A

HAS A

HAS A



PAYMENTDETAILS

PID BID

DATE_OF_PAYMENT

PAYMENTMODE

ACCOUNTNO

FLIGHTDETAILS

FID

FNAMEFLT_FROM

FLT_TO

ARRIVALTIME

AVAILLABLEPRICE

CLASS

NOTICE

NOTICENOSUBJECT

CONTENT

DATE_OF_NOTICE

USERNAME

FEEDBACK_DETAILS

FEEDBACK_NO COMMENTS

SUGGESTION

DATE_OF_FEEDBACK

NAME


4. SYSTEM TESTING AND IMPLEMENTATION

4.1. System testing:Theoretically, a new designed system should have all the pieces in

working order, but in reality, each piece works independently. Now is the time

to put all pieces into one system and test it to determine whether it meets the

user’s requirements. The purpose of the system is to consider all the likely

variations to which it will be subjected and then push the system to its limits. It

is tedious but necessary step in system development. One needs to be familiar

with the following basic terms.

• UNIT TESTING: Unit Testing is testing changes made in an existing

or a new program.

• SEQUENTIAL OR SERIES TESTING: Sequential or Series Testing is

checking the logic of one or more programs in the candidate system, where

the output of one program will affect the processing done by another

program.

• SYSTEM TESTING: System Testing is executing a program to check

logic changes made in it and with the intention of finding errors making the

program fail.

• ACCEPTANCE TESTING: Acceptance Testing is running the system

with live data by the actual user of the system.

Testing is vital to the success of the system. System testing makes a

logical assumption that if all the parts of the system are correct, the goal will be

successfully achieved. In adequate testing or no-testing leads to errors that may

not appear until months later. Another reason for system testing is its utility as a

user-oriented vehicle before implementation. The best program and the user

have communication barriers due to different backgrounds. The system


INTERFACE SOFTWARE BPUT UNIVERSITYtester(designer, programmer, or user) who has developed some computer

mastery can bridge this barrier.

4.1.1 Unit Testing:

This focuses on the smallest unit of software design. The module

using the details design description as a guide; important control paths are tested

to uncover errors within the boundary of the module.

Unit test consideration:

The module interface id tested to ensure that information properly

flows into and out of the program unit under test. The local data structures are

examined to ensure that the data stored temporarily maintains it integrity during

all steps in an algorithm execution. Boundary conditions are tested to ensure that

the module operates properly at boundaries established to limit or restrict

processing. The test of data flow across a module interface is required before

any other test. If data do not enter and exit properly, all other tests are moot.

Unit Procedure:

Unit test is normally considered adjunct to the coding style.

After source level code has been developed, reviewed and verified for

correct syntax, unit test case design begins. Each test case should be

coupled with a set of expected results.

Normally, a driver is a “main program” that accepts test case data,

passes such data to the module to be tested and prints the relevant

results. Stubs serve to replace modules that are subroutines called by

the module to be tested. A Stub or ‘dummy stub program’ uses the

subroutine module’s interface to do minimal data manipulation and

returns.


INTERFACE SOFTWARE BPUT UNIVERSITYUnit testing is simplified when a module with high cohesion is designed. When a

module addresses only one function, the number of test cases is reduced and

errors can be more easily predicted and uncovered.

4.1.2 Integration Testing:

Integration is a systematic technique for constructing the program

structure, while at the same time conducting tests to uncover errors associated with

interfacing. The objective is to make unit-tested modules and build a program

structure that has been dictated by design. Incremental integration is the program

that is the program that is constructed and tested in small segments where errors are

easier to isolate and correct.

Top down Integration:

Top-down integration is an incremental approach to the construction of

program structure. Modules are integrated by moving downward through the

control hierarchy, beginning with the main control module. Module subroutine to

the main control module is incorporated into the structure either in a depth-first

manner is engaged for this system. Breadth-first incorporates all modules directly

subroutine at each level, moving across the structure horizontally.

The integration process is performed in a series of five steps:

The main control module is used as a test driver and stubs are

substituted for all modules directly subroutine to the main control

module.

Depending on the integration approach selected (depth or breadth first)

subroutine stub are replaced one at a time with actual modules.

Tests are conducted as each module is integrated.


INTERFACE SOFTWARE BPUT UNIVERSITY On the completion of each set of test, another stub is replaced with the

real module.

Registration testing is conducted to ensure that new errors have not

been introduced.

4.1.3 Validation testing:

At the end of integration testing, the system is completely assembled

as a package with interfacing errors corrected after which a final series of

software tests namely validation testing begins. Validation succeeds when the

software functions in a manner that can be reasonably expected by the user.

Criteria:

Software validation is achieved through black box tests that

demonstrate conformity with requirements.

4.1.4 System Testing:

System testing is actually a series of different tests whose primary

purpose is to fully exercise the computer-based system. Although each test has a

different purpose, all work should verify that all system elements have been

properly integrated and perform allocated functions. Being the most important

test, the performance test is covered briefly below:

Performance Testing:

For real-time systems, software that provides required function but does

not conform to performance requirement is unacceptable. Performance testing is

designed to test the run-time performance of software within the context of an

integrated system. Performance testing occurs throughout all steps in the testing

process. Even at the unit level, the performance of an individual module may be

accessed as tests are conducted. However, it is not until all system elements are

fully integrated that the true performance of a system can be ascertained.



4.1.5 Debugging:

Debugging is not testing not occurs as a consequence of testing, that is

when a test case uncovers an error, debugging is the process that results in the

removal of the error.

Normally three categories for debugging approaches are proposed:

Brute force

Back-tracking

Cause-elimination

4.1.5.1 Brute force:

This is the most common and least efficient method for isolating the

cost of a software error. Brute-force debugging method is usually applied when

all else fails. Using a “let the computer finding the error” philosophy, memory-

dumps are taken, runtime traces are invoked and the program is loaded with

WRITE (in this case message box) statements. In the information that is

produced, a clue is found leading to the cause of the error.

4.1.5.2 Back-tracking:

This is fairly common debugging approach that can be used

successfully in small programs. Beginning at the site where a symptom has been

uncovered, the source code is traced backwards (manually) until the site of the

cost is found.



Cause-Elimination:

This approach is manifested by induction/deduction and introduces the

concept of ‘binary partition’. A ‘cause hypothesis’ is devised and the error

related data are used to prove or disprove the hypothesis. Alternatively, a list of

all possible causes is developed, and tests are conducted to eliminate each. If

initial tests indicate that a particular cause hypothesis shows promise, that data

are refined in an attempt to isolate the path.

Each of the debugging approaches can be supplemented with

debugging tools. A wide variety of debugging compilers, dynamic debugging

aids (tracers), automatic test case generators, memory dumps and cross-reference

maps can be applied. However, tools are not a substitute for careful evaluation,

based on a complete software design document and clear source code.

4.2. System implementation

After proper testing and validation, the question arises whether the

system can be implemented or not. Implementation includes all those activities that

take place to convert from the old system to the new. The new system may be

totally new; replacing an existing module or automated system, or it may be major

modification to an existing system. In either case proper implementation is essential

to provide a reliable to provide a reliable system to meet organization requirements.

All planning has now, be completed and the transformation to a fully

operational system can commence. The first job will be writing, debugging

documenting of all computer programs and their integration into a total system. The

master and transaction files are decided, and this general processing of the system is

established. Programming is complete when the programs conformed to the detailed

specification.


INTERFACE SOFTWARE BPUT UNIVERSITYWhen the system is ready for implementation, emphasis switches to

communicate with the finance department staff. Open discussion with the staff is

important form the beginning of the project. Staff can be expected to the concerned

about the effect of the automation on their jobs and the fear of redundancy or loss of

status must be allayed immediately. During the implementation phase it is

important that all staff concerned be apprised of the objectives of overall operation

of the system. They will need shinning on how computerization will change their

duties and need to understand how their role relates to the system as a whole. An

organization-training program is advisable; this can include demonstrations,

newsletters, seminars etc.

The department should allocate a member of staff, who understands

the system and the equipment, and should be made responsible for the smooth

operation of the system. An administrator should coordinate the users to the system.

Users should be informed about new aspects of the system that will,

affect them. The features of the system explained with the adequate documentation.

New services such as security, on-line application from the back-ups must be

advertise on the staff when the time is ripe.

Existing documents such as employee loan details should be entered into the new

system. Since these files are very large, conversion of these may continue long after

the system based on current files has been implemented. Hence we need to assign

responsibility for each activity.

The system may come into full operation via number of possible

routes. Complete change over at one point time is conceptually the most tidy.

But this approach requires careful planning and coordination, particularly during

the changeover. A phased approach, possible implementing the system of the

section relating to one operation or procedure first and processing to more novel

or complex subsystems in the fullness of time. These likely to be less traumatic.



A phased approach gives the staff time to adjust to the new system. But depends

on being able to split the system, without reliance on it. Thus approach is

sensible when the consequences of failure are disastrous, but will require extra

staff time. The fourth angle, is pilot operation permits any problems to be

tackled on a smaller scale operation. Pilot operation generally means the

implementation of the complete system, but at one location or branch only.



Screen shot:

Login.jsp

Description : This page comes first when you run this projects. This page is by defult call index.jsp page.



AdminHome.jsp

Description :This page comes after inputing correct username, password and type then clicking the Login button on Login page.

Fields :

Login -: Login id of admin Password -: password of admin



Registration.jsp

Description: This page comes after clicking NewUser hyperlink at the Login page. This page is for the registration of new user by filling required fields available and all the data giving by the users through this page will store in database.



UserHome.jsp

Description: This page comes after inputting correct username, password and type then clicking the Login button on Login page.

Fields:

Login -: Login id of user. Password -: password of user.



ViewFlight.jsp

Description: This page comes after clicking the Attributes of user . It gives all the information of the flight.



GiveFeedback.jsp

Description: This page is for storing the feedback given by the customer.

Fields: Name- Customer Name.

Comments-Comments given by the Customer.

Suggestion- Suggestion given by the Customer.



ViewCustomer.jsp

Description: This page comes after clicking the Attributes of Admin i.e View Customer. It gives the details of Customers.

Fields:

Customer Name: Name of Customer.

Address: Address of Customer.

Gender: Gender of Customer.

Mob No: Mobile no of Customer.



Annoucement.jsp

Description: This page comes after clicking the Attributes of Admin i.e. Give Announcement. It gives the details about the Announcement.



ViewBooking.jsp

Description: This page comes after clicking the Attributes of Admin i.e View Booking. It gives details of the booking of ticket.



ChangePassword.jsp

Description: This page comes after clicking the attribute of user i.e. Change Password. This page changes the old password of a User.



DEVELOPMENT PROCESS

2.1. PROJECT LIFE CYCLE

The Software Development Life Cycle (SDLC) is the process by which

software is created. Some companies don't have anything more than an ad hoc

approach to software development, but these environments still have an SDLC-it's

just a bad one. Likewise, each company that has a formal SDLC probably has its

own, unique flavor of the SDLC. Sometimes the SDLC is a very complicated,

detailed approach that requires a whole team of project managers just to keep going.

The lifecycle of a project may include the following steps:

. By applying this simple set of definite steps and deliverables at the outset and

relating this to a transparent time and cost structure, we provide clients with an

effective framework against which to measure expectation, quality, progress and

cost for their project.


INTERFACE SOFTWARE BPUT UNIVERSITY2.2. DEVELOPMENT PROCESS

Waterfall Model

Planning the development process involves several important considerations.

The first consideration is to define a product life-cycle model.A software LIFE-

CYCLE model encompasses all activities required to define, test, and develop.


Design- v&v

Implementation-v&v

Requirement analysis-

Testing- v&v

Maintenance-v&v


FEASEBILITY STUDY

The main aim of feasibility study is to determine whether developing

the product is financially and technically feasible .The feasibility study involves.

An abstract definition of the problem.

Formation of different solution strategies.

Examination of alternative solution strategies and their benefits,

indicating resources required, developed, cost and time respect of each of

the alternative solution. A cost effective analysis is performed to determine

which solution is the best at this stage , it may also determine whether any

of this solution is not feasible due to the high cost , resource constraint or

extraordinary technically reason .

The module is totally feasible in all respect i.e. technically it reduces the time

consuming and in economically it reduces the cost.

The feasibility aspect of the project was considered at the time of the

negotiation with the officials and while discussing the same with the team.

FEASIBILITY ANALYSIS:

The advantage of computer based system is more likely to be

plagued by a scarcity of resources and difficulty delivery dates. A feasibility study

is not warranted for a system in which economic justification is obvious, technical

risk is low, few legal problem are expected and no reasonable alternative risks.

Even if there are different types of feasibility study reports but the following were

given importance for this project:-


INTERFACE SOFTWARE BPUT UNIVERSITY Security Feasibility

Operational Feasibility

Economical Feasibility

Technical Feasibility

SEQURITY FEASIBILITY:

The security of the database from being tampered from an unauthorized

personnel different password fields were provided to different users. The

password are validated and given in the front-end keeping its flexibility and user

friendliness in view. As the concept goes usually the backend is not a frequently

visited area that’s why we kept the access of passwords in jsp. As our project

keeps, evaluates and relatives very important and confidential data about the

diseases and it’s eradication program , it is very important that user should

maintain their own individuality and identity so as one cannot overlap or interfere

or even tamper the restricted fields.

OPERATIONAL FEASIBILITY:

People are inherently resistance to change and computers have been

known to facilitate change. An estimate should be made of how strong a reaction

the user staff is likely to have towards the development of a computerized

system. It is common knowledge that computer installations have something to

do with turnover, transfer retraining and change in job status.

The end users are eager enough to use the s/w. This would reieve them from

physical labor and also financially to maintain various registers and paying a lot

of staffs in the working office and depot.


INTERFACE SOFTWARE BPUT UNIVERSITY The top level officials or the outsides can vital information quickly and

correctly form our interpretation.

ECONOMICALLY FEASIBILITY:

Economically Feasibility is most frequently used for evaluating the

effectiveness of equipment information system. More commonly known as cost

benefit analysis, the procedure is to determine the benefits and saving that are

expected from equipment information system and compare them with costs. If

benefits outweigh costs, then the decision is made to design and implement the

system, otherwise design and implement the system, otherwise further justification

or alternation in the proposed system will have to be made if it is to have a chance

of being approved.

Keeping in view the no. of clients who would be using this software that

is the different places and locations, this project was developed keeping in view the

lowest hardware capacity computer available during that time. As can be seen in

our synopsis that we use p2 7 p3 computers the lowest available with the client

having the following configuration.

486 DX

60 MHz

1 GB HDD

12/16 MB RAM



The software was developed in JSP & Oracle8.0 because we opted for a front-end

that will be very user friendly, web friendly and easier for the end user. This also

helped the end user to a very large extent because usually the end user is just a data

entry operator who knows the distinction between letter and number. Keeping this

IQ level of the user into view this type of front-end was used for smooth operation.

TECHNICAL FEASIBILITY:

Technical Feasibility involves financial considerations to accommodate

technical enhancement. If the budget is a serious constraint then the project is

judged ‘not feasible’.

Here the cost incurred by searching an appropriate s/w which may handle

by some few people and hidden to others, but it reduces the searching time, so it

technically fit.

The module reduce the work load of different end user , and gives a clear

picture about the s/w required so the user use this module , hence this system is

operationally feasible .

As this page is technically, economically sequritically and operationally

feasible, so this system is judged feasible.

Hardware Feasibility

For develop this project or implement this project we need different

types of hardware configuration for server and client. If we will use different type

of hardware’s then it may not work properly.


INTERFACE SOFTWARE BPUT UNIVERSITY FOR SERVER

Machine: Pentium IV Server

Memory: 256 MB DDRAM

Hard Drive: 40 GB HDD or Higher

CPU Speed: 2.0Ghz Monitor: S.V.G.A

Keyboard: Standard

Printer: Laser

UPS: 5KVA

For client

Machine: Pentium IV Client

Memory: 128 MB DDRAM

Hard Drive: 10 GB HDD or Higher

CPU Speed: 1.0Ghz

Monitor: S.V.G.A Keyboard: Standard

Printer: Laser UPS: 2KVA



Software Feasibility

Using different types of software, which have listed below so these

software’s also need for implement this project, developed this project. If we will

use different types of software then this project will not work.

Operating System: WINDOWS 98, 2000, Xp,2007

Front-end Tool: SERVLET, JSP, STRUTS

Back-end Tool: SQL SERVER

Server: Tomcat 6.0, WBLOGIC

Economical Feasibility

As soon as the specific requirements and solutions have been identified then

the cost of and benefits of each alternative would be evaluated.


INTERFACE SOFTWARE BPUT UNIVERSITYCost Of Estimation Of the Project

The cost of the major hardware, software and accessories required for this

project are 20 lakhs.

Requirement Analysis and Specification

Before starting to design a software product, it is extremely important to understand

the precise requirements of the customer and to document them properly. The

requirements analysis and specifications phase starts once the feasibility study

phase is complete and the project is found to be financially sound and technically

feasible, the goal of the requirements analysis and specifications phase is to clearly

understand the customer requirements and to systematically organize these

requirements in a specification document, this phase consists of the following two

activities:

Requirements gathering analysis

Requirements specification

Requirements gathering analysis

We can elaborate the two main activities involved in the requirements

gathering and analysis phase:


INTERFACE SOFTWARE BPUT UNIVERSITYRequirements gathering.

This activity typically involves interviewing the end-users and customers and

studying the existing documents to collect all possible information regarding the

system. If the project involves automating some existing procedures then the task of

the system analyst becomes a little easier as he can obtain the input and the output

data formats and the details of the nation and creativity on the part of the system

analyst is required.

Analysis of gathered requirements.

The main purpose to this activity is to clearly understand the exact

requirements of the customer. The following basic questions pertaining to the

project should be clearly understood by the analyst in order to obtain a good grasp

of the problem:

What is the problem?

Why is it important to solve the problem?

What are the possible solutions to the problem?

What exactly are the data inputs to the system and what exactly are the

data outputs required of the system?

What are the likely complexities that might arise while solving the

problem?

If there are external software or hardware with which the developed

software has to interface, then what exactly would the data interchange

formats with the external system.



Software Requirements Specification (SRS).

After the analyst has collected all the required information regarding the

software to be developed, and has removed all incompleteness, inconsistencies, and

anomalies from the specification, he starts to systematically organize the

requirements n the form of an SRS document. The SRS document usually contains

all the user requirements in an informal form.

Contents of the SRS Document

An SRS document should clearly document the following aspects of a

system:

Functional requirements

Nonfunctional requirements

Goals of implementation

The functional requirements part should discuss the functionalities required from

the system. It is useful to consider a system as performing a set of functions {f1}.

This functional view of a system is shown schematically in figure.

Each function fi of the system can be considered as a transformation of a set of input data(ii)corresponding set of output data(oi).

The nonfunctional requirements deal with the characteristics of the system that

cannot be expressed as functions. Example of nonfunctional requirements includes


ySystem

OutputInput


aspects also include reliability issues, accuracy of results, human-computer

interface issues, and constraints on the system implementation.

The ‘goals of implementation’ part of the SRS document gives some general

suggestions regarding development. These suggestion guide trade-off among design

decisions.

DESIGN

Software design deals with transforming the customer requirements, as described in

the SRS document, into a form that is implement able using a programming

language, for a design to be easily implement able using a programming language,

the following items must be designed during the design phase:

Different modules required implementing the design solution.

Control relationship among the identified modules. The relationship is

also known as the call relationship or invocation relationship among

modules.

Data structures of the individual modules. Algorithms required implementing the individual modules.

System design

System design consists of the flow of control among different modules and the

approach i.e. function-oriented approach of object-oriented approach is used.

In our project we have used function-oriented approach. The commonly used data

flow control (DFD).



6.Coding

Web.xml

<?xml version="1.0" encoding="UTF-8"?><web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="2.4" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"> <servlet> <servlet-name>action</servlet-name> <servlet-class>org.apache.struts.action.ActionServlet</servlet-class> <init-param> <param-name>config</param-name> <param-value>/WEB-INF/struts-config.xml</param-value> </init-param> <init-param> <param-name>debug</param-name> <param-value>3</param-value> </init-param> <init-param> <param-name>detail</param-name> <param-value>3</param-value> </init-param> <load-on-startup>0</load-on-startup> </servlet> <servlet-mapping> <servlet-name>action</servlet-name> <url-pattern>*.do</url-pattern> </servlet-mapping> <welcome-file-list> <welcome-file>Home.jsp</welcome-file> </welcome-file-list></web-app>



Struts-config.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">

<struts-config> <data-sources /> <form-beans > <form-bean name="loginForm" type="pp.form.LoginForm" />

</form-beans>

<global-exceptions /> <global-forwards /> <action-mappings > <action attribute="loginForm" name="loginForm" parameter="submit" path="/login" scope="request" type="pp.action.LoginAction"> <forward name="submit" path="/Registration.jsp"/> <forward name="notapp" path="/Login.jsp"/> <forward name="admin" path="/AdminHome.jsp"/> <forward name="customer" path="/UserHome.jsp"/> <forward name="view" path="/FlightManagment.jsp"/> <forward name="flight" path="/FlightManagment.jsp"/> <forward name="add" path="/AddFlight.jsp"/> <forward name="fedit" path="/EditFlight.jsp"/> <forward name="vcust" path="/ViewCustomer.jsp"/> <forward name="vcust1" path="/ViewBooking.jsp"/> <forward name="feed" path="/ViewFeedback.jsp"/> <forward name="notice" path="/Announcement.jsp"/> <forward name="vprof" path="/MyProfile.jsp"/> <forward name="eprof" path="/EditProfile.jsp"/> <forward name="dprof" path="/DeleteProfile.jsp"/>


INTERFACE SOFTWARE BPUT UNIVERSITY <forward name="cpwd" path="/ChangePassword.jsp"/> <forward name="fview" path="/View Flight.jsp"/> <forward name="mbook" path="/MyBooking.jsp"/> <forward name="cancel" path="/Cancellation.jsp"/> <forward name="feed1" path="/GiveFeedback.jsp"/> <forward name="vannoun"path="/ViewAnnouncement.jsp"/> <forward name="not" path="/NoticeMgmt.jsp"/> <forward name="ntice" path="/EditNotice.jsp"/> <forward name="dnotice" path="/DeleteNotice.jsp"/> <forward name="subError" path="/Registration.jsp" /> <forward name="logon" path="/Login.jsp" /> <forward name="logout" path="/UserHome.jsp" /> </action>

</action-mappings>

<message-resources parameter="pp.ApplicationResources" /></struts-config>

Home.jsp

<%@ page language="java" pageEncoding="ISO-8859-1"%>

<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean" %><%@ taglib uri="http://struts.apache.org/tags-html" prefix="html" %><%@ taglib uri="http://struts.apache.org/tags-logic" prefix="logic" %><%@ taglib uri="http://struts.apache.org/tags-tiles" prefix="tiles" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">


INTERFACE SOFTWARE BPUT UNIVERSITY<html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><title>Professional by FreeCSSTemplates.org</title><link rel="stylesheet" type="text/css" href="style.css" media="screen" /></head><body>

<div id="wrapper">

<div id="header"><div id="logo">

<h1>Air Ticket Reservation</h1><p>Fly In

Cooooooooollllllllllllll......................</p></div><div id="menu">

<ul><li class="active"><a

href="Home.jsp">Home</a></li><li><a href="AboutUs.jsp">About Us</a></li><li><a href="ContactUs.jsp">Contact

Us</a></li></ul>

</div>

</div>

INTERFACE SOFTWARE BPUT UNIVERSITY<div id="page">

<div id="header-pic"></div><div id="content">

<div class="post"><h1 class="title"><h2>Welcome To Home

Page......</h2> </h1><p class="byline"><div class="entry">

</div><div class="meta">

<p class="links">Welcome aboard RK Airlines, where you are

made to feel like an honoured guest and not just a passenger. At RK, a flight is not a journey between two airports but an experience of a lifetime.RK is built for people with things to do, places to be, people to see - who don't want to waste time, money or energy in the process. By minimizing the cost/time/tension of air travel, RK opens up a country full of opportunities. With RK, you've got a billion reasons to fly</div>

</div><div class="post">

<p class="byline"><div class="entry">


</div></div>

</div><div id="sidebar">

<div id="sidebar-bgtop"></div><div id="sidebar-content">

<div id="sidebar-bgbtm"><ul>

<li>

INTERFACE SOFTWARE BPUT UNIVERSITY<h2>Sign Here<br /></h2><ul>

<li><a href="Login.jsp">Login<br /></a></li>

<li><a href="Registration.jsp">New User<br /></a></li>

</ul></li><li>

<ul>

</li></ul>

</div></div>

</div><div style="clear:both; margin:0;"></div>

</div>

</div>

<div id="footer">

</div></body></html>

Login.jsp



<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><meta http-equiv="Content-Type" content="text/html; charset=utf-8" /><title>Professional by FreeCSSTemplates.org</title><link rel="stylesheet" type="text/css" href="style.css" media="screen" /> <script> function validateForm(frm){var uname=frm.uname.value;

INTERFACE SOFTWARE BPUT UNIVERSITYvar pwd=frm.pwd.value;

if(uname.length==0) { alert("Enter ur UserName"); frm.uname.focus(); return false; } if(pwd.length==0) { alert("Enter ur Password"); frm.pwd.focus(); return false; } return true;} </script></head><body>

<div id="wrapper">






Us</a></li></ul>


</div><div id="page">

INTERFACE SOFTWARE BPUT UNIVERSITY<div id="header-pic"></div><div id="content">

<div class="post"><h1 class="title"><h2>Welcome Login



<p class="links">

Welcome Login Page......

<html:form action="login" onsubmit="return validateForm(this);">

<table> <tr><td>User Name</td><td><html:text

property="uname"/></td></tr> <tr><td>Password</td><td><html:password

property="pwd"/></td></tr> <tr><td>Type</td><td colspan="2"

align="center"><html:radio property="type" value="admin">Admin</html:radio>

<html:radio property="type" value="customer">Customer</html:radio></td></tr>

<tr><td><html:submit property="submit" value="Login"/><html:submit property="submit" value="Reset"/></td></tr>

</table></html:form><font color="red"><bean:write name="loginForm"

property="msg"></bean:write></font><br /></div></div>

<div class="post">



</div>


INTERFACE SOFTWARE BPUT UNIVERSITY</div>


<div id="sidebar-bgtop">

</div>

<div id="sidebar-content"><div id="sidebar-bgbtm"><ul><li><h2>Sign Here<br /></h2><ul>

<li><a href="Login.jsp">Login<br /></a></li>

<li><a href="Registration.jsp">New User<br /></a></li>

</ul></li><li>

<ul>

</li></ul>

</div></div>



</div>

<div id="footer">

</div><></body></html>

UserHome.jsp



<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><!--Design by Free CSS Templateshttp://www.freecsstemplates.orgReleased for free under a Creative Commons Attribution 2.5 License

INTERFACE SOFTWARE BPUT UNIVERSITY<div id="wrapper">






Us</a></li><li><a href="login.do?

submit=LogOut">Logout</a></li></ul>




<div class="post"><h1 class="title"><h2>Welcome To User Home



<p class="links">

<br /></div></div><div class="post">


</div>


INTERFACE SOFTWARE BPUT UNIVERSITY<div class="meta">

</div></div>


<div id="sidebar-bgtop">

</div>

<div id="sidebar-content"><div id="sidebar-bgbtm"><ul><li><h2><br /></h2><ul>

<li><a href="login.do?submit=viewProfile">My Profile<br /></a></li>

<li><a href="ChangePassword.jsp">Change Password</a></li>

<li><a href="login.do?submit=viewFlight">View Flight</a></li>

<li><a href="login.do?submit=myBooking">My Booking</a></li>

<li><a href="login.do?submit=cancelFlight">Cancellation<br /></a></li>

<li><a href="login.do?submit=viewAnnouncement">View Announcement<br /></a></li>

</ul></li><li>

<ul>

</li></ul>

</div></div>




</div>

<div id="footer">

</div><></body></html> MyProfile.jsp

<jsp:directive.page import="java.util.*"/><%@ page language="java" pageEncoding="ISO-8859-1"%>


<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"><html:html lang="true"> <head> <html:base /> <title>MyProfile.jsp</title>

<meta http-equiv="pragma" content="no-cache"><meta http-equiv="cache-control" content="no-

cache"><meta http-equiv="expires" content="0"> <meta http-equiv="keywords"

content="keyword1,keyword2,keyword3"><meta http-equiv="description" content="This is my

page"><!--<link rel="stylesheet" type="text/css"

href="styles.css">

INTERFACE SOFTWARE BPUT UNIVERSITY-->

</head> <body><!--Design by Free CSS Templateshttp://www.freecsstemplates.orgReleased for free under a Creative Commons Attribution 2.5 License



<div id="wrapper">





href="#">Home</a></li><li><a href="#">About Us</a></li><li><a href="#">Contact Us</a></li>

INTERFACE SOFTWARE BPUT UNIVERSITY</ul>




<div class="post"><h1 class="title"><h2>Welcome To My Profile

page......</h2> </h1><p class="byline"><div class="entry">

<html:form action="login.do?submit=viewProfile1">

<% ArrayList<String>

name=( ArrayList<String>)request.getAttribute("CUST");

%><table>

<tr><td>Customer Name</td><td><html:select property="cname" size="1">

<% for(int i=0;i <

name.size();i++) { %> <html:option

value="<%=name.get(i)%>"><%=name.get(i)%></html:option> <% } %>

</html:select></td></tr>

<tr><td>Address</td><td><html:textarea property="address"/></td></tr>



<tr><td>Gender</td><td><html:text property="gender"></html:text><br /></td></tr>

<tr><td>Mob. No</td><td><html:text property="mob"/></td></tr>

<tr><td>Email</td><td><html:text property="email"/></td></tr>

<br\><tr><td colspan="2"

align="center"><html:submit property="view" value="View"></html:submit></td></tr> </table>

</html:form>


<p class="links"></div>

</div><div class="post">



</div></div>


<div id="sidebar-bgtop"></div><div id="sidebar-content">

<div id="sidebar-bgbtm"><ul>

<li><h2> </h2><ul>


INTERFACE SOFTWARE BPUT UNIVERSITY<li><a href="login.do?

submit=editProfile">Edit Profile</a></li><li><a href="login.do?

submit=deleteProfile">Delete Profile</a></li>

</ul></li><li>

<ul>

</ul></li>

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



</div>

<div id="footer"><p>© 2008. All Rights Reserved. Design by <a

href="http://www.freecsstemplates.org/">Free CSS Templates</a>.</p></div></body></html>

</html:html>

LoginAction.java

package pp.action;

INTERFACE SOFTWARE BPUT UNIVERSITYimport java.sql.ResultSet;

import java.sql.SQLException;

import java.util.*;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import org.apache.struts.action.ActionForm;

import org.apache.struts.action.ActionForward;

import org.apache.struts.action.ActionMapping;

import org.apache.struts.actions.DispatchAction;

import pp.DBLogic;

import pp.form.LoginForm;

public class LoginAction extends DispatchAction {

public ActionForward Submit(ActionMapping

mapping, ActionForm form,

HttpServletRequest request,

HttpServletResponse response) throws SQLException

{

LoginForm loginForm = (LoginForm) form;

DBLogic dblogic=new DBLogic();

String fname=loginForm.getFname();

String uname=loginForm.getUname();

String pwd=loginForm.getPwd();

String gender=loginForm.getGender();

if(gender==null)

{

loginForm.setMsg("Plz Select Gender");

return mapping.findForward("subError");


INTERFACE SOFTWARE BPUT UNIVERSITY}

String email=loginForm.getEmail();

String address=loginForm.getAddress();

Long mob=loginForm.getMob();

System.out.println(fname+uname+pwd+gender+email+address+

mob);

int i=0;

i=dblogic.Submit(fname,uname,pwd,gender,email,address,mo

b);

loginForm.reset(mapping, request);

return mapping.findForward("submit");

}

public ActionForward Login(ActionMapping

mapping,ActionForm form,HttpServletRequest

request,HttpServletResponse response)throws SQLException

{

LoginForm loginForm=(LoginForm)form;


String uname=loginForm.getUname();

String pwd=loginForm.getPwd();

String type=loginForm.getType();

String msg="You Are Not Approved";

System.out.println(msg);

System.out.println(uname+" "+pwd+" "+type);

ResultSet rs=dblogic.Login(uname,pwd,type);

while(rs.next())

{ if(type.equals("admin"))



{

return mapping.findForward("admin");

}

if(type.equals("customer"))

{

ResultSet rs1=dblogic.retCId(uname);

Long id=null;

while(rs1.next())

{

id=rs1.getLong("CUSTOMERID");

System.out.println(id);

}

HttpSession

session=request.getSession();

session.setAttribute("CID", id);

return mapping.findForward("customer");

}}

loginForm.setMsg(msg);

loginForm.reset(mapping, request);

return mapping.findForward("notapp");

}

Public ActionForward viewProfile(ActionMapping



{

LoginForm loginForm=(LoginForm) form;


HttpSession session=request.getSession(true);


INTERFACE SOFTWARE BPUT UNIVERSITYLong id=(Long)session.getAttribute("CID");

ResultSet rs=dblogic.viewProfile(id);

ArrayList<String>

cname= new ArrayList<String>();

while(rs.next())

{

cname.add(rs.getString("NAME"));

System.out.println(cname);

}

request.setAttribute("CUST",cname);

return mapping.findForward("vprof");

}

public ActionForward viewProfile1(ActionMapping



{

LoginForm loginForm=(LoginForm) form;


HttpSession session=request.getSession(true);

Long id=(Long)session.getAttribute("CID");

ResultSet rs=dblogic.view9(id);

while(rs.next())

{

loginForm.setGender(rs.getString("GENDER"));

loginForm.setAddress(rs.getString("ADDRESS"));

loginForm.setMob(rs.getLong("PHONO"));

loginForm.setEmail(rs.getString("EMAIL"));

}

return viewProfile(mapping,form,request,response);


INTERFACE SOFTWARE BPUT UNIVERSITY }

LoginForm.java

package pp.form;

import javax.servlet.http.HttpServletRequest;

import org.apache.struts.action.ActionErrors;

import org.apache.struts.action.ActionForm;


public class LoginForm extends ActionForm

{ private String ruser;

private String nsub;

private String ncon;

private String suggestion;

private String comments;

private String ffname;

private String type;

private String email;

private String address;

private Long mob;

private String flight;

private String fno;

private String from;

private String to;

private Long atime;

private Long dtime;

private String clas;

private Long available;

private Long price;

private String cname;

private String doj;


INTERFACE SOFTWARE BPUT UNIVERSITY private String dob;

private String funame;

private Long nos;

private String mop;

private String dcs;

private String name;

private String feedback;

private String data;

private String announ;

private String opwd;

private String npwd;

private String vnnoun;

private String subject;

private String content;

private String ruse;

private String rpwd;

private String don;

private String snm;

private String epwd;

private String sugg;

private String euse;

private String gender;

private String cpwd;

private String lname;

private String fname;

private String pwd;

private String uname;

private String msg;

private String cnd;


INTERFACE SOFTWARE BPUT UNIVERSITYprivate String Suggestion;

public String getUname() {

return uname;}

public void setUname(String uname) {

this.uname = uname; }

public ActionErrors validate(ActionMapping mapping,

HttpServletRequest request) {

return null;}

public void reset(ActionMapping mapping,

HttpServletRequest request)

{ this.address=null;

this.ruser=null;

this.nsub=null;

this.ncon=null;

this.suggestion=null;

this.comments=null;

this.ffname=null;

this.type=null;

this.email=null;

this.address=null;

this.mob=null;

this.flight=null;

this.fno=null;

this.from=null;

this.to=null;

this.atime=null;

this.dtime=null;

this.clas=null;

this.available=null;


INTERFACE SOFTWARE BPUT UNIVERSITYthis.price=null;

this.cname=null;

this.doj=null;

this.dob=null;

this.funame=null;

this.nos=null;

this.mop=null;

this.dcs=null;

this.name=null;

this.feedback=null;

this.data=null;

this.announ=null;

this.opwd=null;

this.npwd=null;

this.vnnoun=null;

this.subject=null;

this.content=null;

this.ruse=null;

this.rpwd=null;

this.don=null;

this.snm=null;

this.epwd=null;

this.sugg=null;

this.euse=null;

this.gender=null;

this.cpwd=null;

this.lname=null;

this.fname=null;

this.pwd=null;


INTERFACE SOFTWARE BPUT UNIVERSITY this.uname=null;

this.msg=null;

this.cnd=null; }

public String getPwd() {

return pwd; }

public void setPwd(String pwd) {

this.pwd = pwd;

}

public String getEmail() {

return email;}

public void setEmail(String email) {

this.email = email; }

public String getAddress() {return address;}

public void setAddress(String address) {

this.address = address;}

public Long getMob() {

return mob;

}

public void setMob(Long mob) {

this.mob = mob; }

public String getFlight() {

return flight;}

public void setFlight(String flight) {

this.flight = flight; }

public String getFno() {

return fno;

}

public void setFno(String fno) {


INTERFACE SOFTWARE BPUT UNIVERSITYthis.fno = fno; }

public String getFrom() {

return from;

}

public void setFrom(String from) {

this.from = from;}

public String getTo() {return to;}

public void setTo(String to) {this.to = to;}

public Long getAtime() {return atime;}

public Long getDtime() {return dtime;}

public String getClas() {return clas;}

public void setClas(String clas) {this.clas = clas;}

public Long getAvailable() {return available;}

public void setAvailable(Long available) {

this.available = available;}

public Long getPrice() {return price;}

public void setPrice(Long price) {this.price = price;}

public String getCname() {return cname;}

public void setCname(String cname) {this.cname = cname;}

public String getDoj() {return doj;}

public void setDoj(String doj) {this.doj = doj;}

public String getDob() {return dob;}

public void setDob(String dob) {this.dob = dob;}

public String getFuname() {return funame;}

public void setFuname(String funame){

this.funame = funame;}

public Long getNos() {return nos;}

public void setNos(Long nos) {this.nos = nos;}


INTERFACE SOFTWARE BPUT UNIVERSITYpublic String getMop() {return mop;}

public void setMop(String mop) {this.mop = mop;}

public String getDcs() {return dcs;}

public void setDcs(String dcs) {this.dcs = dcs;}

public String getName() {return name;}

public void setName(String name) {this.name = name;

}

public String getFeedback() {return feedback;}

public void setFeedback(String feedback) {

this.feedback = feedback; }

public String getData() {return data;}

public void setData(String data) {this.data =

data;}

public String getAnnoun() {return announ;}

public void setAnnoun(String announ) {this.announ =

announ;}

public String getOpwd() { return opwd;}

public void setOpwd(String opwd) {this.opwd = opwd;}

public String getNpwd() {return npwd;}

public void setNpwd(String npwd) {this.npwd = npwd;}

public String getVnnoun() {return vnnoun;}

public void setVnnoun(String vnnoun) {this.vnnoun =

vnnoun;}

public String getSubject() {return subject;}

public void setSubject(String subject) {

this.subject = subject;}

public String getContent() {return content;}

public void setContent(String content) {this.content =

content;}


INTERFACE SOFTWARE BPUT UNIVERSITYpublic String getRuse() {return ruse;}

public void setRuse(String ruse) {this.ruse = ruse;}

public String getRpwd() {return rpwd;}

public void setRpwd(String rpwd) {this.rpwd = rpwd;}

public String getDon() {return don;}

public void setDon(String don) {this.don = don;}

public String getSnm() {return snm;}

public void setSnm(String snm) {this.snm = snm;}

public String getEpwd() {return epwd;}

public void setEpwd(String epwd) {this.epwd = epwd;}

public String getSugg() {return sugg;}

public void setSugg(String sugg) {this.sugg = sugg;}

public String getEuse() {return euse;}

public void setEuse(String euse) {this.euse = euse;}

public String getGender() {return gender;}

public void setGender(String gender) {this.gender =

gender;}

public String getCpwd() {return cpwd;}

public void setCpwd(String cpwd) {this.cpwd = cpwd;}

public String getLname() {return lname;}

public void setLname(String lname) {this.lname = lname;}

public String getFname() {return fname;}

public void setFname(String fname) {this.fname = fname;}

public String getType(){return type;}

public void setType(String type) {this.type = type;}

public String getMsg() {return msg;}

public void setMsg(String msg) {this.msg = msg;}

public void setAtime(Long atime) {this.atime = atime;}

public void setDtime(Long dtime) {this.dtime = dtime;}


INTERFACE SOFTWARE BPUT UNIVERSITYpublic String getFfname() {return ffname;}

public void setFfname(String ffname) {this.ffname =

ffname;}

public String getComments() {return comments;}

public void setComments(String comments) {this.comments

= comments;}

public String getSuggestion() {return suggestion;}

public void setSuggestion(String suggestion) {

this.suggestion = suggestion;}

public String getRuser() {return ruser;}

public void setRuser(String ruser) {this.ruser = ruser;}

public String getNsub() {return nsub;}

public void setNsub(String nsub) {this.nsub = nsub;}

public String getNcon() {return ncon;}

public void setNcon(String ncon) {this.ncon = ncon;}

public String getCnd() {return cnd;}

public void setCnd(String cnd) {this.cnd = cnd;}

}

DBLogic.java

package pp;

import java.util.*;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;


import pp.form.LoginForm;

public class DBLogic {


INTERFACE SOFTWARE BPUT UNIVERSITYpublic int Submit(String fname,String uname,String

pwd,String gender,String email,String address,Long

mob)throws SQLException{

int i=0;

Statement st=DBConnect.getStatement();

st.executeUpdate("insert into LOGIN

values(LID_SEQ.nextval,'"+uname+"','"+pwd+"','customer')

");

i=st.executeUpdate("insert into CUSTOMERDETAILS

values(RID_SEQ.nextval,'"+fname+"','"+address+"','"+emai

l+"','"+gender+"',"+mob+",lid_seq.currval)");

return i;

}

public ResultSet Login(String uname,String pwd,String

type) throws SQLException{

ResultSet

rs=DBConnect.getStatement().executeQuery("select * from

Login where username='"+uname+"' and password='"+pwd+"'

and type='"+type+"'");

return rs;

}

public ResultSet viewProfile(Long id)throws SQLException

{

ResultSet


CUSTOMERDETAILS where CUSTOMERID="+id+"");

return rs;

}


INTERFACE SOFTWARE BPUT UNIVERSITY public ResultSet view9(Long id)throws SQLException

{

ResultSet


CUSTOMERDETAILS where CUSTOMERID="+id+"");

Return

rs;

}

DBConnect.java

package pp;

import java.sql.DriverManager;

import java.sql.*;

public class DBConnect {

public static Statement getStatement()

{

Connection con=null;

Statement st=null;

ResultSet rs=null;

try{

Class.forName("oracle.jdbc.driver.OracleDriver");

con=DriverManager.getConnection("jdbc:oracle:thin:@local

host:1521:XE","bubu","bubu");

st=con.createStatement();

}

catch(Exception err){


INTERFACE SOFTWARE BPUT UNIVERSITYSystem.out.println(err.getMessage());

}

return st;

}

}


INTERFACE SOFTWARE BPUT UNIVERSITY7.CONCLUSION

The project “AIRLINE RESERVATION SYSTEM” has been

developed as per the requirements specification of the Interface Software .It has

been developed in Servlet,jsp and struts in frontend and SQL server in backend.

The complete system is thoroughly tested with the availability data and

throughput reports are verified with reports which are prepared manually.

It has been observed that the report generation is easier and now

compared with the manual operation. These are found to be more accurate

because of availability of information from various levels. Design procedure and

output reports are presented in this project report. This design is so flexible that

any new modules can be incorporated easily.

8. APPENDICES

7.1. SYSTEM REQUIREMENTS

8.1.1. Software specification

Operating System : windows’2k

Front end : java, servlet, jsp, html

Back end : SQL Server 2000

Server : Weblogic Bea server 9.0

8.1.2. Hardware specification


INTERFACE SOFTWARE BPUT UNIVERSITY CPU type : Pentium IV

Memory : 256 MB RAM

Hard disk : 20 GB hdd

Key board : 110 keys

8.1.3. Drive summary

CDROM Monitor : 15’’color monitor

:



9. BIBILIOGRAPHY

The Complete reference java2... By Herbert Schildt …….

Tata McGraw Hill Publication.

Pure JSP By James Goodwill Dream Tech Publication.

A Beginner’s guide JSP By Madhushree Ganguli Wiley

Publishing .

Teach Yourself Web-Technologies (I & II) By Ivan Bay Ross

BPB Publication.

Oracle 9i Complete reference Oracle Oracle Corporation TMH

Analysis and Design of Information System …. By James A. Senn

The Complete reference Struts…..James Holmes…………..TMH


55064408 Airline Reservation Sysytem

Documents

Transcript of 55064408 Airline Reservation Sysytem