Courier Project Report

8/10/2019 Courier Project Report

http://slidepdf.com/reader/full/courier-project-report 1/99

1



2

Introduction

This Project aims to model the working of a Courier Management System. ThisProject uses Java as the programming Language.

Today’s world is very fast and competitive. To achieve the success in this

competitive world, one should be aware of the computer and the information

related to the concerned business because computer and the information plays an

important weeks manually. Right information available at the right place makes

the decision process efficient. Hence the identification of the current and futurerequirement becomes a basic need of any flexible information system

Courier management system is software which is used manage the work

regarding the services of the courier in an effective & efficient manner.

Basically it stores the information regarding the customer and his material,

which has to be couriered.

This project is based on the 2-tier architecture. The Project is developed keeping

in mind the security needs of today. The project is totally built at administrative

end and thus only the administrator is guaranteed the access.



3

Objective

The software aims at making the work of the entire staff of the CourierDepartment very easy, to save their time. To maintain their documents, to

maintain their tasks performed in timely manner. The system saves your time

and gives out the accurate documentation.

The proposed system has been designed in such a way that can be operated by

various kinds of users. The working of software is very easy to understand it is

very graphical and it is user friendly.

This new system is built with the following objective:

1) Information retrieval will become easy.

2) Maintenance of database as well as overall project will become easy.

3) Security measure will be adopted, by maintaining the login of username and

the password.

4) Data redundancy will be greatly reduced.



4

System Analysis

System analysis is a process of gathering and interpreting facts,

diagnosing problems and the information to recommend improvements on the

system. It is a problem solving activity that requires intensive communication

between the system users and system developers. System analysis or study is an

important phase of any system development process. The system is studied to

the minutest detail and analyzed. The system analyst plays the role of the

interrogator and dwells deep into the working of the present system. The system

is viewed as a whole and the input to the system are identified. The outputs from

the organizations are traced to the various processes. System analysis is

concerned with becoming aware of the problem, identifying the relevant and

decisional variables, analyzing and synthesizing the various factors and

determining an optimal or at least a satisfactory solution or program of action.

Identification of Need

The 1st step of the system analysis procedure involves the identification of

requirement. The analyst system engineer meets with the customer and the end

user if different from the customer. Customer may be a representative of an

outside organization the marketing department of the analyst's organization

when a product is being established or another technical department when an

internal system is to be established. Like information engineering the intent is to

understand the product's goal and to describe the target wants to meet the goal.

Once overall target are identified the analyst moves on to an evaluation of

supplementary information that are: Does the technology exist to build the

system? What special manufacturing and development resources will be

needed? What bounds have been placed on schedule and costs? If the newsystem is really a product to be established for sale to various customers the

following questions are also asked that are how does this product compare with

competitive products? What is the potential market for the product? What

position does this product take in the overall product line of the organization?



5

Information collection during the requirement identification step is specified in a

system concept document. The real concept document is sometimes built

through the customer previously meetings with the analyst. Regularly customer-

analyst communication results in changes to the document.

EXISTING SYSTEM

The courier system involves a lot of the employees at the office.

The data for a particular courier maintained in a proper file. A person

summarizes all the data of the courier in a register, this work require a high-level

of attention since it has to be taken care that no wring entry goes into the

register. This repetitive work may lead to errors in the entry thus resulting in the

wrong entry of courier packed data.

Since the data is maintained in the registers, the modification of data

cannot do easily. The previous information has to be erased and overwritten or a

new page has to be allocated so that both the old and new information can be

written on the same page.

The summarizing of the data i.e. preparation of an up to data report is verycomplex, it require a lot of hard work and searching through the different

register so as to condense the data for presentation.

LIMITATIONS OF EXISTING SYSTEM

From the client site, the entire work was achieved manually and they manage all

their billing and services manually. Because of the manual system there are so

many problems occurred in the existing system: -

It involves managing a huge number of data each having separate data

items.

All the work is done at a very large volume, so we have a possibility of

losing the data.



6

To look for a particular problem the entire system is searched, so the

process becomes more time consuming.

PROPOSED SYSTEM

After a detailed study of the existing system, it is evident that is does not

fulfill the objective of the organization. To make the objective possible for

the organization, it is required to have a computerized information system

with the help of which all tasks can be processed more accurately and

quickly. To achieve this, it is necessary to design and develop a new system.

Proposed system is being designed in such a way that many users can have a

view with the system simultaneously. it makes effective and perfect

utilization of man power and resources.

ADVANTAGES

User satisfaction: The system is such that is stands up to the user

expectations like easy and faster retrieval of information.

Safety: The system will be accessible by only the authorized users. Asinformation being the most crucial for the organization, then the safety of

information is importation.

Highly accurate: resources being used by the system will be compatible

with the latest technologies available in the market

Less time consuming: work carried out by the staff at various stages will

be less time consuming

Feasibility Study

Feasibility study is the detailed study expanded from the result of initial

investigation. This is done by investigating the existing system in the area under



7

investigation or generally ideas about a new system. It is the test of a system

proposal according to its work ability, impact on organization, ability to meet

user needs and effective use of resources. Objective of feasibility study is to

acquire a sense of the scope of the problem. It is carried out to select the best

system that meets performance requirements.

Feasibility analysis involves the following steps:

Form a project and appoint a project leader

Prepare system flowcharts

Weigh system performance

Prepare and report final project directive to management

There are three key considerations involved in feasibility analysis namely:

Economic feasibility

Technical feasibility

Operational feasibility

Economic Feasibility:

Economic feasibility is used to determine the benefits and savings expected

from the candidate system and to compare them with costs incurred. If benefits

outweigh cost, then decision will be to design and implement system. Otherwise,

alterations will have to be made to the proposed system. The proposed system is

economically feasible.

Technical Feasibility:

Technical feasibility centers on existing system and to what extent it can support

proposed modifications. It involves financial enhancement. This evaluation

determines whether the technology needed for the proposed system is available



8

or not. This is concerned with specifying satisfy the user requirements. The

technical needs of the system may include front-end and backend-selection.

An important issue for the development of a project is the selection of suitable

front-end and back-end. Based on some aspects, we select the most suitable

platform that suits the needs of the organization.

Operational Feasibility:

The present system is easily understandable. The users are presented with

friendly user interface that helps them to understand the flow of the system more

easily. Maximum transparency has been provided. The new system is very much

user friendly and operational cost is bearable. The maintenance and working of

the new system needs less human efforts. The proposed project is beneficial tothe organizational and is user friendly.



9

PERT Chart

Start Collect

Information

Survey Report

Format Design

Visit Office

Meet end user Meet manager Visit In

Integrate all these

Coding of Project

Finish



10

GANTT Chart

A Gantt chart is a horizontal bar chart developed as a production control tool

in 1917 by Henry L. Gantt, an American engineer and social scientist. A Gantt

chart provides a graphical illustration of a schedule that helps to plan,

coordinate and track specific tasks in a project.

ACTIVITY 11/05-

18/05

18/05-

25/05

1/06-

10/06

11/06-

20/06

01/08-

10/09

12/09-18/09 19/09-

25/09

Project

Search

Finalization&

Allocation

Investigation

of system

requirement

System

Design

Program

design

Program

coding

Systemintegration

Acceptance

test



11

