INTRODUCTION TO THE PROJECT:

The objective of the project is to design and develop Secure online

Banking Application.

Some customers avoid online banking as they perceive it as being too

vulnerable to fraud. The security measures employed by most banks are never
100% safe, but in practice the number of fraud victims due to online banking is
very small. Indeed, conventional banking practices may be more prone to abuse
by fraudsters than online banking. Credit card fraud, signature forgery and
identity theft are far more widespread "offline" crimes than malicious hacking.
Bank transactions are generally traceable and criminal penalties for bank fraud
are high. Online banking can be more insecure if users are careless, gullible or
computer illiterate. An increasingly popular criminal practice to gain access to a
user's finances is phishing, whereby the user is in some way persuaded to hand
over their password(s) to the fraudster.

System:

The system will check the user’s existence in the database and provide
the set of services with respect to the role of the user. The application is based
on three-tier architecture. The cipher key obtained will help to find the fraud
application. The business logic helps in authenticating the application,
authorizing the users and providing services. The technologies are chosen by
keeping the compatibility and performance as the constraints for the application.

SYSTEM ANALYSIS

Definition and reason for Condition Analysis

System analysis will be performed to determine if it is feasible to design

information based on policies and plans of the organization and on user
requirements and to eliminate the weaknesses of the present system.
General requirements are: -

1. The new system should be cost effective.

2. To augment management, improve productivity and services.
3. To enhance User/System interface.
4. To improve information qualify and usability.

1
 5. To upgrade system’s reliability, availability, flexibility and growth
potential.

FEASIBILITY STUDY

TECHINICAL FEASIBILITY:

Evaluating the technical feasibility is the trickiest part of a feasibility study. This
is because, at this point in time, not too many-detailed design of the system, making it
difficult to access issues like performance, costs on (on account of the kind of technology
to be deployed) etc.
A number of issues have to be considered while doing a technical analysis.

i) Understand the different technologies involved in the proposed system:

Before commencing the project, we have to be very clear about what are the
Technologies that are to be required for the development of the new system.

ii) Find out whether the organization currently possesses the required
technologies:
Is the required technology available with the organization?
If so is the capacity sufficient?
For instance –
“Will the current printer be able to handle the new reports and forms required for the
new system?”

OPERATIONAL FEASIBILITY:

Proposed projects are beneficial only if they can be turned into information systems that
will meet the organizations operating requirements. Simply stated, this test of feasibility
asks if the system will work when it is developed and installed. Are there major barriers
to Implementation? Here are questions that will help test the operational feasibility of a
project:

 Is there sufficient support for the project from management from users? If
the current system is well liked and used to the extent that persons will not be
able to see reasons for change, there may be resistance.
 Are the current business methods acceptable to the user? If they are not,

2
Users may welcome a change that will bring about a more operational and useful
systems.
 Have the user been involved in the planning and development of the project?
Early involvement reduces the chances of resistance to the system and in
General and increases the likelihood of successful project.

Since the proposed system was to help reduce the hardships encountered
In the existing manual system, the new system was considered to be operational
feasible.

ECONOMIC FEASIBILITY:

Economic feasibility attempts 2 weigh the costs of developing and implementing a

new system, against the benefits that would accrue from having the new system in
place. This feasibility study gives the top management the economic justification for the
new system.
A simple economic analysis which gives the actual comparison of costs and
benefits are much more meaningful in this case. In addition, this proves to be a useful
point of reference to compare actual costs as the project progresses. There could be
various types of intangible benefits on account of automation. These could include
increased customer satisfaction, improvement in product quality better decision making
timeliness of information, expediting activities, improved accuracy of operations, better
documentation and record keeping, faster retrieval of information, better employee
morale.

3
SOFTWARE REQUIREMENT SPECIFICATION

REQUIREMENT SPECIFICATION:

The Project “Anti Phishing— The Fraud Detection in Online Banking” is mainly designed
to maintain the security for the user accounts by encrypting and decrypting the
passwords using antiphishing concept

 Phishing is a trick to trap a user to give his/her personal information.

 A Hacker creates a duplicate website which is a replica of the original
genuine website.
 Now, the Hacker sends an e-mail to a user (here, a bank customer) giving
a link and saying that his account needs to be updated or his account has
been locked and asking him to send his account details immediately.
 Now, the customer may fall for his trick and clicks the link, because the
link would look similar to the genuine bank’s link (under which, the
hacker’s URL is hidden in that). Now, when the link is clicked, the
customer is re-directed to that fake website (created by hacker).
 Customer thinks that he has reached a genuine website and gives his
account details and personal details thinking that the e-mail is from
genuine website.
 The account details are now re-directed to the Hacker. Thus, the Hacker is
successful in cheating the customer.

How to avoid this?

 ANTI – PHISHING is the solution to get rid of this problem. This Anti-
Phishing is nothing but “preventing the phishing”.

 Creating a cipher key (an encrypted code) in the customer’s username,

password or in a/c no., which is not recognized in the hacker’s fake
website, is considered as one of the best solutions.

INTRODUCTION

4
Purpose: The main purpose for preparing this document is to give a general
insight into the analysis and requirements of the existing system or situation and
for determining the operating characteristics of the system.

Scope: This Document plays a vital role in the development life cycle (SDLC)

As it describes the complete requirement of the system. It is meant for use by

the developers and will be the basic during testing phase. Any changes made to
the requirements in the future will have to go through formal change approval
process.

Developers Responsibilities Overview:

The developer is responsible for:

1) Developing the system, which meets the SRS and solving all the requirements
of the system?

2) Demonstrating the system and installing the system at client's location after
the acceptance testing is successful.

3) Submitting the required user manual describing the system interfaces to work
on it and also the documents of the system.

4) Conducting any user training that might be needed for using the system.

5) Maintaining the system for a period of one year after installation.

Functional Requirements:
Inputs: The major inputs for “Anti Phishing— The Fraud Detection in Online
Banking” can be categorized module -wise. Basically all the information is
managed by the software and in order to access the information one has to
produce one's identity by entering the user-id and password. Every user has their
own domain of access beyond which the access is dynamically refrained rather
denied.

Output: The major outputs of the system are tables and reports. Tables are
created dynamically to meet the requirements on demand. Reports, as it is
obvious, carry the gist of the whole information that flows across the institution.

This application must be able to produce output at different modules for

different inputs.

5
Performance Requirements:

Performance is measured in terms of reports generated weekly and monthly.

SOFTWARE AND HARDWARE SPECIFICATIONS

Hardware:

Processor : Dual core or Above

Ram : 1GB or more
Cache : 512 KB

6
Hard disk : 16 GB hard disk recommended for primary partition.

Software:

Operating system : Windows 7 or later

