Professional Documents
Culture Documents
ABSTRACT
INTRODUCTION
Smartphones
Tablet computers
Netbooks
Ultra-mobile PCs
Wearable computers
Palmtops/pocket computers
Vehicles:
Tomorrows cars will comprise many wireless communication
systems and mobility aware applications. Music, news, road conditions,
weather reports, and other broadcast information are received via digital audio
broadcasting (DAB) with 1.5 M-bits/s. For personal communication, a global
system for mobile communications (GSM) phone might be available offering
voice and data connectivity with 384 k-bits/s. For remote areas satellite
communication can be used, while the current position of the car is determined
via global positioning system (GPS). Additionally, cars driving in the same
area build a local ad-hoc network for fast information exchange in emergency
situations or to help each other keeping a safe distance. In case of an accident,
not only will the airbag be triggered, but also an emergency call to a service
provider informing ambulance and police. Cars with this technology are
already available. Future cars will also inform other cars about accidents via the
ad hoc network to help them slow down in time, even before a driver can
recognize the accident. Buses, trucks, and train are already transmitting
maintenance and logistic information to their home base, which helps o improve
organization (fleet management), and thus save time and money.
Emergency:
Just imagine the possibilities of an ambulance with a high quality
wireless connection to a hospital. After an accident, vital information about
injured persons can be sent to the hospital immediately. There, all necessary
steps for this particular type of accident can be prepared or further specialists
can be consulted for an early diagnosis. Furthermore, wireless networks
are the only means of communication in the case of natural disasters such as
hurricanes or earthquakes.
Business:
Todays typical traveling salesman needs instant access to the
companys database: to ensure that the files on his or her laptop reflect the
actual state, to enable the company to keep track of all activities of their
traveling employees, to keep databases consistent etc., with wireless access, the
laptop can be turned into a true mobile office.
Mobile computing has changed the complete landscape of human being life.
Following are the clear advantages of Mobile Computing:
Location flexibility:
This has enabled user to work from anywhere as long as there is a connection
established. A user can work without being in a fixed position. Their mobility
ensures that they are able to carry out numerous tasks at the same time perform
their stated jobs.
Saves Time:
Enhanced Productivity:
Productive nature has been boosted by the fact that a worker can simply work
efficiently and effectively from which ever location they see comfortable and
suitable. Users are able to work with comfortable environments.
Ease of research:
Research has been made easier, since users will go to the field and search for
facts and feed them back to the system. It has also made it easier for field
officer and researchers to collect and feed data from wherever they without
making unnecessary trip to and from the office to the field.
Entertainment:
Video and audio recordings can now be streamed on the go using mobile
computing. It's easy to access a wide variety of movies, educational and
informative material. With the improvement and availability of high speed data
connections at considerable costs, one is able to get all the entertainment they
want as they browser the internet for streamed data. One can be able to watch
news, movies, and documentaries among other entertainment offers over the
internet. This was not such before mobile computing dawned on the computing
world.
Some business functions can be run over secure links and also the sharing of
information between business partners. Also it's worth noting that lengthy
travelling has been reduced, since there is the use of voice and video
conferencing.
Meetings, seminars and other informative services can be conducted using the
video and voice conferencing. This cuts down on travel time and expenditure
SYSTEM ANALYSIS
Implementation is the stage of the project when the theoretical design is turned
out into a working system. Thus it can be considered to be the most critical stage in
achieving a successful new system and in giving the user, confidence that the new
system will work and be effective.
MODULES:
A module is a part of a program. Programs are composed of one or more
independently developed modules that are not combined until the program is linked. A
single module can contain one or several routines.
Segmentation Module
SEGMENTATION MODULE:
In this module, a node receives the pages in the sequential order. When a node
receives a page, it advertises about its available pages. When a node learns that
another node has more available pages, it requests for the page and the page
transmission starts. In this way, ECD does not require a node to have an entire code
image to serve other nodes. Instead, whenever a node has more available pages, it can
serve other nodes having fewer available pages. So as long as the transmissions at two
links do not collide, different pages can be transmitted concurrently at these two links.
In this module, we estimate the number of uncovered nodes and the outbound
link qualities to them. In order to estimate the number of uncovered nodes, we use the
REQ messages sent by uncovered nodes when missing packets are detected. in ECD,
the uncovered nodes send REQ messages unless there is an ongoing page
transmission. The
estimation period for sending and receiving REQ messages is carefully selected to
avoid REQ collisions.
CHAPTER 4
LITERATURE SURVEY
4.1 OVERVIEW:
Wireless ad hoc networks have played an increasingly important role in a wide range of
applications. A key challenge in such networks is to achieve maximum lifetime for battery-
powered mobile devices with dynamic energy-efficient algorithms. Recent studies in battery
technology have revealed that the behaviour of battery discharging is more complex than we
used to know. Battery-powered devices might waste a huge amount of energy if their
battery discharging is not carefully scheduled and budgeted. In this paper, we introduce a
novel energy model for batteries and study the effect of battery behaviour on routing in
wireless ad hoc networks. We first propose an online computable discrete-time
mathematical model to capture battery discharging behaviour. The model has low
computational complexity and data storage requirement. It is therefore suitable for online
battery capacity computation in routing. Our evaluations indicate that the model can
accurately capture the behaviour of battery discharging. Based on this battery model, we
then propose a battery-aware routing (BAR) scheme for wireless ad hoc networks. BAR is a
generic scheme that implements battery awareness in routing protocols and is independent
of any specific routing protocol. By dynamically choosing the devices with well-recovered
batteries as routers and leaving the fatigue batteries for recovery, the BAR scheme can
effectively recover the device's battery capacity to achieve higher energy efficiency. Our
simulation results demonstrate that, by adopting the BAR scheme, network lifetime and data
throughput can be increased by up to 28% and 24%, respectively. The results also show that
BAR achieves good performance in various networks composed of different devices,
batteries, and node densities. Finally, we also propose an enhanced prioritized BAR (PBAR)
scheme for time-sensitive applications in wireless ad hoc networks. Our simulation results
illustrate that PBAR achieves good performance in terms of end-to-end delay and data
throughput.
In this paper, we propose a new data-gathering mechanism for large-scale wireless sensor
networks by introducing mobility into the network. A mobile data collector, for
convenience called an M-collector in this paper, could be a mobile robot or a vehicle
equipped with a powerful transceiver and battery, working like a mobile base station and
gathering data while moving through the field. An M-collector starts the data-gathering tour
periodically from the static data sink, polls each sensor while traversing its transmission
range, then directly collects data from the sensor in single-hop communications, and finally
transports the data to the static sink. Since data packets are directly gathered without relays
and collisions, the lifetime of sensors is expected to be prolonged. In this paper, we mainly
focus on the problem of minimizing the length of each data-gathering tour and refer to this
as the single-hop data-gathering problem (SHDGP). We first formalize the SHDGP into a
mixed-integer program and then present a heuristic tour-planning algorithm for the case
where a single M-collector is employed. For the applications with strict distance/time
constraints, we consider utilizing multiple M-collectors and propose a data-gathering
algorithm where multiple M-collectors traverse through several shorter subtours
concurrently to satisfy the distance/time constraints. Our single-hop mobile data-gathering
scheme can improve the scalability and balance the energy consumption among sensors. It
can be used in both connected and disconnected networks. Simulation results demonstrate
that the proposed data-gathering algorithm can greatly shorten the moving distance of the
collectors compared with the covering line approximation algorithm and is close to the
optimal algorithm for small networks. In addition, the proposed data-gathering scheme can
significantly prolong the network lifetime compared with a network with static data sink or
a network in which the mobile collector can only move along straight lines.
Recent advances have shown a great potential of mobile data gathering in wireless sensor
networks, where one or more mobile collectors are employed to collect data from sensors
via short-range communications. Among a variety of data gathering approaches, one typical
scheme is called anchor-based mobile data gathering. In such a scheme, during each
periodic data gathering tour, the mobile collector stays at each anchor point for a period of
sojourn time, and in the meanwhile the nearby sensors transmit data to the collector in a
multihop fashion. In this paper, we focus on such a data gathering scheme and provide
distributed algorithms to achieve its optimal performance. We consider two different cases
depending on whether the mobile collector has fixed or variable sojourn time at each anchor
point. We adopt network utility, which is a properly defined function, to characterize the
data gathering performance, and formalize the problems as network utility maximization
problems under the constraints of guaranteed network lifetime and data gathering latency.
To efficiently solve these problems, we decompose each of them into several subproblems
and solve them in a distributed manner, which facilitates the scalable implementation of the
optimization algorithms. Finally, we provide extensive numerical results to demonstrate the
usage and efficiency of the proposed algorithms and complement our theoretical analysis.
4.5 BOUNDED RELAY HOP MOBILE DATA GATHERING IN
WIRELESS SENSOR NETWORKS
Recent study reveals that great benefit can be achieved for data gathering in wireless sensor
networks by employing mobile collectors that gather data via short-range communications.
To pursue maximum energy saving at sensor nodes, intuitively, a mobile collector should
traverse the transmission range of each sensor in the field such that each data packet can be
directly transmitted to the mobile collector without any relay. However, this approach may
lead to significantly increased data gathering latency due to the low moving velocity of the
mobile collector. Fortunately, it is observed that data gathering latency can be effectively
shortened by performing proper local aggregation via multihop transmissions and then
uploading the aggregated data to the mobile collector. In such a scheme, the number of local
transmission hops should not be arbitrarily large as it may increase the energy consumption
on packet relays, which would adversely affect the overall efficiency of mobile data
gathering. Based on these observations, in this paper, we study the trade off between energy
saving and data gathering latency in mobile data gathering by exploring a balance between
the relay hop count of local data aggregation and the moving tour length of the mobile
collector. We first propose a polling-based mobile gathering approach and formulate it into
an optimization problem, named bounded relay hop mobile data gathering (BRH-MDG).
Specifically, a subset of sensors will be selected as polling points that buffer locally
aggregated data and upload the data to the mobile collector when it arrives. In the
meanwhile, when sensors are affiliated with these polling points, it is guaranteed that any
packet relay is bounded within a given number of hops. We then give two efficient
algorithms for selecting polling points among sensors. The effectiveness of our approach is
validated through extensive simulations.
Recent studies have shown that significant benefit can be achieved in wireless sensor
networks (WSNs) by employing mobile collectors for data gathering via short-range
communications. A typical scenario for such a scheme is that a mobile collector roams over
the sensing field and pauses at some anchor points on its moving tour such that it can
traverse the transmission range of all the sensors in the field and directly collect data from
each sensor. In this paper, we study the performance optimization of such mobile data
gathering by formulating it into a cost minimization problem constrained by the channel
capacity, the minimum amount of data gathered from each sensor and the bound of total
sojourn time at all anchor points. We assume that the cost of a sensor for a particular anchor
point is a function of the data amount a sensor uploads to the mobile collector during its
sojourn time at this anchor point. In order to provide an efficient and distributed algorithm,
we decompose this global optimization problem into two sub problems to be solved by each
sensor and the mobile collector, respectively. We show that such decomposition can be
characterized as a pricing mechanism, in which each sensor independently adjusts its
payment for the data uploading opportunity to the mobile collector based on the shadow
prices of different anchor points. Correspondingly, we give an efficient algorithm to jointly
solve the two sub problems. Our theoretical analysis demonstrates that the proposed
algorithm can achieve the optimal data control for each sensor and the optimal sojourn time
allocation for the mobile collector, which minimizes the overall network cost. Finally,
extensive simulation results further validate that our algorithm achieves lower cost than the
compared data gathering strategy.
CHAPTER 5
5.1 METHODOLOGY
DISTRIBUTED ALGORITHM :
ADAPTIVE ALGORITHM
SYSTEM SPECIFICATION
SOFTWARE ENVIRONMENT
.NET Framework
The Microsoft .NET Framework (pronounced dot net) is a software
framework developed by Microsoft that runs primarily on Microsoft Windows. It
includes a large class library known as Framework Class Library (FCL) and
provides language interoperability (each language can use code written in other
languages) across several programming languages. Programs written for .NET
Framework execute in a software environment (as contrasted
to hardware environment), known as Common Language Runtime (CLR),
an application virtual machine that provides services such as security, memory
management, and exception handling. FCL and CLR together constitute .NET
Framework.
.NET Framework family also includes two versions for mobile or embedded
device use. A reduced version of the framework, .NET Compact Framework, is
available on Windows CE platforms, including Windows Mobile devices such
as smartphones. Additionally, .NET Micro Framework is targeted at severely
resource-constrained devices.
ARCHITECTURE
For computer programs to run on CLI, they need to be compiled into Common
Intermediate Language (CIL) as opposed to being compiled into machine code.
Upon execution, an architecture-specific Just-in-time compiler (JIT) turns the CIL
code into machine code. To improve performance, however, .NET Framework comes
with Native Image Generator (NGEN) that performs ahead-of-time compilation.
Figure 2: visual overview of the common language infrastructure (CLI)
CLASS LIBRARY
.NET Framework includes a set of standard class libraries. The class library is
organized in a hierarchy of namespaces. Most of the built-in APIs are part of
either System.* or Microsoft.* namespaces. These class libraries implement a large
number of common functions, such as file reading and writing, graphic rendering,
database interaction, and XML document manipulation, among others. .NET class
libraries are available to all CLI compliant languages. .NET Framework class library
is divided into two parts: Framework Class Library (FCL) and Base Class
Library (BCL).
.NET CORE
.NET Core is a free and open-source partial implementation of the .NET
Framework. It consists of CoreCLR and CoreFX, which are partial forks of CLR and
BCL respectively.NET Core comes with an improved JIT compiler, called RyuJIT.
ASSEMBLIES
Compiled CIL code is stored in CLI assemblies. As mandated by the
specification, assemblies are stored in Portable Executable (PE) file format, common
on Windows platform for all DLL and EXE files. Each assembly consists of one
or more files, one of which must contain a manifest bearing the metadata for the
assembly. The complete name of an assembly (not to be confused with the file name
on disk) contains its simple text name, version number, culture, and public key token.
Assemblies are considered equivalent if they share the same complete name,
excluding the revision of the version number. A private key can also be used by the
creator of the assembly for strong naming. The public key token identifies which
private key an assembly is signed with. Only the creator of the keypair (typically
.NET developer signing the assembly) can sign assemblies that have the same strong
name as a previous version assembly, since the creator is in possession of the private
key. Strong naming is required to add assemblies to Global Assembly Cache.
DESIGN TENETS
LANGUAGE INDEPENDENCE
.NET Framework introduces a Common Type System (CTS) that defines all
possible data types and programming constructs supported by CLR and how they may
or may not interact with each other conforming to CLI specification. Because of this
feature, .NET Framework supports the exchange of types and object instances
between libraries and applications written using any conforming .NET language.
PORTABILITY
While Microsoft has never implemented the full framework on any system
except Microsoft Windows, it has engineered the framework to be platform-
agnostic, and cross-platform implementations are available for other operating
systems. Microsoft submitted the specifications for CLI (which includes the core class
libraries, CTS, and CIL), and C++/CLI to both ECMA and ISO, making them
available as official standards. This makes it possible for third parties to create
compatible implementations of the framework and its languages on other platforms.
SECURITY
.NET Framework has its own security mechanism with two general
features: Code Access Security (CAS), and validation and verification. CAS is based
on evidence that is associated with a specific assembly. Typically the evidence is the
source of the assembly (whether it is installed on the local machine or has been
downloaded from the intranet or Internet). CAS uses evidence to determine the
permissions granted to the code. Other code can demand that calling code be granted a
specified permission. The demand causes CLR to perform a call stack walk: every
assembly of each method in the call stack is checked for the required permission; if
any assembly is not granted the permission a security exception is thrown.
MEMORY MANAGEMENT
CLR frees the developer from the burden of managing memory (allocating and
freeing up when done); it handles memory management itself by detecting when
memory can be safely freed. Instantiations of .NET types (objects) are allocated from
the managed heap; a pool of memory managed by CLR. As long as there exists a
reference to an object, which might be either a direct reference to an object or via
a graph of objects, the object is considered to be in use. When there is no reference to
an object, and it cannot be reached or used, it becomes garbage, eligible for collection.
.NET Framework includes a garbage collector which runs periodically, on a
separate thread from the application's thread, that enumerates all the unusable objects
and reclaims the memory allocated to them and this is more effcient then the java.
SIMPLIFIED DEPLOYMENT
.NET Framework includes design features and tools which help manage the
installation of computer software to ensure that it does not interfere with previously
installed software, and that it conforms to security requirements.
Features Of . Net:
.NET is also the collective name given to various software components built
upon the .NET platform. These will be both products (Visual Studio.NET and
Windows.NET Server, for instance) and services (like Passport, .NET My Services,
and so on).
Managed Code:
The code that targets .NET, and which contains certain extra Information-
metadata - to describe itself. Whilst both managed and unmanaged code can run in
the runtime, only managed code contains the information that allows the CLR to
guarantee, for instance, safe execution and interoperability.
Managed Data
The CLR uses something called the Common Type System (CTS) to strictly
enforce type-safety. This ensures that all classes are compatible with each other, by
describing types in a common way. CTS define how types work within the runtime,
which enables types in one language to interoperate with types in another language,
including cross-language exception handling. As well as ensuring that types are only
used in appropriate ways, the runtime also ensures that code doesnt attempt to access
memory that hasnt been allocated to it.
Common Language Specification
OVERLOADING
HISTORY:
GENESIS
Prior to version 7.0 the code base for MS SQL Server was sold by Sybase SQL
Server to Microsoft, and was Microsoft's entry to the enterprise-level database market,
competing against Oracle, IBM, and, later, Sybase. Microsoft, Sybase and Ashton-
Tate originally worked together to create and market the first version named SQL
Server 1.0 for OS/2 (about 1989) which was essentially the same as Sybase SQL
Server 3.0 on Unix,VMS, etc.
Since the release of SQL Server 2000, advances have been made in performance, the
client IDE tools, and several complementary systems that are packaged with SQL
Server 2005. These include:
The OLAP Services feature available in SQL Server version 7.0 is now called
SQL Server 2000 Analysis Services. The term OLAP Services has been replaced with
the term Analysis Services. Analysis Services also includes a new data mining
component. The Repository component available in SQL Server version 7.0 is now
called Microsoft SQL Server 2000 Meta Data Services. References to the component
now use the term Meta Data Services. The term repository is used only in reference to
the repository engine within Meta Data Services
They are,
1. TABLE
2. QUERY
3. FORM
4. REPORT
5. MACRO
TABLE:
VIEWS OF TABLE:
1. Design View
2. Datasheet View
Design View
To build or modify the structure of a table we work in the table design view.
We can specify what kind of data will be hold.
Datasheet View
To add, edit or analyses the data itself we work in tables datasheet view mode.
QUERY:
A query is a question that has to be asked the data. Access gathers data that
answers the question from one or more table. The data that make up the answer is
either dynaset (if you edit it) or a snapshot (it cannot be edited).Each time we run
query, we get latest information in the dynaset. Access either displays the dynaset or
snapshot for us to view or perform an action on it, such as deleting or updating.
CHAPTER 8
INPUT DESIGN
The input design is the link between the information system and the user. It
comprises the developing specification and procedures for data preparation and
those steps are necessary to put transaction data in to a usable form for
processing can be achieved by inspecting the computer to read data from a
written or printed document or it can occur by having people keying the data
directly into the system. The design of input focuses on controlling the amount
of input required, controlling the errors, avoiding delay, avoiding extra steps
and keeping the process simple. The input is designed in such a way so that it
provides security and ease of use with retaining the privacy. Input Design
considered the following things:
OBJECTIVES
3.When the data is entered it will check for its validity. Data can be entered with
the help of screens. Appropriate messages are provided as when needed so that
the user
will not be in maize of instant. Thus the objective of input design is to create an
input layout that is easy to follow
OUTPUT DESIGN
A quality output is one, which meets the requirements of the end user and
presents the information clearly. In any system results of processing are
communicated to the users and to other system through outputs. In output
design it is determined how the information is to be displaced for immediate
need and also the hard copy output. It is the most important and direct source
information to the user. Efficient and intelligent output design improves the
systems relationship to help user decision-making.
SYSTEM DESIGN
DATAFLOW DIAGRAM:
It is common practice to draw the context-level data flow diagram first, which
shows the interaction between the system and external agents which act as data
sources and data sinks. This helps to create an accurate drawing in the context
diagram. The system's interactions with the outside world are modeled purely in
terms of data flows across the system boundary. The context diagram shows the
entire system as a single process, and gives no clues as to its internal organization.
Login
CLIENT ADMIN
Check
no
Exists Sign Up Exists
yes yes
Upload Files
File Request
vai Router
no View Requet
File Receive Check Files
with packets ipaddress?
yes
Download File File Verification
with security No Check
packet's receive verification?
End
SEQUENCE DIAGRAM:
A Sequence diagram is an interaction diagram that shows how processes
operate with one another and what is their order. It is a construct of a Message
Sequence Chart. A sequence diagram shows object interactions arranged in time
sequence. It depicts the objects and classes involved in the scenario and the
sequence of messages exchanged between the objects needed to carry out the
functionality of the scenario. Sequence diagrams are typically associated with
use case realizations in the Logical View of the system under development. Sequence
diagrams are sometimes called event diagrams or event scenarios.
Upload Files
Socket Connection
Socket Connection
Speed Violation
IP Address
Energy
Energy
file received
Download File
USE CASE DIAGRAM:
In UML there are five diagrams available to model dynamic nature and use
case diagram is one of them. Now as we have to discuss that the use case diagram is
dynamic in nature there should be some internal or external factors for making the
interaction. These internal and external agents are known as actors. So use case
diagrams are consists of actors, use cases and their relationships.
Login
File Upload
Socet Connection
File Receive
with packets
File Transfer
Activity Diagram:
ADMIN CLIENT
No
Upload Files Sign Up Exists
Yes
yes Check
no
ipaddress?
File Request
Verify Request
File Received
File Received
With Packets
Proceed Files
File Not
Received
File Download
No socket Yes
connection
CLASS DIAGRAM:
In software engineering, a class diagram in the Unified Modeling
Language (UML) is a type of static structure diagram that describes the structure of a
system by showing the system's classes, their attributes, operations (or methods),
and the relationships among objects.
The class diagram is the main building block of object oriented modelling. It is
used both for general conceptual modelling of the systematics of the application, and
for detailed modelling translating the models into programming code. Class diagrams
can also be used for data modeling. The classes in a class diagram represent both the
main objects, interactions in the application and the classes to be programmed.
In the diagram, classes are represented with boxes which contain three parts:
The top part contains the name of the class. It is printed in bold and
centered, and the first letter is capitalized.
The middle part contains the attributes of the class. They are left-
aligned and the first letter is lowercase.
The bottom part contains the methods the class can execute. They are
also left-aligned and the first letter is lowercase.
MEMBERS:
Visibility
To specify the visibility of a class member (i.e., any attribute or method), these
notations must be placed before the member's name:
+ Public
- Private
# Protected
~ Package
Scopes
The UML specifies two types of scope for members: instance and classifier.[4]
Loginidgenration() upload()
CreateAccount() fileidgenration()
CHAPTER 10
SYSTEM STUDY
FEASIBILITY STUDY:
Economical feasibility
Technical feasibility
Social feasibility
ECONOMICAL FEASIBILITY:
This study is carried out to check the economic impact that the system
will have on the organization. The amount of fund that the company can pour
into the research and development of the system is limited. The expenditures
must be justified. Thus the developed system as well within the budget and this
was achieved because most of the technologies used are freely available. Only
the customized products had to be purchased.
TECHNICAL FEASIBILITY:
This study is carried out to check the technical feasibility, that is, the
technical requirements of the system. Any system developed must not have a
high demand on the available technical resources. This will lead to high
demands on the available technical resources. This will lead to high demands
being placed on the client. The developed system must have a modest
requirement, as only minimal or null changes are required for implementing this
system.
SOCIAL FEASIBILITY:
SYSTEM TESTING
TYPES OF TESTS:
Testing is the process of trying to discover every conceivable fault or
weakness in a work product. The different type of testing are given below:
UNIT TESTING:
Unit testing involves the design of test cases that validate that the internal
program logic is functioning properly, and that program inputs produce valid
outputs. All decision branches and internal code flow should be validated. It is
the testing of individual software units of the application .it is done after the
completion of an individual unit before integration.
FUNCTIONAL TEST:
Functional tests provide systematic demonstrations that functions tested are
available as specified by the business and technical requirements, system
documentation, and user manuals.
Functional testing is centered on the following items:
Features to be tested
Verify that the entries are of the correct format
No duplicate entries should be allowed
All links should take the user to the correct page.
INTEGRATION TESTING:
Software integration testing is the incremental integration testing of two
or more integrated software components on a single platform to produce failures
caused by interface defects.
The task of the integration test is to check that components or software
applications, e.g. components in a software system or one step up software
applications at the company level interact without error.
Test Results: All the test cases mentioned above passed successfully. No
defects encountered.
ACCEPTANCE TESTING:
User Acceptance Testing is a critical phase of any project and requires
significant participation by the end user. It also ensures that the system meets
the functional requirements.
Test Results: All the test cases mentioned above passed successfully. No
defects encountered
CHAPTER 12
SOURCE CODE
REGISTER:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Configuration;
namespace Clients
{
public partial class Form2 : Form
{
string constring =
Convert.ToString(ConfigurationSettings.AppSettings["ConnectionString"]);
Class1 cs = new Class1();
string p1, p2;
public Form2()
{
InitializeComponent();
}
con.Open();
SqlCommand cmd = new SqlCommand("insert into
Register values('" + textBox1.Text + "','" + textBox2.Text + "','" + textBox3.Text +
"','" + textBox4.Text + "','" + textBox5.Text + "','" + textBox6.Text + "')", con);
cmd.ExecuteNonQuery();
DialogResult dlgResult =
MessageBox.Show("REGISTRATION SUCCESS..", "Message Box", MessageBoxButtons.OK,
MessageBoxIcon.Information);
if (dlgResult == DialogResult.OK)
{
textBox1.Text =
Convert.ToString(cs.idgeneration());
textBox2.Text = "";
textBox3.Text = "";
textBox4.Text = "";
textBox5.Text = "";
textBox6.Text = "";
}
}
}
}
Outer:
p2 = "";
}
}
}
}
//}
}
private void label1_Click(object sender, EventArgs e)
{
}
}
LOGIN:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Configuration;
using System.Net.Sockets;
using System.Net;
using System.IO;
namespace Clients
{
public partial class Form1 : Form
{
string constring =
Convert.ToString(ConfigurationSettings.AppSettings["ConnectionString"]);
string p1, p2, p3;
int totreqcount;
string rproceedstatus = "Proceed", empty = "";
public Form1()
{
InitializeComponent();
}
toolTip1.AutoPopDelay = 5000;
toolTip1.InitialDelay = 500;
toolTip1.ReshowDelay = 500;
toolTip1.ShowAlways = true;
toolTip1.SetToolTip(this.pictureBox7, "Click To Reload");
toolTip1.SetToolTip(this.pictureBox1, "Click To User Login");
toolTip1.SetToolTip(this.label3, "Click To User Login");
toolTip1.SetToolTip(this.pictureBox2, "Click To User Register");
toolTip1.SetToolTip(this.label4, "Click To User Register");
toolTip1.SetToolTip(this.pictureBox8, "Click To File Request");
toolTip1.SetToolTip(this.label9, "Click To File Request");
toolTip1.SetToolTip(this.pictureBox3, "Click To Start Transaction");
toolTip1.SetToolTip(this.label5, "Click To Start Transaction");
con.Open();
con.Close();
}
con.Open();
con.Close();
}
}
}
File Request:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Configuration;
namespace Clients
{
public partial class FileRequest : Form
{
string constring =
Convert.ToString(ConfigurationSettings.AppSettings["ConnectionString"]);
string rstatus = "Request", rproceedstatus = "Proceed", ruploadstatus =
"Upload";
int count = 1, totreqcount, totreqcount1;
con.Open();
SqlDataAdapter adp = new SqlDataAdapter("Select * from FileUpload", con);
DataSet ds = new DataSet();
adp.Fill(ds);
if (ds.Tables[0].Rows.Count == 3)
{
comboBox1.Items.Insert(0, "--SELECT--");
comboBox1.SelectedIndex = 0;
for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
{
comboBox1.Items.Add(ds.Tables[0].Rows[i]["id"].ToString());
}
con.Close();
}
else
{
SqlDataAdapter adp1 = new SqlDataAdapter("Select * from FileUpload
where rstatus='" + rstatus + "'", con);
DataSet ds1 = new DataSet();
adp1.Fill(ds1);
if (ds1.Tables[0].Rows.Count == 3)
{
MessageBox.Show("Warning : Files Already Request !.", "Message
Box", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
}
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
SqlConnection con = new SqlConnection(constring);
if (count == 1)
{
}
else
{
if (comboBox1.SelectedIndex == 0)
{
btnrequest.Enabled = false;
label3.Text = "....................";
label4.Text = "....................";
label5.Text = "....................";
MessageBox.Show("Select Any One File ID.", "Message Box",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
con.Open();
SqlDataAdapter adp = new SqlDataAdapter("Select * from FileUpload
where id='" + comboBox1.SelectedItem.ToString() + "'", con);
DataSet ds = new DataSet();
adp.Fill(ds);
label3.Text = ds.Tables[0].Rows[0]["ufilename"].ToString();
label4.Text = ds.Tables[0].Rows[0]["ufilesize"].ToString();
label5.Text = ds.Tables[0].Rows[0]["ufileext"].ToString();
con.Close();
btnrequest.Enabled = true;
}
}
count++;
}
con.Open();
if (dlgResult == DialogResult.OK)
{
btnrequest.Enabled = false;
//comboBox1.SelectedIndex = 0;
label3.Text = "....................";
label4.Text = "....................";
label5.Text = "....................";
}
}
else
{
DialogResult dlgResult1 = MessageBox.Show("BUFFER OVERFLOW(3
request only)..", "Message Box", MessageBoxButtons.OK, MessageBoxIcon.Information);
if (dlgResult1 == DialogResult.OK)
{
btnrequest.Enabled = false;
//comboBox1.SelectedIndex = 0;
label3.Text = "....................";
label4.Text = "....................";
label5.Text = "....................";
}
}
con.Close();
}
}
}
}
Transaction:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Configuration;
using System.Net;
using System.Net.Sockets;
using System.IO;
namespace Clients
{
public partial class Transaction : Form
{
string constring =
Convert.ToString(ConfigurationSettings.AppSettings["ConnectionString"]);
string reqstatus;
int count, filesize1, filesize2, filesize3, eachfilesize, totalfilesize;
string filename1, filename2, filename3, filenames, totalbytes;
string username1, username2, username3;
double tstart, tcalc, tend;
public Transaction()
{
InitializeComponent();
}
con.Open();
if (reqstatus == "Proceed")
{
count++;
if (count == 1)
{
groupBox1.Text = "CLIENT - 1 ( " +
ds3.Tables[0].Rows[i]["rusername"].ToString() + " )";
username1 = ds3.Tables[0].Rows[i]["rusername"].ToString();
filesize1 =
Convert.ToInt32(ds3.Tables[0].Rows[i]["ufilesize"].ToString());
eachfilesize = filesize1 / 10;
label16.Text = Convert.ToString(filesize1) + " bytes";
label15.Text = Convert.ToString(eachfilesize) + " bytes";
filename1 = ds3.Tables[0].Rows[i]["ufilename"].ToString();
}
else
{
if (count == 2)
{
groupBox3.Text = "CLIENT - 2 ( " +
ds3.Tables[0].Rows[i]["rusername"].ToString() + " )";
username2 = ds3.Tables[0].Rows[i]["rusername"].ToString();
filesize2 =
Convert.ToInt32(ds3.Tables[0].Rows[i]["ufilesize"].ToString());
eachfilesize = filesize2 / 10;
label17.Text = Convert.ToString(filesize2) + " bytes";
label18.Text = Convert.ToString(eachfilesize) + " bytes";
filename2 = ds3.Tables[0].Rows[i]["ufilename"].ToString();
}
else
{
if (count == 3)
{
groupBox7.Text = "CLIENT - 3 ( " +
ds3.Tables[0].Rows[i]["rusername"].ToString() + " )";
username3 =
ds3.Tables[0].Rows[i]["rusername"].ToString();
filesize3 =
Convert.ToInt32(ds3.Tables[0].Rows[i]["ufilesize"].ToString());
eachfilesize = filesize3 / 10;
totalfilesize = filesize1 + filesize2 + filesize3;
totalbytes = Convert.ToString(totalfilesize) + "
(Bytes) Are Received";
label31.Text = Convert.ToString(filesize3) + " bytes";
label32.Text = Convert.ToString(eachfilesize) + "
bytes";
filename3 =
ds3.Tables[0].Rows[i]["ufilename"].ToString();
}
}
}
}
}
}
msgrec();
}
else
{
if (rnno == 126)
{
tend = tstart - Convert.ToDouble(DateTime.Now.Millisecond) / 1000;
tcalc = tend;
//Packet - 1
label1.Text = "Processing..";
label1.ForeColor = System.Drawing.Color.Yellow;
label28.Text = "Processing..";
label28.ForeColor = System.Drawing.Color.Yellow;
label42.Text = "Processing..";
label42.ForeColor = System.Drawing.Color.Yellow;
Application.DoEvents();
System.Threading.Thread.Sleep(2000);
button1.BackColor = Color.Lime;
button20.BackColor = Color.Lime;
button30.BackColor = Color.Lime;
label1.Text = "Receive";
label1.ForeColor = System.Drawing.Color.Lime;
label28.Text = "Receive";
label28.ForeColor = System.Drawing.Color.Lime;
label42.Text = "Receive";
label42.ForeColor = System.Drawing.Color.Lime;
Application.DoEvents();
System.Threading.Thread.Sleep(1000);
msgrec();
}
else
{
if (rnno == 127)
{
tend = tstart - Convert.ToDouble(DateTime.Now.Millisecond) /
1000;
tcalc = tend;
//Packet - 1
label1.Text = "Processing..";
label1.ForeColor = System.Drawing.Color.Yellow;
label28.Text = "Processing..";
label28.ForeColor = System.Drawing.Color.Yellow;
label42.Text = "Processing..";
label42.ForeColor = System.Drawing.Color.Yellow;
Application.DoEvents();
System.Threading.Thread.Sleep(2000);
button1.BackColor = Color.Lime;
button20.BackColor = Color.Lime;
button30.BackColor = Color.Lime;
label1.Text = "Receive";
label1.ForeColor = System.Drawing.Color.Lime;
label28.Text = "Receive";
label28.ForeColor = System.Drawing.Color.Lime;
label42.Text = "Receive";
label42.ForeColor = System.Drawing.Color.Lime;
Application.DoEvents();
System.Threading.Thread.Sleep(1000);
msgrec();
}
else
{
if (rnno == 128)
{
tend = tstart - Convert.ToDouble(DateTime.Now.Millisecond)
/ 1000;
tcalc = tend;
//Packet - 1
label1.Text = "Processing..";
label1.ForeColor = System.Drawing.Color.Yellow;
label28.Text = "Processing..";
label28.ForeColor = System.Drawing.Color.Yellow;
label42.Text = "Processing..";
label42.ForeColor = System.Drawing.Color.Yellow;
Application.DoEvents();
System.Threading.Thread.Sleep(2000);
button1.BackColor = Color.Lime;
button20.BackColor = Color.Lime;
button30.BackColor = Color.Lime;
label1.Text = "Receive";
label1.ForeColor = System.Drawing.Color.Lime;
label28.Text = "Receive";
label28.ForeColor = System.Drawing.Color.Lime;
label42.Text = "Receive";
label42.ForeColor = System.Drawing.Color.Lime;
Application.DoEvents();
System.Threading.Thread.Sleep(1000);
msgrec();
}
}
}
}
}
if (dlgResult == DialogResult.OK)
{
filenames = "File Name : " + filename1 + "\n\n" + "File Name : " +
filename2 + "\n\n" + "File Name : " + filename3 + "\n\n";
groupBox5.Text = "filename : "+ filename1;
groupBox2.Text = "filename : " + filename2;
groupBox6.Text = "filename : " + filename3;
//pictureBox2.Enabled = true;
pictureBox1.Enabled = true;
//pictureBox3.Enabled = true;
pictureBox4.Enabled = true;
//pictureBox5.Enabled = true;
pictureBox6.Enabled = true;
}
}
class Clients
{
IPEndPoint ipEnd;
Socket sock;
public Clients()
{
string hostName = Dns.GetHostName();
// IPHostEntry ipEntry = Dns.GetHostEntry(Environment.MachineName);
IPAddress IpAddr = Dns.GetHostByName(hostName).AddressList[0];
ipEnd = new IPEndPoint(IpAddr, 5658);
sock = new Socket(ipEnd.AddressFamily, SocketType.Stream,
ProtocolType.IP);
sock.Bind(ipEnd);
/*
IPHostEntry ipEntry = Dns.GetHostEntry(Environment.MachineName);
IPAddress IpAddr = ipEntry.AddressList[0];
ipEnd = new IPEndPoint(IpAddr, 5659);
sock = new Socket(ipEnd.AddressFamily, SocketType.Stream,
ProtocolType.IP);
sock.Bind(ipEnd);
*/
/*
IPHostEntry ipEntry = Dns.GetHostEntry(Environment.MachineName);
IPAddress IpAddr = ipEntry.AddressList[0];
ipEnd = new IPEndPoint(IpAddr, 5656);
sock = new Socket(AddressFamily.InterNetwork, SocketType.Stream,
ProtocolType.IP);
sock.Bind(ipEnd);*/
}
public static string receivedPath;
public static string Rout= "";
public static string curMsg = "Stopped";
public void StartServer()
{
try
{
//curMsg = "Starting...";
sock.Listen(100);
// curMsg = "Running and waiting to receive file.";
Socket clientSock = sock.Accept();
Rout = "Start";
System.Threading.Thread.Sleep(4000);
}
catch (Exception ex)
{
curMsg = "File Receving error.";
}
}
}
}
Admin Login:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Configuration;
namespace SourceMain
{
public partial class Form1 : Form
{
string constring =
Convert.ToString(ConfigurationSettings.AppSettings["ConnectionString"]);
int totreqcount;
string rproceedstatus = "Proceed", empty = "";
public Form1()
{
InitializeComponent();
}
toolTip1.AutoPopDelay = 5000;
toolTip1.InitialDelay = 500;
toolTip1.ReshowDelay = 500;
toolTip1.ShowAlways = true;
// toolTip1.SetToolTip(this.pictureBox7, "Click To Reload");
toolTip1.SetToolTip(this.pictureBox1, "Click To Admin Login");
toolTip1.SetToolTip(this.label3, "Click To Admin Login");
toolTip1.SetToolTip(this.pictureBox2, "Click To Upload Files");
toolTip1.SetToolTip(this.label4, "Click To Upload Files");
toolTip1.SetToolTip(this.pictureBox8, "Click To Verify Requested Files");
toolTip1.SetToolTip(this.label9, "Click To Verify Requested Files");
toolTip1.SetToolTip(this.pictureBox3, "Click To Start Transaction");
toolTip1.SetToolTip(this.label5, "Click To File Start Transaction");
groupBox1.Visible = false;
pictureBox2.Enabled = false;
label4.Enabled = false;
//pictureBox3.Enabled = false;
// label11.Enabled = true;
pictureBox8.Enabled = false;
label9.Enabled = false;
pictureBox3.Enabled = false;
label5.Enabled = false;
}
}
textBox1.Text = "";
textBox2.Text = "";
}
con.Open();
con.Close();
}
con.Open();
con.Close();
}
File Upload:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Configuration;
using System.IO;
namespace SourceMain
{
public partial class FileUpload : Form
{
string constring =
Convert.ToString(ConfigurationSettings.AppSettings["ConnectionString"]);
Class1 cs = new Class1();
string fileDes, fileini, empty = "", rstatus = "Start";
int len;
string yes, yes1, yes2;
public FileUpload()
{
InitializeComponent();
}
if (fileDes == "openFileDialog1")
{
//lblError.Text = "";
//lblError.Text = "Select a File first";
MessageBox.Show("Select any one File.", "Message Box",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
textBox2.Text = "";
button1.Enabled = false;
yes = null;
}
else
{
yes = "yes";
textBox2.Text = openFileDialog1.FileName;
len = fileDes.Length;
fileini = fileDes.Substring(fileDes.IndexOf("\\") + 1);
button1.Enabled = true;
if (fileDes == "openFileDialog2")
{
//lblError.Text = "";
//lblError.Text = "Select a File first";
MessageBox.Show("Select any one File.", "Message Box",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
textBox3.Text = "";
button1.Enabled = false;
yes1 = null;
}
else
{
yes1 = "yes";
textBox3.Text = openFileDialog2.FileName;
len = fileDes.Length;
fileini = fileDes.Substring(fileDes.IndexOf("\\") + 1);
button1.Enabled = true;
if (fileDes == "openFileDialog1")
{
//lblError.Text = "";
//lblError.Text = "Select a File first";
MessageBox.Show("Select any one File.", "Message Box",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
textBox5.Text = "";
button1.Enabled = false;
yes2 = null;
}
else
{
yes2 = "yes";
textBox5.Text = openFileDialog3.FileName;
len = fileDes.Length;
fileini = fileDes.Substring(fileDes.IndexOf("\\") + 1);
button1.Enabled = true;
con.Open();
textBox2.Text = "";
label2.Text = "....................";
label3.Text = "....................";
label5.Text = "....................";
textBox3.Text = "";
label16.Text = "....................";
label13.Text = "....................";
label10.Text = "....................";
textBox5.Text = "";
label24.Text = "....................";
label21.Text = "....................";
label18.Text = "....................";
button1.Enabled = false;
System.Threading.Thread.Sleep(1000);
//public void uploadfile(string fi, string finam, byte[] fibytes, string exe,
string path1)
//{
// SqlConnection con2 = new SqlConnection(constring);
// con2.Open();
// int n = finam.Length;
// cmd2 = new SqlCommand("insert into FileUpload values('" + fi + "','" +
finam + "',@files,'" + exe + "','" + path1 + "')", con2);
// cmd2.Parameters.AddWithValue("@files", fibytes);
// cmd2.ExecuteNonQuery();
// con2.Close();
//}
}
}
public RequestFiles()
{
InitializeComponent();
}
con.Open();
}
}
MessageBox.Show("FILES ARE ALREADY PROCEED.", "Message Box",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
else
{
SqlDataAdapter adp1 = new SqlDataAdapter("Select * from FileUpload
where rstatus='" + rstatus + "'", con);
DataSet ds1 = new DataSet();
adp1.Fill(ds1);
if (ds1.Tables[0].Rows.Count == 0)
{
label4.Text = "---------------";
label5.Text = "---------------";
label8.Text = "---------------";
label9.Text = "---------------";
label14.Text = "---------------";
label15.Text = "---------------";
button2.Enabled = false;
button3.Enabled = false;
button4.Enabled = false;
}
else
{
SqlDataAdapter adp = new SqlDataAdapter("Select * from
FileUpload", con);
DataSet ds = new DataSet();
adp.Fill(ds);
for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
{
reqstatus = ds.Tables[0].Rows[i]["rstatus"].ToString();
if (reqstatus == "Receive")
{
count++;
if (count == 1)
{
label4.Text =
ds.Tables[0].Rows[i]["ufilename"].ToString();
label5.Text =
ds.Tables[0].Rows[i]["rusername"].ToString();
button2.Enabled = true;
}
else
{
if (count == 2)
{
label9.Text =
ds.Tables[0].Rows[i]["ufilename"].ToString();
label8.Text =
ds.Tables[0].Rows[i]["rusername"].ToString();
button3.Enabled = true;
}
else
{
if (count == 3)
{
label15.Text =
ds.Tables[0].Rows[i]["ufilename"].ToString();
label14.Text =
ds.Tables[0].Rows[i]["rusername"].ToString();
button4.Enabled = true;
}
}
}
}
else
{
}
}
}
}
con.Close();
}
}
}
File Download:
#define LaunchAsynch
#define KillFileAfterLaunch
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Data.SqlClient;
using System.Configuration;
using System.IO;
using System.Net;
using System.Diagnostics;
namespace Clients
{
public partial class FileDownload : Form
{
string constring =
Convert.ToString(ConfigurationSettings.AppSettings["ConnectionString"]);
string fullpath;
private Process Launcher = null;
private string LaunchedFile = "";
int len;
string fileDes, fileini;
//string receivedPath;
//byte[] data1;
//byte[] data2;
//byte[] data3;
//byte[] data4;
//byte[] data5;
//byte[] data6;
//byte[] data7;
//byte[] data8;
//byte[] data9;
//byte[] data10;
//byte[] write;
//int fsize1, fsize2, fsize3, fsize4, fsize5, fsize6, fsize7, fsize8, fsize9,
fsize10;
con.Open();
if (label7.Text == textBox2.Text)
{
SqlDataAdapter adp = new SqlDataAdapter("SELECT * FROM Register WHERE
loginid='" + textBox2.Text + "' and upassword='" + textBox1.Text + "'", con);
DataSet ds = new DataSet();
adp.Fill(ds);
if (ds.Tables[0].Rows.Count == 0)
{
MessageBox.Show("ERROR - CLIENT NOT AUTHORIZED.", "Message Box",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
else
{
SqlDataAdapter adp1 = new SqlDataAdapter("SELECT * FROM FileUpload
WHERE ufilename='" + label2.Text + "' and rusername='" + label7.Text + "' and
ufilesize='" + label8.Text + "'", con);
DataSet ds1 = new DataSet();
adp1.Fill(ds1);
label10.Text = ds1.Tables[0].Rows[0]["ufileext"].ToString();
groupBox5.Visible = false;
groupBox1.Visible = true;
}
con.Close();
}
else
{
MessageBox.Show("ERROR - CLIENT NOT AUTHORIZED.", "Message Box",
MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
con.Open();
SqlDataAdapter adp1 = new SqlDataAdapter("SELECT * FROM FileUpload WHERE
ufilename='" + label2.Text + "' and rusername='" + label7.Text + "' and ufilesize='" +
label8.Text + "'", con);
DataSet ds1 = new DataSet();
adp1.Fill(ds1);
//string recpath =
Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
string recpath = Path.GetTempPath();
//string recpath = label14.Text;
#if !KillFileAfterLaunch
File.SetCreationTime(LaunchedFile,
(DateTime)row["FileDateTime"]);
File.SetLastWriteTime(LaunchedFile,
(DateTime)row["FileDateTime"]);
File.SetLastAccessTime(LaunchedFile,
(DateTime)row["FileDateTime"]);
#endif
//If you want your program to wait, then use this approach
#if LaunchAsynch
Launcher.Exited += new EventHandler(Launcher_Exited); // Let us
know when the user closed the surrogate application
Launcher.EnableRaisingEvents = true; // Only works
if we allow it to raise events
Launcher.Start(); // Fire this
puppy up (aka launch the file)
#else
Launcher.Start();
Launcher.WaitForExit(); //
optionally Just wait here until it is done
Launcher.Dispose(); // Clean
up
Launcher = null;
If you want to delete the file after
#if KillFileAfterLaunch
if(File.Exists(LaunchedFile))
File.Delete(LaunchedFile);
#endif
#endif
}
}
}
namespace SourceMain
{
public partial class viewuploadfiles : Form
{
string constring =
Convert.ToString(ConfigurationSettings.AppSettings["ConnectionString"]);
public viewuploadfiles()
{
InitializeComponent();
}
}
}
}
SCREEN SHOTS
Register:
LOGIN:
UPLOAD FILES:
TRANSACTION FORM:
FILE REQUEST:
TRANSACTION FORM:
VERIFY FILES:
CLIENT TRANSACTION:
CONCLUSION