Software Development Life Cycle

There are a large number of software models used for guiding the

software development process. Normally every software model contains

almost same life cycle except there are some difference process

techniques. In this software we have used the linear sequential model

because it is easiest one to implement and we have to follow the

straightforward techniques for developing the software. There are

following steps we have done through in the complete process.

ANALYSIS:- In this step we have gathered the different requirement to

develop the software, to understand the nature of the program to be buildand all the requirement for both the system and the users has been

identified.

DESIGN:- Software design is actually a group of process that a group of

that focuses on four distinct attribute of a program- data structure,

software architecture, interface representation and procedural detail the

design process translates requirements into a representation of the software

that can be accessed for quality before coding begins. Like requirements

the design is documented becomes part of the software configuration

CODE GENERATION:- The design must be translated into a machine

readable from to develop the software. The code generation step performs

this task. If design is performed in a detail manner, this code generation

can accomplish EASILY.

TESTING:- Once code has been generated the program testing begins.

The testing begins. The testing process focuses on the logical internals of

the software, ensuring that all statement have been tested and on the

functional externals, that is conducting tests to uncover errors and ensure

that defined input will produce actual result that agree with required

result.





13

SOFTWARE REQUIREMENT SPECIFICATION

PURPOSE:

―Courier Management System‖ is a Desktop GUI application that has been

designed to automate the process of courier management system. System can

make the daily activities efficient and providing the fast response to store and

retrieve information.

The purpose of the Airline Reservation System Project is to build an

application program, which an airline could use to manage the reservation of

airline tickets. Passengers make flight reservations through the ticketing staff ofthe airline, which can access a centralized system to check on flight details. The

system able to create flights, delete flights and reserve seats for passengers

according to their requested Destination, day and time



14

HARDWARE AND SOFTWARE REQUIREMENTS

HARDWARE CONFIGURATION

1. Processor Pentium IV with 3.0 GHz.

2. RAM 512MB

3. HDD 40GB

4. Monitor 15‖ Color monitor with 16 million colors

5. Pointing device Two - button Mouse or 3-button Mouse.

6. Keyboard 104 Keys

SOFTWARE CONFIGURATION

1)

FRONT END Net beans (Java)

2) Platform Microsoft Windows

3) Back End Oracle 10G



15

Description of Technology Used in Project.

JAVA

Java is a small, simple, safe, object oriented, interpreted or

dynamically optimized, byte coded, architectural, garbage collected,

multithreaded programming language with a strongly typed exception-handling

for writing distributed and dynamically extensible programs.

Java is an object oriented programming language. Java is a high-level,

third generation language like C, FORTRAN, Small talk, Pearl and many others.

You can use java to write computer applications that crunch numbers, process

words, play games, store data or do any of the thousands of other things

computer software can do.Special programs called applets that can be downloaded from the internet and

played safely within a web browser. Java a supports this application and the

follow features make it one of the best programming languages.

It is simple and object oriented

It helps to create user friendly interfaces.

It is very dynamic.

It supports multithreading.

It is platform independent

It is highly secure and robust.

It supports internet programming

Java is a programming language originally developed by Sun

Microsystems and released in 1995 as a core component of Sun's Java platform.

The language derives much of its syntax from C and C++ but has a simpler

object model and fewer low-level facilities. Java applications are typically

compiled to byte code which can run on any Java virtual machine (JVM)

regardless of computer architecture.

The original and reference implementation Java compilers, virtual machines,

and class libraries were developed by Sun from 1995. As of May 2007, in

compliance with the specifications of the Java Community Process, Sun made

available most of their Java technologies as free software under the GNU



16

General Public License. Others have also developed alternative implementations

of these Sun technologies, such as the GNU Compiler for Java and GNU Class

path.

The Java language was created by James Gosling in June 1991 foruse in a set top box project. The language was initially called Oak , after an oak

tree that stood outside Gosling's office - and also went by the name Green - and

ended up later being renamed to Java, from a list of random words. Gosling's

goals were to implement a virtual machine and a language that had a familiar

C/C++ style of notation.

Primary goals

There were five primary goals in the creation of the Java language:

1. It should use the object-oriented programming methodology.

2.

It should allow the same program to be executed on multiple operating systems.

3.

It should contain built-in support for using computer networks.

4.

It should be designed to execute code from remote sources securely.

5. It should be easy to use by selecting what were considered the good parts of

other object-oriented languages.

The Java platform is the name for a bundle of related programs, or

platform, from Sun which allow for developing and running programs written in

the Java programming language. The platform is not specific to any one

processor or operating system, but rather an execution engine (called a virtual

machine) and a compiler with a set of standard libraries which are implemented

for various hardware and operating systems so that Java programs can run

identically on all of them.

Different "editions" of the platform are available, including:

Java ME (Micro Edition): Specifies several different sets of libraries (known as

profiles) for devices which are sufficiently limited that supplying the full set of

Java libraries would take up unacceptably large amounts of storage.



17

Java SE (Standard Edition): For general purpose use on desktop PCs, servers

and similar devices.

Java EE (Enterprise Edition): Java SE plus various APIs useful for multi-tier

client-server enterprise applications.

The Java Platform consists of several programs,

each of which provides a distinct portion of its overall capabilities. For example,

the Java compiler, which converts Java source code into Java bytecode (an

intermediate language for the Java Virtual Machine (JVM)), is provided as part

of the Java Development Kit (JDK). The sophisticated Java Runtime

Environment (JRE), complementing the JVM with a just-in-time (JIT) compiler,

converts intermediate bytecode into native machine code on the fly. Also

supplied are extensive libraries (pre-compiled into Java bytecode) containing

reusable code, as well as numerous ways for Java applications to be deployed,

including being embedded in a web page as an applet.There are several other

components, some available only in certain editions.

The essential components in the platform are the Java language

compiler, the libraries, and the runtime environment in which Java intermediate

byte code "executes" according to the rules laid out in the virtual machine

specification.

Java Virtual Machine

The heart of the Java Platform is the concept of a "virtual machine" that

executes Java byte code programs. This byte code is the same no matter what

hardware or operating system the program is running under. There is a JIT

compiler within the Java Virtual Machine, or JVM. The JIT compiler translates

the Java byte code into native processor instructions at run-time and caches the

native code in memory during execution.

The use of byte code as an intermediate language

permits Java programs to run on any platform that has a virtual machine

available. The use of a JIT compiler means that Java applications, after a short

delay during loading and once they have "warmed up" by being all or mostly

JIT-compiled, tend to run about as fast as native programs. Since JRE version



18

1.2, Sun's JVM implementation has included a just-in-time compiler instead of

an interpreter.

Although Java programs are Platform Independent, the

code of the Java Virtual Machine (JVM) that execute these programs are not.Every Operating System has its own JVM.

Class libraries

In most modern operating systems, a large body of reusable code is

provided to simplify the programmer's job. This code is typically provided as a

set of dynamically loadable libraries that applications can call at runtime.

Because the Java Platform is not dependent on any specific operating system,

applications cannot rely on any of the existing libraries. Instead, the JavaPlatform provides a comprehensive set of standard class libraries, containing

much of the same reusable functions commonly found in modern operating

systems.

The Java class libraries serve three purposes within the Java

Platform. Like other standard code libraries, they provide the programmer a