Front End Software : ASP.NET (C# .NET)

Back End Software : SQL Server 2008

TOOLS, PLATFORM/LANGUAGES USED

SELECTED SOFTWARE

Microsoft.NET Framework

The .NET Framework is a new computing platform that simplifies application

development in the highly distributed environment of the Internet. The .NET Framework
is designed to fulfill the following objectives:

7
  To provide a consistent object-oriented programming environment
whether object code is stored and executed locally, executed locally but
Internet-distributed, or executed remotely.
 To provide a code-execution environment that minimizes software
deployment and versioning conflicts.
 To provide a code-execution environment that guarantees safe execution
of code, including code created by an unknown or semi-trusted third party.
 To provide a code-execution environment that eliminates the performance
problems of scripted or interpreted environments.
 To make the developer experience consistent across widely varying types
of applications, such as Windows-based applications and Web-based
applications.
 To build all communication on industry standards to ensure that code
based on the .NET Framework can integrate with any other code.

The .NET Framework has two main components: the common language runtime and
the .NET Framework class library. The common language runtime is the foundation of the
.NET Framework. You can think of the runtime as an agent that manages code at
execution time, providing core services such as memory management, thread
management, and remoting, while also enforcing strict type safety and other forms of
code accuracy that ensure security and robustness. In fact, the concept of code
management is a fundamental principle of the runtime. Code that targets the runtime is
known as managed code, while code that does not target the runtime is known as
unmanaged code. The class library, the other main component of the .NET Framework, is
a comprehensive, object-oriented collection of reusable types that you can use to
develop applications ranging from traditional command-line or graphical user interface
(GUI) applications to applications based on the latest innovations provided by ASP.NET,
such as Web Forms and XML Web services.

The .NET Framework can be hosted by unmanaged components that load the common
language runtime into their processes and initiate the execution of managed code,
thereby creating a software environment that can exploit both managed and unmanaged
features. The .NET Framework not only provides several runtime hosts, but also supports
the development of third-party runtime hosts.

For example, ASP.NET hosts the runtime to provide a scalable, server-side environment
for managed code. ASP.NET works directly with the runtime to enable Web Forms
applications and XML Web services, both of which are discussed later in this topic.

Internet Explorer is an example of an unmanaged application that hosts the runtime (in
the form of a MIME type extension). Using Internet Explorer to host the runtime enables
you to embed managed components or Windows Forms controls in HTML documents.

8
Hosting the runtime in this way makes managed mobile code (similar to Microsoft®
ActiveX® controls) possible, but with significant improvements that only managed code
can offer, such as semi-trusted execution and secure isolated file storage.

The following illustration shows the relationship of the common language runtime and
the class library to your applications and to the overall system. The illustration also
shows how managed code operates within a larger architecture.

Features of the Common Language Runtime

The common language runtime manages memory, thread execution, code execution,
code safety verification, compilation, and other system services. These features are
intrinsic to the managed code that runs on the common language runtime.

With regards to security, managed components are awarded varying degrees of trust,
depending on a number of factors that include their origin (such as the Internet,
enterprise network, or local computer). This means that a managed component might or
might not be able to perform file-access operations, registry-access operations, or other
sensitive functions, even if it is being used in the same active application.

The runtime enforces code access security. For example, users can trust that an
executable embedded in a Web page can play an animation on screen or sing a song, but
cannot access their personal data, file system, or network. The security features of the
runtime thus enable legitimate Internet-deployed software to be exceptionally feature
rich.

The runtime also enforces code robustness by implementing a strict type- and code-
verification infrastructure called the common type system (CTS). The CTS ensures that all
managed code is self-describing. The various Microsoft and third-party language
compilers generate managed code that conforms to the CTS. This means that managed
code can consume other managed types and instances, while strictly enforcing type
fidelity and type safety.

In addition, the managed environment of the runtime eliminates many common software
issues. For example, the runtime automatically handles object layout and manages
references to objects, releasing them when they are no longer being used. This
automatic memory management resolves the two most common application errors,
memory leaks and invalid memory references.

The runtime also accelerates developer productivity. For example, programmers can
write applications in their development language of choice, yet take full advantage of the
runtime, the class library, and components written in other languages by other
developers. Any compiler vendor who chooses to target the runtime can do so. Language
compilers that target the .NET Framework make the features of the .NET Framework
available to existing code written in that language, greatly easing the migration process
for existing applications.

9
While the runtime is designed for the software of the future, it also supports software of
today and yesterday. Interoperability between managed and unmanaged code enables
developers to continue to use necessary COM components and DLLs.

The runtime is designed to enhance performance. Although the common language

runtime provides many standard runtime services, managed code is never interpreted. A
feature called just-in-time (JIT) compiling enables all managed code to run in the native
machine language of the system on which it is executing. Meanwhile, the memory
manager removes the possibilities of fragmented memory and increases memory
locality-of-reference to further increase performance.

Finally, the runtime can be hosted by high-performance, server-side applications, such as

Microsoft® SQL Server™ and Internet Information Services (IIS). This infrastructure
enables you to use managed code to write your business logic, while still enjoying the
superior performance of the industry's best enterprise servers that support runtime
hosting.

. NET Framework Class Library

The .NET Framework class library is a collection of reusable types that tightly integrate
with the common language runtime. The class library is object oriented, providing types
from which your own managed code can derive functionality. This not only makes
the .NET Framework types easy to use, but also reduces the time associated with
learning new features of the .NET Framework. In addition, third-party components can
integrate seamlessly with classes in the .NET Framework.

For example, the .NET Framework collection classes implement a set of interfaces that
you can use to develop your own collection classes. Your collection classes will blend
seamlessly with the classes in the .NET Framework.

As you would expect from an object-oriented class library, the .NET Framework types
enable you to accomplish a range of common programming tasks, including tasks such
as string management, data collection, database connectivity, and file access. In addition
to these common tasks, the class library includes types that support a variety of
specialized development scenarios. For example, you can use the .NET Framework to
develop the following types of applications and services:

 Console applications.
 Scripted or hosted applications.
 Web applications (Web Forms).
 ASP.NET applications.
 XML Web services.
 Web services.

10
Client Application Development

Client applications are the closest to a traditional style of application in Windows-based

programming. These are the types of applications that display windows or forms on the
desktop, enabling a user to perform a task. Client applications include applications such
as word processors and spreadsheets, as well as custom business applications such as
data-entry tools, reporting tools, and so on. Client applications usually employ windows,
menus, buttons, and other GUI elements, and they likely access local resources such as
the file system and peripherals such as printers.

Another kind of client application is the traditional ActiveX control (now replaced by the
managed Windows Forms control) deployed over the Internet as a Web page. This
application is much like other client applications: it is executed natively, has access to
local resources, and includes graphical elements.

In the past, developers created such applications using C/C++ in conjunction with the
Microsoft Foundation Classes (MFC) or with a rapid application development (RAD)
environment such as Microsoft® Visual Basic®. The .NET Framework incorporates
aspects of these existing products into a single, consistent development environment
that drastically simplifies the development of client applications.

The Web Forms classes contained in the .NET Framework are designed to be used for GUI
development. You can easily create command windows, buttons, menus, toolbars, and
other screen elements with the flexibility necessary to accommodate shifting business
needs.

For example, the .NET Framework provides simple properties to adjust visual attributes
associated with forms. In some cases the underlying operating system does not support
changing these attributes directly, and in these cases the .NET Framework automatically
recreates the forms. This is one of many ways in which the .NET Framework integrates
the developer interface, making coding simpler and more consistent.

Unlike ActiveX controls, Windows Forms controls have semi-trusted access to a user's
computer. This means that binary or natively executing code can access some of the
resources on the user's system (such as GUI elements and limited file access) without
being able to access or compromise other resources. Because of code access security,
many applications that once needed to be installed on a user's system can now be safely
deployed through the Web. Your applications can implement the features of a local
application while being deployed like a Web page.

Server Application Development

Server-side applications in the managed world are implemented through runtime hosts.
Unmanaged applications host the common language runtime, which allows your custom
managed code to control the behavior of the server. This model provides you with all the

11
features of the common language runtime and class library while gaining the
performance and scalability of the host server.

The following illustration shows a basic network schema with managed code running in
different server environments. Servers such as IIS and SQL Server can perform standard
operations while your application logic executes through the managed code.

Server-side managed code

ASP.NET is the hosting environment that enables developers to use the .NET Framework
to target Web-based applications. However, ASP.NET is more than just a runtime host; it
is a complete architecture for developing Web sites and Internet-distributed objects using
managed code. Both Web Forms and XML Web services use IIS and ASP.NET as the
publishing mechanism for applications, and both have a collection of supporting classes
in the .NET Framework.

XML Web services, an important evolution in Web-based technology, are distributed,

server-side application components similar to common Web sites. However, unlike Web-
based applications, XML Web services components have no UI and are not targeted for
browsers such as Internet Explorer and Netscape Navigator. Instead, XML Web services
consist of reusable software components designed to be consumed by other applications,
such as traditional client applications, Web-based applications, or even other XML Web
services. As a result, XML Web services technology is rapidly moving application
development and deployment into the highly distributed environment of the Internet.

If you have used earlier versions of ASP technology, you will immediately notice the
improvements that ASP.NET and Web Forms offers. For example, you can develop Web
Forms pages in any language that supports the .NET Framework. In addition, your code
no longer needs to share the same file with your HTTP text (although it can continue to
do so if you prefer). Web Forms pages execute in native machine language because, like
any other managed application, they take full advantage of the runtime. In contrast,
unmanaged ASP pages are always scripted and interpreted. ASP.NET pages are faster,
more functional, and easier to develop than unmanaged ASP pages because they
interact with the runtime like any managed application.

The .NET Framework also provides a collection of classes and tools to aid in development
and consumption of XML Web services applications. XML Web services are built on
standards such as SOAP (a remote procedure-call protocol), XML (an extensible data
format), and WSDL ( the Web Services Description Language). The .NET Framework is
built on these standards to promote interoperability with non-Microsoft solutions.

For example, the Web Services Description Language tool included with the .NET
Framework SDK can query an XML Web service published on the Web, parse its WSDL
description, and produce C# or Visual Basic source code that your application can use to
become a client of the XML Web service. The source code can create classes derived

12
from classes in the class library that handle all the underlying communication using SOAP
and XML parsing. Although you can use the class library to consume XML Web services
directly, the Web Services Description Language tool and the other tools contained in the
SDK facilitate your development efforts with the .NET Framework.

If you develop and publish your own XML Web service, the .NET Framework provides a
set of classes that conform to all the underlying communication standards, such as SOAP,
WSDL, and XML. Using those classes enables you to focus on the logic of your service,
without concerning yourself with the communications infrastructure required by
distributed software development.

Finally, like Web Forms pages in the managed environment, your XML Web service will
run with the speed of native machine language using the scalable communication of IIS.

Active Server Pages.NET

ASP.NET is a programming framework built on the common language runtime that

can be used on a server to build powerful Web applications. ASP.NET offers
several important advantages over previous Web development models:

 Enhanced Performance. ASP.NET is compiled common language

runtime code running on the server. Unlike its interpreted
predecessors, ASP.NET can take advantage of early binding, just-in-
time compilation, native optimization, and caching services right
out of the box. This amounts to dramatically better performance
before you ever write a line of code.

 World-Class Tool Support. A rich toolbox and designer in the

Visual Studio integrated development environment complement the
ASP.NET framework. WYSIWYG editing, drag-and-drop server
controls, and automatic deployment are just a few of the features
this powerful tool provides.

 Power and Flexibility. Because ASP.NET is based on the common

language runtime, the power and flexibility of that entire platform is
13
 available to Web application developers. The .NET Framework class
library, Messaging, and Data Access solutions are all seamlessly
accessible from the Web. ASP.NET is also language-independent, so
you can choose the language that best applies to your application
or partition your application across many languages. Further,
common language runtime interoperability guarantees that your
existing investment in COM-based development is preserved when
migrating to ASP.NET.

 Simplicity. ASP.NET makes it easy to perform common tasks, from

simple form submission and client authentication to deployment
and site configuration. For example, the ASP.NET page framework
allows you to build user interfaces that cleanly separate application
logic from presentation code and to handle events in a simple,
Visual Basic - like forms processing model. Additionally, the
common language runtime simplifies development, with managed
code services such as automatic reference counting and garbage
collection.

 Manageability. ASP.NET employs a text-based, hierarchical

configuration system, which simplifies applying settings to your
server environment and Web applications. Because configuration
information is stored as plain text, new settings may be applied
without the aid of local administration tools. This "zero local
administration" philosophy extends to deploying ASP.NET
Framework applications as well. An ASP.NET Framework application
is deployed to a server simply by copying the necessary files to the
server. No server restart is required, even to deploy or replace
running compiled code.

 Scalability and Availability. ASP.NET has been designed with

scalability in mind, with features specifically tailored to improve
performance in clustered and multiprocessor environments. Further,
processes are closely monitored and managed by the ASP.NET
runtime, so that if one misbehaves (leaks, deadlocks), a new
process can be created in its place, which helps keep your
application constantly available to handle requests.

14
  Customizability and Extensibility. ASP.NET delivers a well-
factored architecture that allows developers to "plug-in" their code
at the appropriate level. In fact, it is possible to extend or replace
any subcomponent of the ASP.NET runtime with your own custom-
written component. Implementing custom authentication or state
services has never been easier.

 Security. With built in Windows authentication and per-application

configuration, you can be assured that your applications are secure.

Language Support
The Microsoft .NET Platform currently offers built-in support for three
languages: C#, Visual Basic, and JScript.

What is ASP.NET Web Forms?

The ASP.NET Web Forms page framework is a scalable common language

runtime-programming model that can be used on the server to dynamically
generate Web pages.

Intended as a logical evolution of ASP (ASP.NET provides syntax compatibility with

existing pages), the ASP.NET Web Forms framework has been specifically
designed to address a number of key deficiencies in the previous model. In
particular, it provides:

 The ability to create and use reusable UI controls that can

encapsulate common functionality and thus reduce the amount of
code that a page developer has to write.
 The ability for developers to cleanly structure their page logic in an
orderly fashion (not "spaghetti code").
 The ability for development tools to provide strong WYSIWYG design
support for pages (existing ASP code is opaque to tools).

ASP.NET Web Forms pages are text files with an. aspx file name extension. They
can be deployed throughout an IIS virtual root directory tree. When a browser
client requests. aspx resources, the ASP.NET runtime parses and compiles the
target file into a .NET Framework class. This class can then be used to
dynamically process incoming requests. (Note that the .aspx file is compiled only

15
the first time it is accessed; the compiled type instance is then reused across
multiple requests).

An ASP.NET page can be created simply by taking an existing HTML file and
changing its file name extension to .aspx (no modification of code is required). For
example, the following sample demonstrates a simple HTML page that collects a
user's name and category preference and then performs a form postback to the
originating page when a button is clicked:

ASP.NET provides syntax compatibility with existing ASP pages. This

includes support for <% %> code render blocks that can be intermixed
with HTML content within an .aspx file. These code blocks execute in a
top-down manner at page render time.

Code-Behind Web Forms

ASP.NET supports two methods of authoring dynamic pages. The first is the
method shown in the preceding samples, where the page code is physically
declared within the originating .aspx file. An alternative approach--known as the
code-behind method--enables the page code to be more cleanly separated from
the HTML content into an entirely separate file.

Introduction to ASP.NET Server Controls

In addition to (or instead of) using <% %> code blocks to program dynamic
content, ASP.NET page developers can use ASP.NET server controls to program
Web pages. Server controls are declared within an .aspx file using custom tags or
intrinsic HTML tags that contain a runat="server" attribute value. Intrinsic HTML
tags are handled by one of the controls in the System.Web.UI.HtmlControls
namespace. Any tag that doesn't explicitly map to one of the controls is assigned
the type of System.Web.UI.HtmlControls.HtmlGenericControl.

Server controls automatically maintain any client-entered values between round

trips to the server. This control state is not stored on the server (it is instead
stored within an <input type="hidden"> form field that is round-tripped
between requests). Note also that no client-side script is required.

In addition to supporting standard HTML input controls, ASP.NET enables

developers to utilize richer custom controls on their pages. For example, the
following sample demonstrates how the <asp:adrotator> control can be used to
dynamically display rotating ads on a page.

16
 1. ASP.NET Web Forms provide an easy and powerful way to build
dynamic Web UI.
2. ASP.NET Web Forms pages can target any browser client (there
are no script library or cookie requirements).
3. ASP.NET Web Forms pages provide syntax compatibility with
existing ASP pages.
4. ASP.NET server controls provide an easy way to encapsulate
common functionality.
5. ASP.NET ships with 45 built-in server controls. Developers can
also use controls built by third parties.
6. ASP.NET server controls can automatically project both uplevel
and downlevel HTML.
7. ASP.NET templates provide an easy way to customize the look
and feel of list server controls.
8. ASP.NET validation controls provide an easy way to do declarative
client or server data validation.

Crystal Reports

Crystal Reports for Visual Basic .NET is the standard reporting tool for Visual Basic.NET; it
brings the ability to create interactive, presentation-quality content — which has been
the strength of Crystal Reports for years — to the .NET platform.

With Crystal Reports for Visual Basic.NET, you can host reports on Web and Windows
platforms and publish Crystal reports as Report Web Services on a Web server.

To present data to users, you could write code to loop through recordsets and print them
inside your Windows or Web application. However, any work beyond basic formatting can
be complicated: consolidations, multiple level totals, charting, and conditional formatting
are difficult to program.

With Crystal Reports for Visual Studio .NET, you can quickly create complex and
professional-looking reports. Instead of coding, you use the Crystal Report Designer
interface to create and format the report you need. The powerful Report Engine
processes the formatting, grouping, and charting criteria you specify.

Report Experts

Using the Crystal Report Experts, you can quickly create reports based on your
development needs:

17
  Choose from report layout options ranging from standard reports to form
letters, or build your own report from scratch.
 Display charts that users can drill down on to view detailed report data.
 Calculate summaries, subtotals, and percentages on grouped data.
 Show TopN or BottomN results of data.
 Conditionally format text and rotate text objects.

ACTIVE X DATA OBJECTS.NET

ADO.NET Overview

ADO.NET is an evolution of the ADO data access model that directly addresses user
requirements for developing scalable applications. It was designed specifically for the
web with scalability, statelessness, and XML in mind.

ADO.NET uses some ADO objects, such as the Connection and Command objects, and
also introduces new objects. Key new ADO.NET objects include the DataSet,
DataReader, and DataAdapter.

The important distinction between this evolved stage of ADO.NET and previous data
architectures is that there exists an object -- the DataSet -- that is separate and distinct
from any data stores. Because of that, the DataSet functions as a standalone entity. You
can think of the DataSet as an always disconnected recordset that knows nothing about
the source or destination of the data it contains. Inside a DataSet, much like in a
database, there are tables, columns, relationships, constraints, views, and so forth.

A DataAdapter is the object that connects to the database to fill the DataSet. Then, it
connects back to the database to update the data there, based on operations performed
while the DataSet held the data. In the past, data processing has been primarily
connection-based. Now, in an effort to make multi-tiered apps more efficient, data
processing is turning to a message-based approach that revolves around chunks of
information. At the center of this approach is the DataAdapter, which provides a bridge
to retrieve and save data between a DataSet and its source data store. It accomplishes
this by means of requests to the appropriate SQL commands made against the data
store.

18
The XML-based DataSet object provides a consistent programming model that works
with all models of data storage: flat, relational, and hierarchical. It does this by having no
'knowledge' of the source of its data, and by representing the data that it holds as
collections and data types. No matter what the source of the data within the DataSet is,
it is manipulated through the same set of standard APIs exposed through the DataSet
and its subordinate objects.

While the DataSet has no knowledge of the source of its data, the managed provider
has detailed and specific information. The role of the managed provider is to connect, fill,
and persist the DataSet to and from data stores. The OLE DB and SQL Server .NET Data
Providers (System.Data.OleDb and System.Data.SqlClient) that are part of the .Net
Framework provide four basic objects: the Command, Connection, DataReader and
DataAdapter. In the remaining sections of this document, we'll walk through each part
of the DataSet and the OLE DB/SQL Server .NET Data Providers explaining what they
are, and how to program against them.

The following sections will introduce you to some objects that have evolved, and some
that are new. These objects are:

 Connections. For connection to and managing transactions against a

database.
 Commands. For issuing SQL commands against a database.
 DataReaders. For reading a forward-only stream of data records from
a SQL Server data source.
 DataSets. For storing, remoting and programming against flat data,
XML data and relational data.
 DataAdapters. For pushing data into a DataSet, and reconciling data
against a database.

When dealing with connections to a database, there are two different options: SQL
Server .NET Data Provider (System.Data.SqlClient) and OLE DB .NET Data Provider
(System.Data.OleDb). In these samples we will use the SQL Server .NET Data Provider.
These are written to talk directly to Microsoft SQL Server. The OLE DB .NET Data Provider
is used to talk to any OLE DB provider (as it uses OLE DB underneath).

Connections

Connections are used to 'talk to' databases, and are respresented by provider-specific
classes such as SQLConnection. Commands travel over connections and resultsets are
returned in the form of streams, which can be read by a DataReader object, or pushed
into a DataSet object.

Commands

19
Commands contain the information that is submitted to a database, and are represented
by provider-specific classes such as SQLCommand. A command can be a stored
procedure call, an UPDATE statement, or a statement that returns results. You can also
use input and output parameters, and return values as part of your command syntax.
The example below shows how to issue an INSERT statement against the Northwind
database.

DataReaders

The DataReader object is somewhat synonymous with a read-only/forward-only cursor

over data. The DataReader API supports flat as well as hierarchical data. A DataReader
object is returned after executing a command against a database. The format of the
returned DataReader object is different from a recordset. For example, you might use
the DataReader to show the results of a search list in a web page.

DataSets and DataAdapters

DataSets
The DataSet object is similar to the ADO Recordset object, but more powerful, and with
one other important distinction: the DataSet is always disconnected. The DataSet
object represents a cache of data, with database-like structures such as tables, columns,
relationships, and constraints. However, though a DataSet can and does behave much
like a database, it is important to remember that DataSet objects do not interact directly
with databases, or other source data. This allows the developer to work with a
programming model that is always consistent, regardless of where the source data
resides. Data coming from a database, an XML file, from code, or user input can all be
placed into DataSet objects. Then, as changes are made to the DataSet they can be
tracked and verified before updating the source data. The GetChanges method of the
DataSet object actually creates a second DatSet that contains only the changes to the
data. This DataSet is then used by a DataAdapter (or other objects) to update the
original data source.

The DataSet has many XML characteristics, including the ability to produce and
consume XML data and XML schemas. XML schemas can be used to describe schemas
interchanged via WebServices. In fact, a DataSet with a schema can actually be
compiled for type safety and statement completion.

DataAdapters (OLEDB/SQL)

The DataAdapter object works as a bridge between the DataSet and the source data.
Using the provider-specific SqlDataAdapter (along with its associated SqlCommand
and SqlConnection) can increase overall performance when working with a Microsoft
SQL Server databases. For other OLE DB-supported databases, you would use the
OleDbDataAdapter object and its associated OleDbCommand and OleDbConnection
objects.

20
The DataAdapter object uses commands to update the data source after changes have
been made to the DataSet. Using the Fill method of the DataAdapter calls the SELECT
command; using the Update method calls the INSERT, UPDATE or DELETE command for
each changed row. You can explicitly set these commands in order to control the
statements used at runtime to resolve changes, including the use of stored procedures.
For ad-hoc scenarios, a CommandBuilder object can generate these at run-time based
upon a select statement. However, this run-time generation requires an extra round-trip
to the server in order to gather required metadata, so explicitly providing the INSERT,
UPDATE, and DELETE commands at design time will result in better run-time
performance.

1. ADO.NET is the next evolution of ADO for the .Net Framework.

2. ADO.NET was created with n-Tier, statelessness and XML in the
forefront. Two new objects, the DataSet and DataAdapter, are
provided for these scenarios.
3. ADO.NET can be used to get data from a stream, or to store data in a
cache for updates.
4. There is a lot more information about ADO.NET in the documentation.
5. Remember, you can execute a command directly against the database
in order to do inserts, updates, and deletes. You don't need to first put
data into a DataSet in order to insert, update, or delete it.
6. Also, you can use a DataSet to bind to the data, move through the data,
and navigate data relationships

2.4 SQL SERVER 2008

Microsoft® SQL Server™ 2005 is a set of components that work together to meet
the data storage and analysis needs of the largest Web sites and enterprise data
processing systems. The topics in SQL Server Architecture describe how the
various components work together to manage data effectively.
2.4.1. Features of SQL Server 2008
Microsoft® SQL Server™ 2008 features include:

 Internet Integration.

The SQL Server 2008 database engine includes integrated XML support. It also
has the scalability, availability, and security features required to operate as the
data storage component of the largest Web sites. The SQL Server
2005programming model is integrated with the Windows DNA architecture for
developing Web applications, and SQL Server 2005supports features such as
English Query and the Microsoft Search Service to incorporate user-friendly
queries and powerful search capabilities in Web applications.

 Scalability and Availability.

21
 The same database engine can be used across platforms ranging from laptop
computers running Microsoft Windows® 98 through large, multiprocessor servers
running Microsoft Windows 2000 Data Center Edition. SQL Server 2008Enterprise
Edition supports features such as federated servers, indexed views, and large
memory support that allow it to scale to the performance levels required by the
largest Web sites.

 Enterprise-Level Database Features.

The SQL Server 2008relational database engine supports the features required to
support demanding data processing environments. The database engine protects
data integrity while minimizing the overhead of managing thousands of users
concurrently modifying the database. SQL Server 2008 distributed queries allow
you to reference data from multiple sources as if it were a part of a SQL Server
2005database, while at the same time, the distributed transaction support
protects the integrity of any updates of the distributed data. Replication allows
you to also maintain multiple copies of data, while ensuring that the separate
copies remain synchronized. You can replicate a set of data to multiple, mobile,
disconnected users, have them work autonomously, and then merge their
modifications back to the publisher.

 Ease of installation, deployment, and use.

SQL Server 2008 includes a set of administrative and development tools that
improve upon the process of installing, deploying, managing, and using SQL
Server across several sites. SQL Server 2008 also supports a standards-based
programming model integrated with the Windows DNA, making the use of SQL
Server databases and data warehouses a seamless part of building powerful and
scalable systems. These features allow you to rapidly deliver SQL Server
applications that customers can implement with a minimum of installation and
administrative overhead.

 Data warehousing.

SQL Server 2008 includes tools for extracting and analyzing summary data for
online analytical processing. SQL Server also includes tools for visually designing
databases and analyzing data using English-based questions.

2.4.2 Relational Database Components

The database component of Microsoft® SQL Server™ 2008 is a Structured Query
Language (SQL)–based, scalable, relational database with integrated Extensible
Markup Language (XML) support for Internet applications. Each of the following
terms describes a fundamental part of the architecture of the SQL Server
2008database component:
Database

A database is similar to a data file in that it is a storage place for data. Like a data
file, a database does not present information directly to a user; the user runs an
application that accesses data from the database and presents it to the user in an
understandable format.

Database systems are more powerful than data files in that data is more highly
organized. In a well-designed database, there are no duplicate pieces of data that
the user or application must update at the same time. Related pieces of data are
grouped together in a single structure or record, and relationships can be defined
between these structures and records.

22
 When working with data files, an application must be coded to work with the
specific structure of each data file. In contrast, a database contains a catalog that
applications use to determine how data is organized. Generic database
applications can use the catalog to present users with data from different
databases dynamically, without being tied to a specific data format.

A database typically has two main parts: first, the files holding the physical
database and second, the database management system (DBMS) software that
applications use to access data. The DBMS is responsible for enforcing the
database structure, including:

 Maintaining relationships between data in the database.

 Ensuring that data is stored correctly, and that the rules defining data
relationships are not violated.

 Recovering all data to a point of known consistency in case of system

failures.

2.4.3 Relational Database

Although there are different ways to organize data in a database, relational

databases are one of the most effective. Relational database systems are an
application of mathematical set theory to the problem of effectively organizing
data. In a relational database, data is collected into tables (called relations in
relational theory).

A table represents some class of objects that are important to an organization. For
example, a company may have a database with a table for employees, another
table for customers, and another for stores. Each table is built of columns and
rows (called attributes and topples in relational theory). Each column represents
some attribute of the object represented by the table. For example, an Employee
table would typically have columns for attributes such as first name, last name,
employee ID, department, pay grade, and job title. Each row represents an
instance of the object represented by the table. For example, one row in the
Employee table represents the employee who has employee ID 12345.

When organizing data into tables, you can usually find many different ways to
define tables. Relational database theory defines a process called normalization,
which ensures that the set of tables you define will organize your data effectively.

Scalable

SQL Server 2008 supports having a wide range of users access it at the same
time. An instance of SQL Server 2008 includes the files that make up a set of
databases and a copy of the DBMS software. Applications running on separate
computers use a SQL Server 2008 communications component to transmit
commands over a network to the SQL Server 2005 instance. When an application
connects to an instance of SQL Server 2005, it can reference any of the databases
in that instance that the user is authorized to access. The communication
component also allows communication between an instance of SQL Server 2008
and an application running on the same computer. You can run multiple instances
of SQL Server 2005 on a single computer.

SQL Server 2008 is designed to support the traffic of the largest Web sites or
enterprise data processing systems. Instances of SQL Server 2008 running on
large, multiprocessor servers are capable of supporting connections to thousands
of users at the same time. The data in SQL Server tables can be partitioned across

23
multiple servers, so that several multiprocessor computers can cooperate to
support the database processing requirements of extremely large systems. These
groups of database servers are called federations.

Although SQL Server 2008 is designed to work as the data storage engine for
thousands of concurrent users who connect over a network, it is also capable of
working as a stand-alone database directly on the same computer as an
application. The scalability and ease-of-use features of SQL Server 2008 allow it to
work efficiently on a single computer without consuming too many resources or
requiring administrative work by the stand-alone user. The same features allow
SQL Server 2008 to dynamically acquire the resources required to support
thousands of users, while minimizing database administration and tuning. The
SQL Server 2005 relational database engine dynamically tunes itself to acquire or
free the appropriate computer resources required to support a varying load of
users accessing an instance of SQL Server 2008 at any specific time. The SQL
Server 2008 relational database engine has features to prevent the logical
problems that occur if a user tries to read or modify data currently used by others.

Structured Query Language

To work with data in a database, you have to use a set of commands and
statements (language) defined by the DBMS software. Several different languages
can be used with relational databases; the most common is SQL. The American
National Standards Institute (ANSI) and the International Standards Organization
(ISO) define software standards, including standards for the SQL language. SQL
Server 2008supports the Entry Level of SQL-92, the SQL standard published by
ANSI and ISO in 1992. The dialect of SQL supported by Microsoft SQL Server is
called Transact-SQL (T-SQL). T-SQL is the primary language used by Microsoft SQL
Server applications.

Extensible Markup Language

XML is the emerging Internet standard for data. XML is a set of tags that can be
used to define the structure of a hypertext document. The Hypertext Markup
Language can easily process XML documents, which is the most important
language for displaying Web pages.

Although most SQL statements return their results in a relational, or tabular,

result set, the SQL Server 2005 database component supports a FOR XML clause
that returns results as an XML document. SQL Server 2008 also supports XPath
queries from Internet and intranet applications. XML documents can be added to
SQL Server databases, and the OPENXML clause can be used to expose data from
an XML document as a relational result set.

2.4.4 Database Architecture

Microsoft® SQL Server™ 2005 data is stored in databases. The data in a database
is organized into the logical components visible to users. A database is also
physically implemented as two or more files on disk.
When using a database, you work primarily with the logical components such as
tables, views, procedures, and users. The physical implementation of files is
largely transparent. Typically, only the database administrator needs to work with
the physical implementation.
Each instance of SQL Server has four system databases (master, model,
tempdb, and msdb) and one or more user databases. Some organizations have
only one user database, containing all the data for their organization. Some
organizations have different databases for each group in their organization, and
sometimes a database used by a single application. For example, an organization
could have one database for sales, one for payroll, one for a document

24
 management application, and so on. Sometimes an application uses only one
database; other applications may access several databases.
It is not necessary to run multiple copies of the SQL Server database engine to
allow multiple users to access the databases on a server. An instance of the SQL
Server Standard or Enterprise Edition is capable of handling thousands of users
working in multiple databases at the same time. Each instance of SQL Server
makes all databases in the instance available to all users that connect to the
instance, subject to the defined security permissions.
When connecting to an instance of SQL Server, your connection is associated with
a particular database on the server. This database is called the current database.
You are usually connected to a database defined as your default database by the
system administrator, although you can use connection options in the database
APIs to specify another database. You can switch from one database to another
using either the Transact-SQL USE database name statement, or an API function
that changes your current database context.
SQL Server 2005allows you to detach databases from an instance of SQL Server,
then reattach them to another instance, or even attach the database back to the
same instance. If you have a SQL Server database file, you can tell SQL Server
when you connect to attach that database file with a specific database name.
Implementation Details
The topics in this section provide information about the editions of Microsoft®
SQL Server™ 2008 and the environments that support these editions. Information
about the maximum capacities and memory usage of SQL Server 2005 objects is
also provided.
2.4.5 Managing Permissions
When users connect to an instance of Microsoft® SQL Server™, the activities they
can perform are determined by the permissions granted to:

 Their security accounts.

 The Microsoft Windows NT® 4.0 or Windows® 2000 groups or role

hierarchies to which their security accounts belong.

The user must have the appropriate permissions to perform any activity that
involves changing the database definition or accessing data.
Managing permissions includes granting or revoking user rights to:

 Work with data and execute procedures (object permissions).

 Create a database or an item in the database (statement permissions).

 Utilize permissions granted to predefined roles (implied permissions).

Object Permissions
Working with data or executing a procedure requires a class of permissions known
as object permissions:

 SELECT, INSERT, UPDATE, and DELETE statement permissions, which can

be applied to the entire table and view.

 SELECT and UPDATE statement permissions, which can be selectively

applied to individual columns of a table or view.

 SELECT permissions, which may be applied to user-defined functions.

25
 INSERT and DELETE statement permissions, which affect the entire row,
and therefore can be applied only to the table and view and not to
individual columns.

 EXECUTE statement permissions, which affect stored procedures and

functions.

Statement Permissions
Activities involved in creating a database or an item in a database, such as a table
or stored procedure, require a different class of permissions called statement
permissions. For example, if a user must be able to create a table within a
database, then grant the CREATE TABLE statement permission to the user.
Statement permissions, such as CREATE DATABASE, are applied to the statement
itself, rather than to a specific object defined in the database.
Statement permissions are:

 BACKUP DATABASE

 BACKUP LOG

 CREATE DATABASE

 CREATE DEFAULT

 CREATE FUNCTION

 CREATE PROCEDURE

 CREATE RULE

 CREATE TABLE

 CREATE VIEW

Implied Permissions
Implied permissions control those activities that can be performed only by
members of predefined system roles or owners of database objects. For example,
a member of the sysadmin fixed server role inherits automatically full permission
to do or see anything in a SQL Server installation.
Database object owners also have implied permissions that allow them to perform
all activities with the object they own. For example, a user who owns a table can
view, add, or delete data, alter the table definition, or control permissions that
allow other users to work with the table.
Granting Permissions
Grant statement and object permissions that allow a user account to:

 Perform activities or work with data in the current database.

 Restrict them from activities or information not part of their intended

function.

For example, you may be inclined to grant SELECT object permission on the
payroll table to all members of the personnel role, allowing all members of
personnel to view payroll. Months later, you may overhear members of
personnel discussing management salaries, information not meant to be seen by

26
 all personnel members. In this situation, grant SELECT access to personnel for
all columns in payroll except the salary column.

Note: It is possible to grant permissions only to user accounts in the current

database, for objects in the current database. If a user needs permissions to
objects in another database, create the user account in the other database, or
grant the user account access to the other database, as well as the current
database. System stored procedures are the exception because EXECUTE
permissions are already granted to the public role, which allows everyone to
execute them. However, after EXECUTE has been issued, the system stored
procedures check the user's role membership. If the user is not a member of the
appropriate fixed server or database role necessary to run the stored procedure,
the stored procedure will not continue.
Revoking Permissions
You can revoke a permission that has been granted or denied previously.
Revoking is similar to denying in that both remove a granted permission at the
same level. However, although revoking permission removes a granted
permission, it does not prevent the user, group, or role from inheriting a granted
permission from a higher level. Therefore, if you revoke permission for a user to
view a table, you do not necessarily prevent the user from viewing the table
because permission to view the table was granted to a role to which he belongs.
For example, removing SELECT access on the Employees table from the
HumanResources role revokes permission so that HumanResources can no
longer use the table. If HumanResources is a member of the Administration
role. If you later grant SELECT permission on Employees to Administration,
members of HumanResources can see the table through their membership in
Administration. However, if you deny permission to HumanResources, the
permission is not inherited if later granted to Administration because the deny
permission cannot be undone by a permission at a different level.
Similarly, it is also possible to remove a previously denied permission by revoking
the deny for the permission. However, if a user has other denied permissions at
the group or role level, then the user still is denied access.

Note: You can revoke permissions to user accounts only in the current database,
for objects in the current database.
2.4.6. Permissions for User-Defined Functions
Functions are subroutines made up of one or more Transact-SQL statements that
can be used to encapsulate code for reuse. Microsoft® SQL Server™ 2000 allows
users to create their own user-defined functions.
User-defined functions are managed through the following statements:

 CREATE FUNCTION, which creates a user-defined function.

 ALTER FUNCTION, which modifies user-defined functions.

 DROP FUNCTION, which drops user-defined functions.

Each fully qualified user-defined function name

(database_name.owner_name.function_name) must be unique.
You must have been granted CREATE FUNCTION permissions to create,
alter, or drop user-defined functions. Users other than the owner must be
granted EXECUTE permission on a function (if the function is scalar-
valued) before they can use it in a Transact-SQL statement. If the function
27
 is table-valued, the user must have SELECT permissions on the function
before referencing it. If a CREATE TABLE or ALTER TABLE statement
references a user-defined function in a CHECK constraint, a DEFAULT
clause, or a computed column, the table owner must also own the
function. If the function is being schema-bound

SYSTEM DESIGN

SOFTWARE ENGINEERING PARADIGM APPLIED- (RAD-MODEL)

28
The two design objectives continuously sought by developers are reliability and
maintenance.
Reliable System
There are two levels of reliability. The first is meeting the right requirements. A
careful and through systems study is needed to satisfy this aspect of reliability. The
second level of systems reliability involves the actual working delivered to the user. At
this level, the systems reliability is interwoven with software engineering and
development. There are three approaches to reliability.

1. Error avoidance: Prevents errors from occurring in software.

2. Error detection and correction: In this approach errors are recognized
whenever they are encountered and correcting the error by effect of error, of
the system does not fail.
3. Error tolerance: In this approach errors are recognized whenever they
occur, but enables the system to keep running through degraded perform or
by applying values that instruct the system to continue process.

Maintenance:

The key to reducing need for maintenance, while working, if possible to do

essential tasks.

1. More accurately defining user requirement during system development.

2. Assembling better systems documentation.
3. Using more effective methods for designing, processing, login and
communicating information with project team members.
4. Making better use of existing tools and techniques.
5. Managing system-engineering process effectively.

Output Design:

One of the most important factors of an information system for the user is the
output the system produces. Without the quality of the output, the entire system may
appear unnecessary that will make us avoid using it possibly causing it to fail. Designing

29
the output should process the in an organized well throughout the manner. The right
output must be developed while ensuring that each output element is designed so that
people will find the system easy to use effectively.
The term output applying to information produced by an information
system whether printed or displayed while designing the output we should
identify the specific output that is needed to information requirements select a
method to present the formation and create a document report or other formats
that contains produced by the system.

Types of output:

Whether the output is formatted report or a simple listing of the contents of a file, a
computer process will produce the output.

 A Report
 A Document
 A Message
 Retrieval from a data store
 Transmission from a process or system activity
 Directly from an output sources

Layout Design:

It is an arrangement of items on the output medium. The layouts are building a

Mock up of the actual reports or document, as it will appear after the system is in
operation. The output layout has been designated to cover information. The outputs are
presented in the appendix.

Input design and control:

Input specifications describe the manner in which data enter the system
for processing. Input design features will ensure the reliability of the systems and
produce results from accurate data, or thus can be

30
Result in the production of erroneous information. The input design also determines
whenever the user can interact efficiently with this system.

Objectives of input design:

Input design consists of developing specifications and procedures for data

preparation, the steps necessary to put transaction data into a usable from for
processing and data entry, the activity of data into the computer processing. The five
objectives of input design are:

 Controlling the amount of input

 Avoiding delay
 Avoiding error in data
 Avoiding extra steps
 Keeping the process simple

Controlling the amount of input:

Data preparation and data entry operation depend on people, Because labour costs
are high, the cost of preparing and entering data is also high. Reducing data
requirement expense. By reducing input requirement the speed of entire process
from data capturing to processing to provide results to users.

Avoiding delay:

The processing delay resulting from data preparation or data entry operations is
called bottlenecks. Avoiding bottlenecks should be one objective of input.

Avoiding errors:

Through input validation we control the errors in the input data.

Avoiding extra steps:

The designer should avoid the input design that cause extra steps in processing
saving or adding a single step in large number of transactions saves a lot of
processing time or takes more time to process.

Keeping process simple:

If controls are more people may feel difficult in using the systems. The best-designed
system fits the people who use it in a way that is comfortable for them.

31
 NORMALIZATION

It is a process of converting a relation to a standard form. The process is used to

handle the problems that can arise due to data redundancy i.e. repetition of data in the
database, maintain data integrity as well as handling problems that can arise due to
insertion, updating, deletion anomalies.
Decomposing is the process of splitting relations into multiple relations to
eliminate anomalies and maintain anomalies and maintain data integrity. To do
this we use normal forms or rules for structuring relation.

Insertion anomaly: Inability to add data to the database due to absence of

other data.

Deletion anomaly: Unintended loss of data due to deletion of other data.

Update anomaly: Data inconsistency resulting from data redundancy and

partial update

Normal Forms: These are the rules for structuring relations that eliminate
anomalies.

First Normal Form:

A relation is said to be in first normal form if the values in the relation are atomic
for every attribute in the relation. By this we mean simply that no attribute value can be
a set of values or, as it is sometimes expressed, a repeating group.
Second Normal Form:

A relation is said to be in second Normal form is it is in first normal form

and it should satisfy any one of the following rules.

1) Primary key is a not a composite primary key

2) No non key attributes are present
3) Every non-key attribute is fully functionally dependent on full set of primary
key.
Third Normal Form:

A relation is said to be in third normal form if their exits no transitive

dependencies.

Transitive Dependency: If two non-key attributes depend on each other as well as on

the primary key then they are said to be transitively dependent.
The above normalization principles were applied to decompose the data in
multiple tables thereby making the data to be maintained in a consistent state.

32
E-R DIAGRAMS

33
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
34
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 and
workstations. 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
consists 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
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

35
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

Data flow

Data Store

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

36
 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
A DFD typically shows the minimum contents of data store. Each data store
should contain all the data elements that flow in and out.

Questionnaires should contain all the data elements that flow in and out.
Missing interfaces redundancies and like is then accounted for often through
interviews.

SAILENT FEATURES OF DFD’s

1. The DFD shows flow of data, not of control loops and decision are controlled
considerations do not appear on a DFD.
2. The DFD does not indicate the time factor involved in any process whether
the dataflows take place daily, weekly, monthly or yearly.

TYPES OF DATA FLOW DIAGRAMS

1. Current Physical
2. Current Logical
3. New Logical
4. New Physical

CURRENT PHYSICAL:
In Current Physical DFD proecess label include the name of people or their
positions or the names of computer systems that might provide some of the
overall system-processing label includes an identification of the technology used
to process the data. Similarly data flows and data stores are often labels with
the names of the actual physical media on which data are stored such as file
folders, computer files, business forms or computer tapes.