well-known set of functions to perform common tasks, such as maintaining lists

of items or performing complex string parsing. In addition, the class libraries provide an abstract interface to tasks that would normally depend heavily on the

hardware and operating system. Tasks such as network access and file access are

often heavily dependent on the native capabilities of the platform. The Java

java.net and java.io libraries implement the required native code internally, then

provide a standard interface for the Java applications to perform those tasks.

Finally, when some underlying platform does not support all of the features a

Java application expects, the class libraries can either emulate those features

using whatever is available, or at least provide a consistent way to check for the

presence of a specific feature.

Platform independence

One characteristic, platform independence, means that programs written in the

Java language must run similarly on any supported hardware/operating-system



19

platform. One should be able to write a program once, compile it once, and run

it anywhere.

This is achieved by most Java compilers by compiling the Java language code

halfway (to Java bytecode) – simplified machine instructions specific to the Java platform. The code is then run on a virtual machine (VM), a program written in

native code on the host hardware that interprets and executes generic Java

bytecode. (In some JVM versions, bytecode can also be compiled to native code,

either before or during program execution, resulting in faster execution.)

Further, standardized libraries are provided to allow access to features of the

host machines (such as graphics, threading and networking) in unified ways.

The first implementations of the language used an interpreted virtual machine to

achieve portability. These implementations produced programs that ran more

slowly than programs compiled to native executables, for instance written in C

or C++, so the language suffered a reputation for poor performance. More recent

JVM implementations produce programs that run significantly faster than

before, using multiple techniques.

One technique, known as just-in-time compilation (JIT), translates

the Java bytecode into native code at the time that the program is run, which

results in a program that executes faster than interpreted code but also incurscompilation overhead during execution. More sophisticated VMs use dynamic

recompilation, in which the VM can analyze the behavior of the running

program and selectively recompile and optimize critical parts of the program.

Dynamic recompilation can achieve optimizations superior to static compilation

because the dynamic compiler can base optimizations on knowledge about the

runtime environment and the set of loaded classes, and can identify the hot spots

(parts of the program, often inner loops, that take up the most execution time).

JIT compilation and dynamic recompilation allow Java programs to take

advantage of the speed of native code without losing portability.

Another technique, commonly known as static compilation, is to compile

directly into native code like a more traditional compiler. Static Java compilers,

such as GCJ, translate the Java language code to native object code, removing

the intermediate bytecode stage. This achieves good performance compared to



20

interpretation, but at the expense of portability; the output of these compilers can

only be run on a single architecture. Some see avoiding the VM in this manner

as defeating the point of developing in Java; however it can be useful to provide

both a generic bytecode version, as well as an optimised native code version of

an application.

Automatic memory management

One of the ideas behind Java's automatic memory management model is that

programmers be spared the burden of having to perform manual memory

management. In some languages the programmer allocates memory for the

creation of objects stored on the heap and the responsibility of later deallocating

that memory also resides with the programmer. If the programmer forgets to

deallocate memory or writes code that fails to do so, a memory leak occurs and

the program can consume an arbitrarily large amount of memory. Additionally,

if the program attempts to deallocate the region of memory more than once, the

result is undefined and the program may become unstable and may crash.

Finally, in non garbage collected environments, there is a certain degree of

overhead and complexity of user-code to track and finalize allocations. Often

developers may box themselves into certain designs to provide reasonable

assurances that memory leaks will not occur.

In Java, this potential problem is avoided by automatic garbage collection. The

programmer determines when objects are created, and the Java runtime is

responsible for managing the object's lifecycle. The program or other objects can

reference an object by holding a reference to it (which, from a low-level point of

view, is its address on the heap). When no references to an object remain, the

Java garbage collector automatically deletes the unreachable object, freeing

memory and preventing a memory leak. Memory leaks may still occur if a

programmer's code holds a reference to an object that is no longer needed — in

other words, they can still occur but at higher conceptual levels.

The use of garbage collection in a language can also affect programming

paradigms. If, for example, the developer assumes that the cost of memory

allocation/recollection is low, they may choose to more freely construct objects

instead of pre-initializing, holding and reusing them. With the small cost of



21

potential performance penalties (inner-loop construction of large/complex

objects), this facilitates thread-isolation (no need to synchronize as different

threads work on different object instances) and data-hiding. The use of transient

immutable value-objects minimizes side-effect programming.

Comparing Java and C++, it is possible in C++ to implement similar

functionality (for example, a memory management model for specific classes

can be designed in C++ to improve speed and lower memory fragmentation

considerably), with the possible cost of adding comparable runtime overhead to

that of Java's garbage collector, and of added development time and application

complexity if one favors manual implementation over using an existing third-

party library. In Java, garbage collection is built-in and virtually invisible to the

developer. That is, developers may have no notion of when garbage collection

will take place as it may not necessarily correlate with any actions being

explicitly performed by the code they write. Depending on intended application,

this can be beneficial or disadvantageous: the programmer is freed from

performing low-level tasks, but at the same time loses the option of writing

lower level code. Additionally, the garbage collection capability demands some

attention to tuning the JVM, as large heaps will cause apparently random stalls

in performance.

Java does not support pointer arithmetic as is supported in, for example, C++.This is because the garbage collector may relocate referenced objects,

invalidating such pointers. Another reason that Java forbids this is that type

safety and security can no longer be guaranteed if arbitrary manipulation of

pointers is allowed.

Performance

Java's performance has improved substantially since the early

versions, and performance of JIT compilers relative to native compilers has in

some tests been shown to be quite similar. The performance of the compilers

does not necessarily indicate the performance of the compiled code; only careful

testing can reveal the true performance issues in any system.



22

Java Runtime Environment

The Java Runtime Environment, or JRE , is the software required to

run any application deployed on the Java Platform. End-users commonly use aJRE in software packages and Web browser plugins. Sun also distributes a

superset of the JRE called the Java 2 SDK (more commonly known as the JDK),

which includes development tools such as the Java compiler, Javadoc, Jar and

debugger.

One of the unique advantages of the concept of a runtime engine is that

errors (exceptions) should not 'crash' the system. Moreover, in runtime engine

environments such as Java there exist tools that attach to the runtime engine and

every time that an exception of interest occurs they record debugginginformation that existed in memory at the time the exception was thrown (stack

and heap values). These Automated Exception Handling tools provide 'root-

cause' information for exceptions in Java programs that run in production,

testing or development environments.

.



23

Data Flow Diagram

A data flow diagram is graphical tool used to describe and analyze

movement of data through a system. These are the central tool and the basis

from which the other components are developed. The transformation of data

from input to output, through processed, may be described logically and

independently of physical components associated with the system. These are

known as the logical data flow diagrams. The physical data flow diagrams show

the actual implements and movement of data between people, departments andworkstations. A full description of a system actually consists of a set of data

flow diagrams. Using two familiar notations Yourdon, Gane and Sarson

notation develops the data flow diagrams. Each component in a DFD is labeled

with a descriptive name. Process is further identified with a number that will be

used for identification purpose. The development of DFD’S is done in several

levels. Each process in lower level diagrams can be broken down into a more

detailed DFD in the next level. The lop-level diagram is often called context

diagram. It consist a single process bit, which plays vital role in studying the

current system. The process in the context level diagram is exploded into other

process at the first level DFD.

The idea behind the explosion of a process into more process is that

understanding at one level of detail is exploded into greater detail at the next

level. This is done until further explosion is necessary and an adequate amount

of detail is described for analyst to understand the process.

Larry Constantine first developed the DFD as a way of expressing system

requirements in a graphical from, this lead to the modular design.

A DFD is also known as a ―bubble Chart‖ has the purpose of clarifying

system requirements and identifying major transformations that will become

programs in system design. So it is the starting point of the design to the lowest



24

level of detail. A DFD consists of a series of bubbles joined by data flows in the

system.

DFD SYMBOLS:

In the DFD, there are four symbols

1. A square defines a source (originator) or destination of system data.

2. An arrow identifies data flow. It is the pipeline through which the

information flows

3. A circle or a bubble represents a process that transforms incoming data flow

into outgoing data flows.

4.

An open rectangle is a data store, data at rest or a temporary repository of

data

Process that transforms data flow.

Source or Destination of data



25

Data flow

Data Store

CONSTRUCTING A DFD:

Several rules of thumb are used in drawing DFD’S:

1. Process should be named and numbered for an easy reference. Each name

should be representative of the process.

2. The direction of flow is from top to bottom and from left to right. Data

traditionally flow from source to the destination although they may flow back

to the source. One way to indicate this is to draw long flow line back to a

source. An alternative way is to repeat the source symbol as a destination.Since it is used more than once in the DFD it is marked with a short diagonal.

3.

When a process is exploded into lower level details, they are numbered.

4. The names of data stores and destinations are written in capital letters.

Process and dataflow names have the first letter of each work capitalized



26

Context Diagram

Manages

Place

Consi nment

Courier

Management

CONSIGNER

ADMINISTRATOR



27

DFD for Booking Ticket



28

DFD For Cancel Ticket



29

DFD For Flight Enquiry

Invalid Fli ht

Flight Code For

Searching

Accessing Flight Info

Flight Info

Accessing Flight Info

Valid Flight For Display

FLIGHT

Search Process

Display Process

1 Flight



30

DFD FOR TICKET ENQUIRY

Invalid Ticket

Ticket Code For

Searching

Accessing Ticket Info

Ticket Info

Accessing Ticket Info

Valid Ticket ForDisplay

TICKET

Search Process

Display Process

1 Ticket



31

DFD FOR USER LOGIN

Invalid User Matched

Accessin User Information

Valid User For Software Access

User Enter Their Password & User_id for opening the

application

USER

1 USER_ID

CMS

Password

Validity



32

ER Diagram



33

System Design

INPUT DESIGN

Input design is the process of converting a user-oriented description of the inputs

to a computer based business system into a programmer-oriented specification.

Inaccurate input data is the most common cause of processing errors. Effective

input design minimizes errors made by data entry operators. The input design is

the link that ties information system into the world of its users. Input design

consists of developing specific procedures for data preparations, steps necessaryto put the transaction data in the form that is usable for computer processing.

The data entry operator need to know the space allocated for each field, the field

sequence which must match with the source document and the format in which

the data is entered.

This project ―Airline Reservation System‖ has got several inputs taken from the

user. They are:

Details of Flights.

Details Of passengers.

Details of Ticket Booking and Cancellation

The system is provided with Java pages for the user to input above details. Only

the administrator and registered user are able to upload data. So their details are

the major inputs to the system.



34

OUTPUT DESIGN

Outputs form computer systems are required primarily to communicate the

processing to the end users. The output of the system designed in such a way

that it provides, opportunities, problem or warnings, trigger an action andconfirm an action. The user-friendly interfaces provide a clear output to the

system.

The output of this software system is a Window Application. This system

consists of displaying Flight details, List of booked Ticket, list of cancelled

Tickets.

Module design:

Software design sits at the technical kernel of the software engineering

process and is applied regardless of the development paradigm and area of

application. Design is the first step in the development phase for any engineered

product or system. The designer’s goal is to produce a model or representation

of an entity that will later be built. Beginning, once system requirement have

been specified and analyzed, system design is the first of the three technical

activities -design, code and test that is required to build and verify software.

The importance can be stated with a single word ―Quality‖. Design is the

place where quality is fostered in software development. Design provides us

with representations of software that can assess for quality. Design is the only

way that we can accurately translate a customer’s view into a finished software

product or system. Software design serves as a foundation for all the software

engineering steps that follow. Without a strong design we risk building an

unstable system – one that will be difficult to test, one whose quality cannot be

assessed until the last stage.

During design, progressive refinement of data structure, program

structure, and procedural details are developed reviewed and documented.

System design can be viewed from either technical or project management

perspective. From the technical point of view, design is comprised of four



35

activities – architectural design, data structure design, interface design and

procedural design.

MODULES

Modules of Project are as Follows:

There are 5 modules in this project.

Administrator Module.

Reservation Module.

Search Module.

Payment.

Cancellation.

Administrator Module.

Enables the administrator to perform all administrative functions and

manage inventory over LAN. The administrator can define or modify routes,

fares schedules and assign or deny access for authorized users.

Reservation Module.This module is used for booking the ticket.

Search Module.

This module is used to search the Flights on the basis of source, destination

and routes.

Payment.

It provides the airline system with the ability to set up various payment

options for reservations.



36

Cancellation.

This module is used to cancel the existing booking.



37

DATABASE DESIGN

TABLES

1. dbdetails : This table store the details of Delivery Boy Details.

Field

Name

Type Size constraints

Delid Varchar 5 PRIMARY KEY

Delname Varchar 25 NOT NULL

City Varchar 20 NOT NULL

Address Varchar 50 NOT NULL

Mobileno Varchar 10 -

2. Employee

This table is used to store employee details.

Field name Data Type Size constraints

Emp_id Varchar 5 PRIMARY KEY

emp_name Varchar 25 NOT NULL

emp_address Varchar 50 NOT NULL

Emp_phone Varchar 11 NOT NULL



38

3. Calculation

This table is used to Charge Details.

Field name Data type Size

destination Varchar 30

Charge_per_gram Number 3

4. courier_details

This table is used to store the Consignment Details.

Field name Data type Size constraints

courier_id Number(4) 10 PRIMARY KEY

s_name Varchar 30 NOT NULL

s_address Varchar 50 NOT NULL

S_city Varchar 25 NOT NULL

S_state Varchar 25 NOT NULL

s_phone Varchar 11 NOT NULL

r_name Varchar 30 NOT NULL



39

r_address Varchar 50 NOT NULL

r_city Varchar 25 NOT NULL

R_state Varchar 25 NOT NULL

r_phone Varchar 11 NOT NULL

Status Varchar 25 NOT NULL

Amount Number 5 NOT NULL

Description Varchar 255 NOT NULL

empid varchar 5 Foreign Key

1. Login

Field name Data type Size Constraints

username Varchar 25 Primary Key

password Varchar 25 NOT NULL

type Varchar 25 NOT NULL



40

Coding

Login.java

package project;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import javax.swing.JOptionPane;