37
CURRENT LOGICAL:

The physical aspects at the system are removed as mush as possible so

that the current system is reduced to its essence to the data and the processors
that transform them regardless of actual physical form.

NEW LOGICAL:

This is exactly like a current logical model if the user were completely
happy with he user were completely happy with the functionality of the current
system but had problems with how it was implemented typically through the new
logical model will differ from current logical model while having additional
functions, absolute function removal and inefficient flows recognized.

NEW PHYSICAL:

The new physical represents only the physical implementation of the new
system.

RULES GOVERNING THE DFD’S

PROCESS
1) No process can have only outputs.
2) No process can have only inputs. If an object has only inputs than it
must be a sink.
3) A process has a verb phrase label.
DATA STORE

1) Data cannot move directly from one data store to another data store, a
process must move data.
2) Data cannot move directly from an outside source to a data store, a
process, which receives, must move data from the source and place
the data into data store
3) A data store has a noun phrase label.
SOURCE OR SINK

The origin and /or destination of data.

1) Data cannot move direly from a source to sink it must be moved by a

process
2) A source and /or sink has a noun phrase land

38
DATA FLOW
1) A Data Flow has only one direction of flow between symbol. It may
flow in both directions between a process and a data store to show a
read before an update. The later is usually indicated however by two
separate arrows since these happen at different type.
2) A join in DFD means that exactly the same data comes from any of two
or more different processes data store or sink to a common location.
3) A data flow cannot go directly back to the same process it leads. There
must be atleast one other process that handles the data flow produce
some other data flow returns the original data into the beginning
process.
4) A Data flow to a data store means update ( delete or change).
5) A data Flow from a data store means retrieve or use.
6) A data flow has a noun phrase label more than one data flow noun
phrase can appear on a single arrow as long as all of the flows on the
same arrow move together as one package.