public class login extends javax.swing.JFrame {

Connection con;

PreparedStatement ps;

ResultSet rs;

static String n;

public login() {

initComponents();

conn();

}

void conn()

{

try

{



41

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

Connection con =

DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:XE","air","air

");

}

catch(Exception exp)

{

JOptionPane.showMessageDialog(this,exp.getMessage());

}

}

private void btn1ActionPerformed(java.awt.event.ActionEvent evt) {

try

{

String p=String.valueOf(pass.getPassword());

String s="select Pwd from login where User_Id=?";

ps=con.prepareStatement(s);

ps.setString(1,txt1.getText());

rs=ps.executeQuery();

if(rs.next())

{

if(p.equals(rs.getString("Pwd")))

{

n=txt1.getText();



42

JOptionPane.showMessageDialog(this,"Welcome"+" "+n);

new menus().setVisible(true);

setVisible(false);

}

else

{

JOptionPane.showMessageDialog(this,"password incorrect");

}

}

else

{

JOptionPane.showMessageDialog(this,"username password not

found");

}

}

catch(Exception ex)

{

JOptionPane.showMessageDialog(this,ex.getMessage());

}

}




43

txt1.setText(null);

pass.setText(null);

}

public static void main(String args[]) {

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

new login().setVisible(true);

}

});

}

// Variables declaration - do not modify

private javax.swing.JButton btn1;

private javax.swing.JButton btn2; private javax.swing.JLabel jLabel1;

private javax.swing.JPanel jPanel1;

private javax.swing.JLabel lbl1;

private javax.swing.JLabel lbl2;

private javax.swing.JPasswordField pass;

private javax.swing.JTextField txt1;

// End of variables declaration

}



44

Flightenuiry.java

package project;





import java.util.Vector;


import javax.swing.table.DefaultTableModel;

public class Flightenquery extends javax.swing.JFrame {

Connection con;


ResultSet rs;Vector<String> col;

Vector<Vector<String>> data;

public Flightenquery() {

initComponents();

conn();

add();

}

void conn()

{



45

try

{


Connection con =


");

}

catch(Exception ex)

{

JOptionPane.showMessageDialog(this, ex.getMessage());

}

}

void add()

{

cbox1.addItem("Select City");

cbox1.addItem("NEW DELHI");

cbox1.addItem("MUMBAI");

cbox1.addItem("LUCKNOW");

cbox1.addItem("KANPUR");

cbox1.addItem("KOLKATTA");

cbox1.addItem("CHENNAI");

cbox1.addItem("BANGLORE");

cbox1.addItem("HYDRABAD");



46

cbox1.addItem("GOA");











}

void add2()

{col=new Vector<String>();

col.add("Flight no");

col.add("Flight name");

col.add("Days");

col.add("Route");

col.add("Executive class Seats");

col.add("Fare");

col.add("Business class Seats");

col.add("Fare");



47

}


try

{

add2();

data=new Vector<Vector<String>>();

String s="select

Flight.F_no,F_name,days,route,EX_Class,EX_Class_Fare,B_Class,B_Class_Far

e from Flight,Fare where source=? and destination=? and

Flight.F_no=Fare.F_no";


ps.setString(1,cbox1.getSelectedItem().toString());



while(rs.next())

{

Vector<String> row=new Vector<String>();

row.add(rs.getString("F_no"));

row.add(rs.getString("F_name"));

row.add(rs.getString("days"));

row.add(rs.getString("route"));

row.add(String.valueOf(rs.getInt("EX_Class")));

row.add(rs.getString("EX_Class_Fare"));

row.add(String.valueOf(rs.getInt("B_Class")));



48

row.add(rs.getString("B_Class_Fare"));

data.add(row);

}

tab.setModel(new DefaultTableModel(data,col));

}

catch(Exception ex)

{


}

}



public void run() {

new Flightenquery().setVisible(true);}

});

}



private javax.swing.JComboBox cbox1;


private javax.swing.JLabel jLabel1;




49



private javax.swing.JScrollPane jScrollPane1;

private javax.swing.JTable tab;


}

Flightfare.java

package project;






public class Flightfare extends javax.swing.JFrame {Connection con;


ResultSet rs;

public Flightfare() {

initComponents();

con();

add();

}

void con()



50

{

try

{


Connection con =


");

}

catch(Exception ex)

{


}

}

void add()

{

try

{

String s="select F_no from Flight";



while (rs.next())

{

cbox.addItem(rs.getString("F_no"));



51

}

}

catch(Exception ex)

{


}

}


try

{

String s="insert into Fare values(?,?,?)";


ps.setString(1,cbox.getSelectedItem().toString());

ps.setString(2,txt1.getText()); ps.setString(3,txt2.getText());

ps.executeUpdate();

JOptionPane.showMessageDialog(this,"Fare Successfully set");

}

catch(Exception ex)

{


}

}



52


txt1.setText(null);

txt2.setText(null);

}



public void run() {

new Flightfare().setVisible(true);

}

});

}


private javax.swing.JButton btn1; private javax.swing.JButton btn2;

private javax.swing.JComboBox cbox;










53


}

Flightmaster.java

package project;





public class Flightmaster extends javax.swing.JFrame {

Connection con;


public Flightmaster() {

initComponents();add();

con();

}

void add()

{







54














cbox2.addItem("GOA");}

void con()

{

try

{


Connection con =


");



55

}

catch(Exception exp)

{

JOptionPane.showMessageDialog(this, exp.getMessage());

}

}

private void cbox1ItemStateChanged(java.awt.event.ItemEvent evt) {

txt3.setText(cbox1.getSelectedItem().toString());

txt6.setText(txt3.getText()+"-"+txt4.getText());

txt6.setEditable(false);

}


txt4.setText(cbox2.getSelectedItem().toString());

txt6.setText(txt3.getText()+"-"+txt4.getText());txt6.setEditable(false);

}


try

{

String s="insert into Flight values(?,?,?,?,?,?,?,?)";






56





ps.setInt(7,Integer.parseInt(txt7.getText()));

ps.setInt(8,Integer.parseInt(txt8.getText()));

ps.executeUpdate();

JOptionPane.showMessageDialog(this,"Flight Successfully Added");

}

catch(Exception ex)

{


}

} private void btn2ActionPerformed(java.awt.event.ActionEvent evt) {

txt1.setText(null);

txt2.setText(null);

txt3.setText(null);

txt4.setText(null);

txt5.setText(null);

txt6.setText(null);

txt7.setText(null);

txt8.setText(null);



57

}



public void run() {

new Flightmaster().setVisible(true);

}

});

}






private javax.swing.JLabel jLabel1; private javax.swing.JLabel jLabel2;











58










}

Reservation.java

package project;



import java.sql.PreparedStatement;import java.sql.ResultSet;

import java.util.Calendar;

import javax.swing.DefaultListModel;