OUTPUT SCREENS

start.aspx

39
ADMIN

login.aspx

home.aspx

40
accountcreation.aspx

accountinformation.aspx

41
balancecheck.aspx

deposit.aspx

42
withdraw.aspx

depositdetails.aspx

43
withdrawdetails.aspx

USER

44
login.aspx

registration.aspx

home.aspx

45
balance.aspx

withdraw.aspx

46
CODEING

47
start.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class start : System.Web.UI.Page

{
protected void Page_Load(object sender, EventArgs e)
{

}
protected void Button1_Click(object sender, EventArgs e)
{
Response.Redirect("login.aspx");
}
protected void Button2_Click(object sender, EventArgs e)
{
Response.Redirect("~/user/login.aspx");
}
}

Admin
login.aspx

using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Data.SqlClient;
using System.Data;
public partial class login : System.Web.UI.Page
{
SqlConnection con = new SqlConnection(@"Data Source=.\sqlexpress;Initial
Catalog=onlinebank;Integrated Security=True");
public DataSet ds = new DataSet();
protected void Page_Load(object sender, EventArgs e)
{

}
protected void Button1_Click(object sender, EventArgs e)
{
con.Open();
DataSet ds = new DataSet();

48
 SqlDataAdapter adp = new SqlDataAdapter("select *from adminlogin where
uname='" + txt_uname.Text + "'", con);
adp.Fill(ds);
int x = ds.Tables[0].Rows.Count;
if (x > 0)
{
string ss = ds.Tables[0].Rows[0]["pwd"].ToString();
if (ss == txt_pass.Text)
{
Session["uname"] = txt_uname.Text;
Response.Redirect("home.aspx");
}
else
{
Label2.Visible = true;
Label2.Text = "invalid password";
}
}
else
{
Label2.Visible = true;
Label2.Text = "invalid user name";

}
}
}
home.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class home : System.Web.UI.Page

{
protected void Page_Load(object sender, EventArgs e)
{
Label2.Text = Session["uname"].ToString();
}
}

accountcreation.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;

49
using System.Web.UI.WebControls;

public partial class accountcreation : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{

}
protected void Button1_Click(object sender, EventArgs e)
{
string ss1 = FileUpload1.FileName;
FileUpload1.SaveAs(Server.MapPath(ss1));
string ss2 = FileUpload1.FileName;
FileUpload2.SaveAs(Server.MapPath(ss2));
string dt1 = txt_dt.Text;
string dd1 = dt1.Substring(0, 2);
string mon1 = dt1.Substring(3, 2);
string yr1 = dt1.Substring(6, 4);
string date1 = mon1 + "/" + dd1 + "/" + yr1;
obj.commall("select *from account_create where
accno='"+txt_accno.Text+"'","a1");
if (obj.ds.Tables[0].Rows.Count == 0)
{
obj.commall("insert into account_create values('" +
DropDownList1.SelectedItem.Text + "','" + DropDownList2.SelectedItem.Text + "','" +
txt_accno.Text + "','" + txt_name.Text + "','" + date1 + "','" + txt_add.Text + "','" +
txt_email.Text + "','" + txt_cont.Text + "','" + txt_amnt.Text + "','" +
FileUpload1.FileName + "','" + FileUpload2.FileName + "')", "a2");
obj.commall("insert into amount_mst values('" + txt_accno.Text + "','" +
txt_amnt.Text + "')", "a3");
txt_accno.Text = "";
txt_add.Text = "";
txt_amnt.Text = "";
txt_cont.Text = "";
txt_dt.Text = "";
txt_email.Text = "";
txt_name.Text = "";
DropDownList1.SelectedIndex = -1;
DropDownList2.SelectedIndex = -1;
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "k", "<script>alert('Account
Number already exist'); window.closed();</script>");
}

}
}
accountinformation.aspx.cs

50
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class accountinformation : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{

}
protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs
e)
{

obj.commall("select *from account_create where

branch='"+DropDownList1.SelectedItem.Text+"'", "ai1");
if (obj.ds.Tables["ai1"].Rows.Count > 0)
{

DropDownList2.DataSource = obj.ds.Tables["ai1"];
DropDownList2.DataTextField = "accno";
DropDownList2.DataValueField = "accno";
DropDownList2.DataBind();
DropDownList2.Items.Insert(0, new ListItem("--Select--", "0"));
DropDownList2.SelectedIndex = 0;
}
else
{

}
}
protected void Button1_Click(object sender, EventArgs e)
{
obj.commall("select *from account_create where accno='" +
DropDownList2.SelectedItem.Text + "'", "ai2");
if (obj.ds.Tables["ai2"].Rows.Count > 0)
{
GridView1.DataSource = obj.ds.Tables["ai2"];
GridView1.DataBind();
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "k", "<script>alert('No Data
Found'); window.closed();</script>");
}}}
balancecheck.aspx.cs

51
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class balancecheck : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{

}
protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs
e)
{
obj.commall("select *from account_create where branch='" +
DropDownList1.SelectedItem.Text + "'", "ai1");
if (obj.ds.Tables["ai1"].Rows.Count > 0)
{

DropDownList2.DataSource = obj.ds.Tables["ai1"];
DropDownList2.DataTextField = "accno";
DropDownList2.DataValueField = "accno";
DropDownList2.DataBind();
DropDownList2.Items.Insert(0, new ListItem("--Select--", "0"));
DropDownList2.SelectedIndex = 0;
}
else
{

}
}
protected void Button1_Click(object sender, EventArgs e)
{
obj.commall("select *from amount_mst where
accno='"+DropDownList2.SelectedItem.Text+"'","ac1");
if (obj.ds.Tables[0].Rows.Count > 0)
{
GridView1.DataSource = obj.ds.Tables["ac1"];
GridView1.DataBind();
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "k", "<script>alert('No Data
Found'); window.closed();</script>");
}
}
}