public class Reservation extends javax.swing.JFrame {

Connection con;

PreparedStatement ps;ResultSet rs;

int f1,f2,tid=1,tid1=1;

String date;

public Reservation() {

initComponents();



59

conn();

add();

}

void add()

{cbox1.addItem("Select Gender");

cbox1.addItem("Male");

cbox1.addItem("Female");





cbox3.addItem("KANPUR");cbox3.addItem("KOLKATTA");















}

void conn()

{

try

{




60

Connection con =


");

}catch(Exception ex)

{


}

}


try

{

DefaultListModel mod=new DefaultListModel();

list1.setModel(mod);

String s="select * from Flight where source=? and destination=?";





while(rs.next())

{mod.addElement(rs.getString("F_name"));

}

}

catch(Exception ex)

{

// JOptionPane.showMessageDialog(this, ex.getMessage());

}

} private void list1ValueChanged(javax.swing.event.ListSelectionEvent evt) {

try

{

//JOptionPane.showMessageDialog(this, date);

ResultSet rs1;



61

String s="select F_no,days,source,destination from Flight where

F_name=?";


ps.setString(1,list1.getSelectedValue().toString());

rs1=ps.executeQuery();rs1.next();

txt2.setText(rs1.getString("F_no"));

txt16.setText(rs1.getString("days"));

txt3.setText(list1.getSelectedValue().toString());

txt4.setText(rs1.getString("source"));

txt5.setText(rs1.getString("destination"));

String z="select count(*) as cnt from Ticket";

ps=con.prepareStatement(z);ResultSet rw=ps.executeQuery();

if(rw.next())

{

int c=rw.getInt("cnt");

if(c>0)

{

String x="select max(Ticket_no) as mx from Ticket";

ps=con.prepareStatement(x);

ResultSet rw1=ps.executeQuery();

rw1.next();

tid=rw1.getInt("mx");

tid++;

String y="select max(seat_no) as mx2 from Ticket";

ps=con.prepareStatement(y);

ResultSet rw2=ps.executeQuery();

rw2.next();

tid1=rw2.getInt("mx2");

tid1++;

}

}



62

txt1.setText(String.valueOf(tid));

txt13.setText(String.valueOf(tid1));

}

catch(Exception ex){

//JOptionPane.showMessageDialog(this, ex.getMessage());

}

}

private void cbox2ActionPerformed(java.awt.event.ActionEvent evt) {

}

private void cbox2ItemStateChanged(java.awt.event.ItemEvent evt) {try

{

String f="Executive";

ResultSet rs2=null;

String s="select * from Fare where F_no=?";



rs2=ps.executeQuery();

rs2.next();

if(f.equals(cbox2.getSelectedItem()))

{

txt14.setText(rs2.getString("EX_Class_Fare"));

}

else

{

txt14.setText(rs2.getString("B_Class_Fare"));

}

}

catch(Exception ex)

{


}



63

}


try

{ Calendar d=Calendar.getInstance();Calendar c=Calendar.getInstance();

int mon=Integer.parseInt(cbox6.getSelectedItem().toString());

mon--;

d.set(Integer.parseInt(cbox7.getSelectedItem().toString()),mon,Integer.parseInt(

cbox5.getSelectedItem().toString()));

date=cbox5.getSelectedItem().toString()+"/"+cbox6.getSelectedItem().toString()+"/"+cbox7.getSelectedItem().toString();

c.set(c.get(Calendar.YEAR),c.get(Calendar.MONTH),c.get(Calendar.DATE));

if(d.after(c)||d.equals(c))

{

ResultSet rs3;

String s="insert into Ticket values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";







ps.setString(6,date);












64

ps.setString(16,"CONFIRMED");

ps.executeUpdate();

String v="Executive";

String w="select EX_Class,B_Class from Flight where F_no=?";

ps=con.prepareStatement(w); ps.setString(1,txt2.getText());


rs3.next();

if(v.equals(cbox2.getSelectedItem()))

{

f1=rs3.getInt("EX_Class");

f2=rs3.getInt("B_Class");

f1--;}

else

{

f1=rs3.getInt("EX_Class");

f2=rs3.getInt("B_Class");

f2--;

}

String u="update Flight set EX_Class=?,B_Class=? where F_no=?";

ps=con.prepareStatement(u);

ps.setInt(1, f1);

ps.setInt(2, f2);


ps.executeUpdate();

JOptionPane.showMessageDialog(this,"Flight Successfully Booked");

}

else

{

JOptionPane.showMessageDialog(this,"Invalid Date Insert Valid

Date");

}

}

catch(Exception ex)



65

{


}

}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {txt1.setText(null);

txt2.setText(null);

txt3.setText(null);

txt4.setText(null);

txt5.setText(null);

txt8.setText(null);

txt9.setText(null);

txt10.setText(null);txt11.setText(null);

txt12.setText(null);



}



public void run() {

new Reservation().setVisible(true);

}

});

}












66

private javax.swing.JButton jButton2;




















private javax.swing.JScrollPane jScrollPane1;

private javax.swing.JList list1;














67




}

Ticketcancel.java

package project;






public class Ticketcancel extends javax.swing.JFrame {

Connection con;


ResultSet rs;

float r,t,rf;

int cl,c2;

public Ticketcancel() {

initComponents();

conn();

}

void conn()

{

try

{


Connection con =


");

}

catch(Exception ex)



68

{


}

}

private void btnpActionPerformed(java.awt.event.ActionEvent evt) {

try

{

String s="select * from Ticket where Ticket_no=?";




rs.next();txtq.setText(rs.getString("Flight_no"));

txt2.setText(rs.getString("Flight_name"));

txt3.setText(rs.getString("nm"));

txt4.setText(rs.getString("source"));

txt5.setText(rs.getString("destination"));

txt6.setText(rs.getString("date"));

txt7.setText(rs.getString("class"));

txt8.setText(rs.getString("seat_no"));

txt9.setText(rs.getString("Fare"));

txt10.setText(rs.getString("status_of_ticket"));

r=Float.parseFloat(txt9.getText());

t=r*25.0f/100.0f;

rf=r-t;

}

catch(Exception ex)

{

JOptionPane.showMessageDialog(this,"Enter Valid Ticket Number");

}

}


try

{



69

ResultSet rs1;

String s="insert into cancel values(?,?,?,?,?,?,?,?,?,?,?)";


ps.setString(1,txtq.getText());

ps.setString(2,txt2.getText()); ps.setString(3,txt3.getText());







ps.setString(10,"CANCELLED"); ps.setString(11,String.valueOf(rf));

ps.executeUpdate();

String e="Executive";

String u="select EX_Class,B_Class from Flight where F_no=?";

ps=con.prepareStatement(u);



rs1.next();

if(e.equals(txt7.getText()))

{

cl=rs1.getInt("EX_Class");

cl++;

String v="update Flight set EX_Class=? where F_no=?";

ps=con.prepareStatement(v);

ps.setInt(1, cl);


ps.executeUpdate();

}

else

{

c2=rs1.getInt("B_Class");

c2++;



70

String v="update Flight set B_Class=? where F_no=?";

ps=con.prepareStatement(v);

ps.setInt(1, c2);


ps.executeUpdate();}

String w="delete from Ticket where Ticket_no=?";

ps=con.prepareStatement(w);


ps.executeUpdate();

JOptionPane.showMessageDialog(this,"you will we refunded 75% of

money");JOptionPane.showMessageDialog(this,"you receive"+" "+rf);

JOptionPane.showMessageDialog(this,"Ticket Succesfully Cancelled");

}

catch(Exception ex)

{


}

}



public void run() {

new Ticketcancel().setVisible(true);

}

});

}



private javax.swing.JButton btnp;






71












private javax.swing.JTextField txt10; private javax.swing.JTextField txt2;








private javax.swing.JTextField txtq;


}



72

Output Screens

Splash Screen



73

Login Screen



74

Main Menu



75

Flight Master Screen



76

Add Fare Screen



77

Update Fare Screen



78

Flight Reservation Screen



79

Flight Enquiry Screen



80

Ticket Enquiry Screen



81

Ticket Cancellation Screen



82

List Of Flights



83

List Of Bookings



84

List Of Cancellation



85

Password Change Screen



86

Scope

Reusability:Reusability is possible as and when we require in this application.

We can update it next version. Reusable software reduces design, coding and

testing cost by amortizing effort over several designs. Reducing the amount of

code also simplifies understanding, which increases the likelihood that the code

is correct. We follow up both types of reusability: Sharing of newly written code

within a project and reuse of previously written code on new projects.

Extensibility:

This software is extended in ways that its original developers may

not expect. The following principles enhance extensibility like Hide data

structure, avoid traversing multiple links or methods, Avoid case statements on

object type and distinguish public and private operations.

Robustness:

Its method is robust if it does not fail even if it receives improper

parameters. There are some facilities like Protect against errors, Optimize after

the program runs, validating arguments and Avoid predefined limits.

Understandability:

A method is understandable if someone other than the creator of

the method can understand the code (as well as the creator after a time lapse).

We use the method, which small and coherent helps to accomplish this.

Cost-effectiveness:

Its cost is under the budget and make within given time

period. It is desirable to aim for a system with a minimum cost subject to the

condition that it must satisfy all the requirements.

Scope of this document is to put down the requirements, clearly identifying the

information needed by the user, the source of the information and outputs

expected from the system.



87

Testing

Software Testing is the process of executing software in a controlled manner, in

order to answer the question - Does the software behave as specified?. Software

testing is often used in association with the terms verification and validation.

Validation is the checking or testing of items, includes software, for

conformance and consistency with an associated specification. Software testing

is just one kind of verification, which also uses techniques such as reviews,

analysis, inspections, and walkthroughs. Validation is the process of checking

that what has been specified is what the user actually wanted.

Testing is a set of activity that can be planned in advanced and conducted

systematically. Testing begins at the module level and work towards theintegration of entire computers based system. Nothing is complete without

testing, as it vital success of the system testing objectives, there are several rules

that can serve as testing objectives. They are

Testing is a process of executing a program with the intend of findingan error.

A good test case is one that has high possibility of finding an undiscovered

error.

A successful test is one that uncovers an undiscovered error.

If a testing is conducted successfully according to the objectives as stated

above, it would uncovered errors in the software also testing demonstrate that

the software function appear to be working according to the specification, that

performance requirement appear to have been met.

There are three ways to test program.

For correctness

For implementation efficiency

For computational complexity



88

Test for correctness are supposed to verify that a program does exactly what it

was designed to do. This is much more difficult than it may at first appear,

especially for large programs.

Testing Objective:

The following are the testing objectives:

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

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

undiscovered error

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

Testability:

Software Testability is simply how easily (a computer program can be tested).

The Following characteristics are considered that lead to testable software.

-Operability: ―The better it works, the more efficiently it can be tested.‖

-Observability: ―What you see is what you test.‖

-Controllability: ―The better we can control the software, the more the Testing

can be automated and optimized.‖

-Decomposability: ―By controlling the scope of testing, we can more quickly

Isolate problems and perform smarter retesting.

-Simplicity: ―The less there is to test, the more quickly we can test it.‖

-Stability: ―The fewer the changes, the fewer the disruptions to testing.‖

-Understandability: ―the more information we have, the smarter we will test.



89

TEST PLAN

A test plan implies a series of desired course of action to be followed in

accomplishing various testing methods. The Test Plan acts as a blue print for the

action that is to be followed. The software engineers create a computer program,its documentation and related data structures. The software developers is always

responsible for testing the individual units of the programs, ensuring that each

performs the function for which it was designed. There is an independent test

group (ITG) which is to remove the inherent problems associated with letting

the builder to test the thing that has been built. The specific objectives of testing

should be stated in measurable terms. So that the mean time to failure, the cost

to find and fix the defects, remaining defect density or frequency of occurrence

and test work-hours per regression test all should be stated within the test plan.

The levels of testing include:

Unit testing

Integration Testing

Data validation Testing

Output Testing

UNIT TESTING

Unit testing focuses verification effort on the smallest unit of software design

– the software component or module. Using the component level design

description as a guide, important control paths are tested to uncover errors

within the boundary of the module. The relative complexity of tests and

uncovered scope established for unit testing. The unit testing is white-box

oriented, and step can be conducted in parallel for multiple components. The

modular interface is tested to ensure that information properly flows into and out

of the program unit under test. The local data structure is examined to ensurethat data stored temporarily maintains its integrity during all steps in an

algorithm’s execution. Boundary conditions are tested to ensure that all

statements in a module have been executed at least once. Finally, all error

handling paths are tested.



90

Tests of data flow across a module interface are required before any other test

is initiated. If data do not enter and exit properly, all other tests are moot.

Selective testing of execution paths is an essential task during the unit test. Gooddesign dictates that error conditions be anticipated and error handling paths set

up to reroute or cleanly terminate processing when an error does occur.

Boundary testing is the last task of unit testing step. Software often fails at its

boundaries.

Unit testing was done in Sell-Soft System by treating each module as

separate entity and testing each one of them with a wide spectrum of test inputs.

Some flaws in the internal logic of the modules were found and were rectified.

INTEGRATION TESTING

Integration testing is systematic technique for constructing the program

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

with interfacing. The objective is to take unit tested components and build a

program structure that has been dictated by design. The entire program is tested

as whole. Correction is difficult because isolation of causes is complicated by

vast expanse of entire program. Once these errors are corrected, new ones

appear and the process continues in a seemingly endless loop.

After unit testing in Sell-Soft System all the modules were integrated to test

for any inconsistencies in the interfaces. Moreover differences in program

structures were removed and a unique program structure was evolved.



91

VALIDATION TESTING OR SYSTEM TESTING

This is the final step in testing. In this the entire system was tested as a

whole with all forms, code, modules and class modules. This form of testing is

popularly known as Black Box testing or System tests.

Black Box testing method focuses on the functional requirements of the

software. That is, Black Box testing enables the software engineer to derive sets

of input conditions that will fully exercise all functional requirements for a

program.

Black Box testing attempts to find errors in the following categories;

incorrect or missing functions, interface errors, errors in data structures orexternal data access, performance errors and initialization errors and termination

errors.

OUTPUT TESTING OR USER ACCEPTANCE TESTING

The system considered is tested for user acceptance; here it should satisfy thefirm’s need. The software should keep in touch with perspective system; user at

the time of developing and making changes whenever required. This done with

respect to the following points

Input Screen Designs,

Output Screen Designs,

Online message to guide the user and the like.

The above testing is done taking various kinds of test data. Preparation of test

data plays a vital role in the system testing. After preparing the test data, the

system under study is tested using that test data. While testing the system by



92

which test data errors are again uncovered and corrected by using above testing

steps and corrections are also noted for future use.

Validation Checking:

At the culmination of integration testing, software is completely assembled as a

package; interfacing errors have been uncovered and corrected, and a final series

of software test-validation checks may begin. Validation can be defined in many

ways, but a simple definition (Albeit Harsh) is that validation succeeds when

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

Software validation is achieved through a series of black-box tests to be