52
deposit.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class deposit : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{

}
protected void Button1_Click(object sender, EventArgs e)
{
string dt1 = txt_dt.Text;
string dd1 = dt1.Substring(0, 2);
string mon1 = dt1.Substring(3, 2);
string yr1 = dt1.Substring(6, 4);
string date1 = mon1 + "/" + dd1 + "/" + yr1;
obj.commall("insert into deposit_mst
values('"+DropDownList2.SelectedItem.Text+"','"+date1+"','"+txt_dby.Text+"','"+txt_a
mnt.Text+"','"+DropDownList3.SelectedItem.Text+"')", "i1");
decimal amount = Convert.ToDecimal(txt_amnt.Text);
obj.commall("select *from amount_mst where
accno='"+DropDownList2.SelectedItem.Text+"'","am1");
if (obj.ds.Tables[0].Rows.Count > 0)
{
decimal pamount = Convert.ToDecimal(obj.ds.Tables[0].Rows[0]["amount"]);
decimal tot = amount + pamount;
obj.commall("update amount_mst set amount='"+tot+"' where
accno='"+DropDownList2.SelectedItem.Text+"'", "u1");
}
txt_amnt.Text = "";
txt_dby.Text = "";
txt_dt.Text = "";
DropDownList3.SelectedIndex = -1;
DropDownList2.SelectedIndex = -1;
DropDownList1.SelectedIndex = -1;
}
protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs
e)
{
obj.commall("select *from account_create where branch='" +
DropDownList1.SelectedItem.Text + "'", "ai1");

53
 if (obj.ds.Tables["ai1"].Rows.Count > 0)
{

DropDownList2.DataSource = obj.ds.Tables["ai1"];
DropDownList2.DataTextField = "accno";
DropDownList2.DataValueField = "accno";
DropDownList2.DataBind();
DropDownList2.Items.Insert(0, new ListItem("--Select--", "0"));
DropDownList2.SelectedIndex = 0;
}
else
{

}
}
}

withdraw.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class withdraw : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{

}
protected void Button1_Click(object sender, EventArgs e)
{
string dt1 = txt_dt.Text;
string dd1 = dt1.Substring(0, 2);
string mon1 = dt1.Substring(3, 2);
string yr1 = dt1.Substring(6, 4);
string date1 = mon1 + "/" + dd1 + "/" + yr1;
obj.commall("insert into withdraw_mst
values('"+DropDownList2.SelectedItem.Text+"','"+txt_with.Text+"','"+date1+"')","w2");
decimal balance = Convert.ToDecimal(txt_balance.Text);
decimal wamount = Convert.ToDecimal(txt_with.Text);
decimal amount = balance - wamount;
obj.commall("update amount_mst set amount='"+amount+"' where
accno='"+DropDownList2.SelectedItem.Text+"'","w3");
DropDownList2.SelectedIndex = -1;
DropDownList1.SelectedIndex = -1;
txt_with.Text = "";

54
 txt_dt.Text = "";
txt_balance.Text = "";

}
protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs
e)
{
obj.commall("select *from account_create where branch='" +
DropDownList1.SelectedItem.Text + "'", "ai1");
if (obj.ds.Tables["ai1"].Rows.Count > 0)
{

DropDownList2.DataSource = obj.ds.Tables["ai1"];
DropDownList2.DataTextField = "accno";
DropDownList2.DataValueField = "accno";
DropDownList2.DataBind();
DropDownList2.Items.Insert(0, new ListItem("--Select--", "0"));
DropDownList2.SelectedIndex = 0;
}
else
{

}
}
protected void DropDownList2_SelectedIndexChanged(object sender, EventArgs
e)
{
obj.commall("select *from amount_mst where accno='" +
DropDownList2.SelectedItem.Text + "'", "w1");
if (obj.ds.Tables[0].Rows.Count > 0)
{
txt_balance.Text = obj.ds.Tables[0].Rows[0]["amount"].ToString();

}
else
{
}

protected void txt_with_TextChanged(object sender, EventArgs e)

{
decimal balance = Convert.ToDecimal(txt_balance.Text);
decimal wamount = Convert.ToDecimal(txt_with.Text);
decimal min = 1000;
decimal abalance = balance - min;
if (wamount <= abalance)
{
}
else
{

55
 Label6.Text = "Insufficient Balance";
}
}
}

depositdetails.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class depositdetails : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{

}
protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs
e)
{
obj.commall("select *from account_create where branch='" +
DropDownList1.SelectedItem.Text + "'", "ai1");
if (obj.ds.Tables["ai1"].Rows.Count > 0)
{

DropDownList2.DataSource = obj.ds.Tables["ai1"];
DropDownList2.DataTextField = "accno";
DropDownList2.DataValueField = "accno";
DropDownList2.DataBind();
DropDownList2.Items.Insert(0, new ListItem("--Select--", "0"));
DropDownList2.SelectedIndex = 0;
}
else
{

}
protected void Button1_Click(object sender, EventArgs e)
{
obj.commall("select *from deposit_mst where accno='" +
DropDownList2.SelectedItem.Text + "'", "d1");
if (obj.ds.Tables["d1"].Rows.Count > 0)
{
GridView1.DataSource = obj.ds.Tables["d1"];
GridView1.DataBind();

56
 }
else
{
ClientScript.RegisterStartupScript(this.GetType(), "k", "<script>alert('No Data
Found'); window.closed();</script>");
}

}
}

withdrawdetails.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class withdrawdetails : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{

}
protected void DropDownList1_SelectedIndexChanged(object sender, EventArgs
e)
{
obj.commall("select *from account_create where branch='" +
DropDownList1.SelectedItem.Text + "'", "ai1");
if (obj.ds.Tables["ai1"].Rows.Count > 0)
{

DropDownList2.DataSource = obj.ds.Tables["ai1"];
DropDownList2.DataTextField = "accno";
DropDownList2.DataValueField = "accno";
DropDownList2.DataBind();
DropDownList2.Items.Insert(0, new ListItem("--Select--", "0"));
DropDownList2.SelectedIndex = 0;
}
else
{

}
protected void Button1_Click(object sender, EventArgs e)
{

57
 obj.commall("select *from withdraw_mst where accno='" +
DropDownList2.SelectedItem.Text + "'", "w1");
if (obj.ds.Tables["w1"].Rows.Count > 0)
{
GridView1.DataSource = obj.ds.Tables["w1"];
GridView1.DataBind();
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "k", "<script>alert('No Data
Found'); window.closed();</script>");
}
}
}

USER

registration.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class user_registration : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{

}
protected void txt_accno_TextChanged(object sender, EventArgs e)
{
obj.commall("select *from account_create where
accno='"+txt_accno.Text+"'","r1");
if (obj.ds.Tables[0].Rows.Count > 0)
{
txt_name.Text = obj.ds.Tables[0].Rows[0]["accname"].ToString();
Label12.Text = " Valid Account Number";
}
else
{
Label12.Text = " Invalid Account Number";
}
}
protected void Button1_Click(object sender, EventArgs e)
{

58
 string dt1 = txt_dt.Text;
string dd1 = dt1.Substring(0, 2);
string mon1 = dt1.Substring(3, 2);
string yr1 = dt1.Substring(6, 4);
string date1 = mon1 + "/" + dd1 + "/" + yr1;
obj.commall("select *from cust_reg where accno='"+txt_accno.Text+"'","r2");
if (obj.ds.Tables[0].Rows.Count == 0)
{
obj.commall("insert into cust_reg values('" + txt_accno.Text + "','" +
txt_name.Text + "','" + date1 + "','" + txt_email.Text + "','" + txt_uname.Text + "','" +
txt_pwd.Text + "')", "r3");
txt_uname.Text = "";
txt_pwd.Text = "";
txt_name.Text = "";
txt_email.Text = "";
txt_dt.Text = "";
txt_cont.Text = "";
txt_accno.Text = "";
Label12.Text = "";

}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "k", "<script>alert('Account
Number already Register'); window.closed();</script>");
}

}
}

login.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Data.SqlClient;
using System.Data;
public partial class login : System.Web.UI.Page
{
SqlConnection con = new SqlConnection(@"Data Source=.\sqlexpress;Initial
Catalog=onlinebank;Integrated Security=True");
public DataSet ds = new DataSet();
protected void Page_Load(object sender, EventArgs e)
{

59
 protected void Button1_Click(object sender, EventArgs e)
{
con.Open();
DataSet ds = new DataSet();

SqlDataAdapter adp = new SqlDataAdapter("select *from cust_reg where

uname='" + txt_uname.Text + "'", con);
adp.Fill(ds);
int x = ds.Tables[0].Rows.Count;
if (x > 0)
{
string ss = ds.Tables[0].Rows[0]["pwd"].ToString();
if (ss == txt_pass.Text)
{
Session["uname"] = txt_uname.Text;
Response.Redirect("~/user/home.aspx");
}
else
{
Label2.Visible = true;
Label2.Text = "invalid password";
}
}
else
{
Label2.Visible = true;
Label2.Text = "invalid user name";

}
}
}

home.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class user_home : System.Web.UI.Page

{
protected void Page_Load(object sender, EventArgs e)
{
Label2.Text = Session["uname"].ToString();
}
}

60
balance.aspx.cs

sing System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class user_balance : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{
obj.commall("select *from cust_reg where uname='" + Session["uname"] + "'",
"ub1");
if (obj.ds.Tables[0].Rows.Count > 0)
{
string ac = obj.ds.Tables[0].Rows[0]["accno"].ToString();
obj.commall("select *from amount_mst where accno='" + ac + "'", "ub2");
if (obj.ds.Tables[0].Rows.Count > 0)
{
GridView1.DataSource = obj.ds.Tables["ub2"];
GridView1.DataBind();
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "k", "<script>alert('No
Data Found'); window.closed();</script>");
}
}

}}

deposit.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class user_deposit : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{
obj.commall("select *from cust_reg where uname='" + Session["uname"] + "'",
"ud1");

61
 if (obj.ds.Tables[0].Rows.Count > 0)
{
string ac = obj.ds.Tables[0].Rows[0]["accno"].ToString();
obj.commall("select *from deposit_mst where accno='" + ac + "'", "ud2");
if (obj.ds.Tables[0].Rows.Count > 0)
{
GridView1.DataSource = obj.ds.Tables["ud2"];
GridView1.DataBind();
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "k", "<script>alert('No
Data Found'); window.closed();</script>");
}
}
}}

withdraw.aspx.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class user_withdraw : System.Web.UI.Page

{
Class2 obj = new Class2();
protected void Page_Load(object sender, EventArgs e)
{
obj.commall("select *from cust_reg where uname='" + Session["uname"] + "'",
"ud1");
if (obj.ds.Tables[0].Rows.Count > 0)
{
string ac = obj.ds.Tables[0].Rows[0]["accno"].ToString();
obj.commall("select *from withdraw_mst where accno='" + ac + "'", "uw2");
if (obj.ds.Tables[0].Rows.Count > 0)
{
GridView1.DataSource = obj.ds.Tables["uw2"];
GridView1.DataBind();
}
else
{
ClientScript.RegisterStartupScript(this.GetType(), "k", "<script>alert('No
Data Found'); window.closed();</script>");
}
}
}
}

62
TESTING

SYSTEM TESTING

During system testing the system is used experimentally used to ensure

that the software does not fail, i.e., it will run according to its specification and in
the way the users expect. Special test data are input for processing and the
results examined. A limited number of users may be allowed to use the system
to see whether they try to use it in unforeseen ways. It is preferable to discover
any surprises before the organization implements the system.

Implementation and Evaluation

Implementations is the process of having systems personnel checkout and
put new equipment into use, train users, installs the new application and
construct any files of data needed to use it.

Evaluation of the system is performed to identify its strengths and

weakness. The actual evaluation can occur along any of the following
dimensions.

Operation Evaluation:

Assessment of the manner in which the system functions, including ease

of use, response time, suitability of information formats, overall reliability and
level of utilization.

Operational Impact:

Identification and measurement of benefits to the organization in such

areas as financial concerns operational efficiency, and competitive impact.
Includes impact on internal and external information flows.

User Manager Assessment:

Evaluation of the attitudes of senior and user managers within the

organization, as well as end-users.

Development Performance Evaluation of the development process in

accordance with such yardsticks as overall development time and effort,
conformance to budgets and standards, and other project management criteria.

SYSTEM IMPLEMENTATION

63
System Implementation is used to bring a developed system or sub system into
operational use and turning it over to the user. It involves programmer users and
operational management.

System Implementation components include:

Personal Orientation:

Introduce people to the new system and their relationship to the system

Training:

Give employees the tools and techniques to operate and use the system.

Hardware Installation:

Schedule for, prepare for, and then actually install new equipment.

Procedure Writing:

Develop procedure manual to follow in operating the new system.

Testing:

Ensure that the computer programs properly process the data.

File Conversion:

Load the information of the present files onto the new system files.

Parallel Operation:

Use the new system at the same time, as the old to make sure results are
correct.

CONCLUSION

64
 The ““Online Banking”” has been successfully completed. The goal of
the system is achieved and problems are solved. The package is developed in a
manner that it is user friendly and required help is provided at different levels.

The project can be easily used in the process of decision-making.

Different types of reports can be generated which help the management to take
correct decision and reduce the time delay which automatically increases the
company’s work standards as well as the economical state of the company.

This system never decreases the manpower but helps the development of
available manpower and optimizes the manpower by which company’s standards
and capabilities can be scaled to higher dimensions.

FUTURE SCOPE OF THE PROJECT

65
 The project has met the standards required to work at WebSite. If
the business logic remains same the project can be ported to any Website with
minor changes in the working procedure of the project. The project can be used
as an availability to develop a project for a different company with different
business logic wherein the commonalties in certain areas remain the same at
any business level. By using the common features in future development the
development time as well as the cost of development can be decreased
considerably.

BIBLOGRAPHY

66
The following books were referred during the analysis and execution phase of the
project

SQL SERVER 2008 REFERENCE BOOK

By Microsoft corporation

SOFTWARE ENGINEERING

By Roger.S.Pressman

Professional ASP.NET

By Wrox

MSDN 2008

By Microsoft

67