conducted and a test procedure defines specific test cases that will be used inattempt to uncover errors in conformity with requirements. Both the plan and

procedure are designed to ensure that all functional requirements are satisfied;

all performance requirements are achieved; documentation is correct and human

– Engineered and other requirements are met. Once the application was made

free of all logical and interface errors , inputting dummy data to ensure that the

software developed satisfied all the requirements of the user did validation

checks .The data are created with the intent of determining whether the system

will process them correctly .

In Courier Management System Project Black box testing is used.



93

System Security

Enterprise businesses and government agencies around the world face the

certainty of losing sensitive data from a lost laptop, removable media or other

plug-and-play storage device. This drives the need for a complete data

protection solution that secures data on all common platforms, deploys easily,

scales to any size organization and meets strict compliance requirements related

to privacy laws and regulations.

Check Point Endpoint Security solutions provide data protection for laptops,

PCs, removable media and mobile devices. Our independently certified data

security products ensure that our enterprise, government and law enforcement

customers remain in compliance with regulatory standards. By leveraging a

strong and efficient blend of full disk encryption, access control, removable

media encryption and port management, Check Point Endpoint Security

solutions deliver comprehensive data security

Authentication security:

―To make information available to those who need it and who can be trusted

with it, organizations use authentication and authorization. Authentication is

proving that a user is whom he or she claims to be. That proof may involve

something the user knows (such as a password), something the user has (such as

a 'smartcard'), or something about the user that proves the person's identity (such

as a fingerprint). Authorization is the act of determining whether a particular

user (or computer system) has the right to carry out a certain activity, such as

reading a file or running a program. Authentication and authorization go hand in

hand. Users must be authenticated before carrying out the activity they areauthorized to perform. Security is strong when the means of authentication

cannot later be refuted – the user cannot later deny that he or she performed the

activity. This is known as no repudiation.‖

http://www.checkpoint.com/products/certifications/index.html

http://www.checkpoint.com/products/certifications/index.html



94

Java security:

Java’s security model is one of the language’s key architectural features that

make it an appropriate technology for networked environments. Security is

important because networks provide a potential avenue of attack to any

computer hooked to them. This concern becomes especially strong in an

environment in which software is downloaded across the network and executed

locally, as is done with java applets, for example. Because the class files for an

applet are automatically downloaded when a user goes to the containing web

page in a browser, it is likely that a user will encounter applets from untrusted

sources. Without any security, this would be a convenient way to spread viruses.

Thus, java securities mechanisms help make java suitable of networks becausethey establish a needed trust in the safety of network-mobile code.

Creation of User profiles and access rights:

Users have different type rights as , Each user first makes their login to server to

show their availability.



95

Implementation

Implementation is the stage of the project where thetheoretical design is turned into a working system. It can be considered to be the

most crucial stage in achieving a successful new system gaining the users

confidence that the new system will work and will be effective and accurate. It

is primarily concerned with user training and documentation. Conversion

usually takes place about the same time the user is being trained or later.

Implementation simply means convening a new system design into operation,

which is the process of converting a new revised system design into an

operational one.

Implementation is the stage of the project where the theoretical design is

tuned into a working system. At this stage the main work load, the greatest

upheaval and the major impact on the existing system shifts to the user

department.

Implementation includes all those activities that take place to convert

from the existing system to the new system. The new system may be a totally

new, replacing an existing manual or automated system or it may be amodification to an existing system. Proper implementation is essential to

provide a reliable system to meet organization requirements. The process of

putting the developed system in actual use is called system implementation. This

includes all those activities that take place to convert from the old system to the

new system. The system can be implemented only after through testing is done

and if it is found to be working according to the specifications. The system

personnel check the feasibility of the system. The more complex the system

being implemented, the more involved will be the system analysis and design

effort required to implement the three main aspects: education and training,

system testing and changeover. The implementation state involves the following

tasks:

Careful planning.

Investigation of system and constraints.



96

Design of methods to achieve the changeover.

Training of the staff in the changeover phase.

Implementation Procedures

Implementation of software refers to the final installation of the package

in its real environment, to the satisfaction of the intended uses and the operation

of the system. In many organizations someone who will not be operating it, will

commission the software development project. In the initial stage people doubt

about the software but we have to ensure that the resistance does not build up, as

one has to make sure that

The active user must be aware of the benefits of using the new system.

Their confidence in the software is built up.

Proper guidance is imparted to the user so that he is comfortable in using the

application.

Before going ahead and viewing the system, the user must know that for

viewing the result, the server program should be running in the server. If the

server object is not up running on the server, the actual process won’t take place.

User Training

User training is designed to prepare the user for testing and converting the

system. To achieve the objective and benefits expected from computer based

system, it is essential for the people who will be involved to be confident of their

role in the new system. As system becomes more complex, the need for training

is more important. By user training the user comes to know how to enter data,

respond to error messages, interrogate the database and call up routine that will

produce reports and perform other necessary functions.

Training on the Application Software

After providing the necessary basic training on computer awareness the

user will have to be trained on the new application software. This will give the

underlying philosophy of the use of the new system such as the screen flow,



97

screen design type of help on the screen, type of errors while entering the data,

the corresponding validation check at each entry and the ways to correct the date

entered. It should then cover information needed by the specific user/ group to

use the system or part of the system while imparting the training of the program

on the application. This training may be different across different user groupsand across different levels of hierarchy.

Operational Document

Once the implementation plan is decided, it is essential that the user of the

system is made familiar and comfortable with the environment. Education

involves right atmosphere and motivating the user. A documentation providing

the whole operations of the system is being developed in such a way that the

user can work with it in well consistent way. The system is developed user

friendly so that the user can work the system from the tips given in the

application itself. Useful tip and guidance is given inside the application itself to

help the user. Users have to be made aware that what can be achieved with the

new system and how it increases the performance of the system. The user of the

system should be given a general idea of the system before he uses the system.

System Maintenance

Maintenance is the enigma of system development. The maintenance

phase of the software cycle is the time in which a software product performs

useful work. After a system is successfully implemented, it should be

maintained in a proper manner.

System maintenance is an important aspect in the software development life

cycle. The need for system maintenance is for it to make adaptable to the

changes in the system environment. Software maintenance is of course, far more

than "Finding Mistakes". Maintenance may be defined by describing fouractivities that are undertaken after a program is released for use.



98

Conclusion

The system is used for daily activities such as booking, non delivery, out return,

company details, hub rates, and pickup centers. It is very difficult to do this

process manually. Hence it is recommended to computerize the process by

developing the relative software as the world is turning into information and

technology; computerization becomes necessity in all walks of life.

The various benefits that can be realized from this project are:

Easy maintenance of information.

No dependency on a specific person to get required information.

Saves time and effort.

Eases task of auditing.



Bibliography

Books

1.

Khalid A. Mughal, Rolf W. Rasmussen eight Impression,2008

2.

Phill Hanna, JSP: The complete Reference3. jaworski, Java 2 Platform, Techmedia.

4. Dieter Gollmann,Computer Security, Johan Wiley & sons.

5. Elias M. Awad, System Analysis and Design, IInd edition

6. Roger S. Pressman, Software Engineering (A Practitoner’s

Approach) The Mc Graw-Hill Companies 5th Edition 2002

Documents

Courier Project Report