Escolar Documentos
Profissional Documentos
Cultura Documentos
TABLE OF CONTENTS
CHAPTER NO.
TITLE
PAGE
NO.
ABSTRACT
I
VII
LIST OF FIGURES
IX
LIST OF SYMBOLS
XIV
LIST OF ABBREVIATIONS
LIST OF TABLES
CHAPTER 1 : INTRODUCTION
1.1 GENERAL
1.2 OBJECTIVE
1.3 EXISTING SYSTEM
1.3.1 EXISTING SYSTEM
DISADVANTAGES
1.3.2 LITERATURE SURVEY
1.4 PROPOSED SYSTEM
1.4.1
2.
PROPOSED
SYSTEM
ADVANTAGES
CHAPTER 2 : PROJECT DESCRIPTION
2.1 GENERAL
2.2 PROBLEM DEFINATION
2.3 METHODOLOGIES
2.3.1 MODULES NAME
2.3.2 MODULES DESCRIPTION
2.3.3 MODULE DIAGRAM
2.3.4 GIVEN INPUT AND EXPECTED
OUTPUT
2.4 TECHNIQUE OR ALGORITHM
3.
CHAPTER 3 : REQUIREMENTS
3.1 GENERAL
3.2 HARDWARE REQUIREMENTS
3.3 SOFTWARE REQUIREMENTS
3.4 FUNCTIONAL SPECIFICATION
3.5 NON-FUNCTIONAL SPECIFICATION
4.
CHAPTER 6 :
6.
IMPLEMENTATION
6.1 GENERAL
6.2 IMPLEMENTATION
6.3 DATA BASE TABLE
STRUCTURE
7.
CHAPTER 7 : SNAPSHOTS
7.1 GENERAL
7.2 VARIOUS SNAPSHOTS
8.
9.
CHAPTER 9
APPLICATIONS AND FUTURE
ENHANCEMENT
9.1 GENERAL
9.2 APPLICATIONS
9.3 FUTURE ENHANCEMENTS
CHAPTER 10 :
10
10.1CONCLUSION
10.2 REFERENCES
LIST OF FIGURES
FIGURE NO
2.3.3
4.1.1
4.1.2
4.1.3
4.1.4
Sequence diagram
4.1.5
Collaboration diagram
4.1.6
Class diagram
PAGE NO.
4.1.7
System Architecture
4.1.8
Object diagram
4.1.9
State diagram
4.1.10
Component diagram
4.1.11
E-R diagram
7.2.1
Register
7.2.2
Login
7.2.3
Enquiry Form
7.2.4
7.2.5
7.2.6
Admin Login
7.2.7
Admin Page
7.2.8
7.2.9
7.2.10
Schedule Diagnose
7.2.11
7.2.12
7.2.13
Faculty Login
7.2.14
Privacy Page
LIST OF SYSMBOLS
NOTATIO
S.N
O
NOTATION
DESCRIPTION
NAME
Class
Name
1.
Class
+ public
-private
-attribute
-attribute
Represents a
collection of
similar entities
grouped
together.
2.
3.
Class A
NAMEClass B
Class A
Class B
Associatio
n
Associations
represent static
relationships
between classes.
Roles represent
the way the two
classes see each
other.
It aggregates
several classes
into a single
classes.
Actor
Class A
Class A
5.
5.
6.
Aggregati
on
Relation
(uses)
Class B
Class B
uses
Relation
(extends)
extends
Interaction
between the
system and
external
environment
Used for
additional
process
communication.
Extends
relationship is
used when one
use case is
similar to
another use case
but does a bit
more.
7.
Communicat
ion
8.
State
9.
Initial State
Communication
between various
use cases.
State
State of the
process.
F final state of
the object
Represents
various control
flow between the
states.
Represents
decision making
process from a
constraint
Use case
Use case
13.
14.
15.
Node
Component
Interaction
between the
system and
external
environment.
Represents
physical
modules which
are a collection
of components.
Represents
physical modules
which are a
collection of
components.
16.
Data
A circle in DFD
represents a
state or process
which has been
triggered due to
some event or
action.
Process/St
ate
17.
External
Represents
external entities
such as
keyboard,
sensors, etc.
entity
18. Transition
Represents
communication
that occurs
between
processes.
19. Object
Lifeline
Represents the
vertical
dimensions that
the object
communications.
20.
Message
Message
Represents the
message
exchanged.
LIST OF ABBREVATION
S.NO
ABBREVATION
EXPANSION
1.
BDS
2.
EMR
3.
MIS
LIST OF TABLES
S.NO.
6.3.1
Register Table
6.3.2
Enquiry Table
6.3.3
EMR Report
6.3.4
MIS Report
PAGE NO.
CHAPTER 1
INTRODUCTION
1.1.
GENERAL
Over the last two and a half years we have designed,
hundred terabytes of data. In many ways, Big table resembles a database: it shares
many implementation strategies with databases. Parallel databases and mainmemory databases have achieved scalability and high performance, but Big table
provides a different interface than such systems. Big table does not support a full
relational data model; instead, it provides clients with a simple data model that
supports dynamic control over data layout and format, and allows clients to reason
about the locality properties of the data represented in the underlying storage. Data
is indexed using row and column names that can be arbitrary strings. Big table also
treats data as uninterrupted strings, although clients often serialize various forms of
structured and semi-structured data into these strings. Clients can control the
locality of their data through careful choices in their schemas. Finally, Big table
schema parameters let clients dynamically control whether to serve data out of
memory or from disk.
1.2.
OBJECTIVE
The Scope of the project is State-of-the-art in scalable data management for
traditional and cloud computing infrastructures for both update heavy as well as
analytical workloads. Summary of current research projects and future research
directions. Design choices that have led to the success of the scalable systems, and
the errors that limited the success of some other systems. Design principles that
should be carried over in designing the next generation of data management
systems for the cloud. Understanding the design space for DBMS targeted to
supporting update intensive workloads for supporting large single tenant systems
and large multitenant systems.
1.3.
EXISTING SYSTEM
In the existing system to achieving high level of scalable and availability
leads to highly distributed systems. Distribution occurs in all tiers from web server
farms and caches to back-end storage. The abstraction of a single system image
with transaction writes and consistent reads using SQL like query languages, is
difficult to achieve at scale. Applications must be aware of data of the replicas,
handle inconsistencies from conflicting replicas updates. And continue operation
in spite of failures of processors, networks and software.
1.3.1.
Description:
Cloud Computing, the long-held dream of computing as a utility, has the
potential to transform a large part of the IT industry, making software even more
attractive as a service and shaping the way IT hardware is designed and purchased.
Developers with innovative ideas for new Internet services no longer require the
large capital outlays in hardware to deploy their service or the human expense to
operate it. They need not be concerned about over-provisioning for a service whose
popularity does not meet their predictions, thus wasting costly resources, or underprovisioning for one that becomes wildly popular, thus missing potential customers
and revenue. Moreover, companies with large batch-oriented tasks can get results
as quickly as their programs can scale, since using 1000 servers for one hour costs
no more than using one server for 1000 hours. This elasticity of resources, without
paying a premium for large scale, is unprecedented in the history of IT. As a result,
Cloud Computing is a popular topic for blogging
and white papers and been featured in the title of workshops, conferences, and
even magazines.
3. Consistency tradoffs in modern Distributed database System design
Authors: Daniel J. Abadi
Year: 2011
Description:
To understand modern DDBS design, it is important to realize the context in which
these systems were built. Amazon originally designed Dynamo to serve data to the
core services in its e-commerce platform (for example, the shopping cart). Face
book constructed Cassandra to power
its Inbox Search feature. LinkedIn created Voldemort to handle online updates
from various write-intensive features on its website. Yahoo built PNUTS to store
user data that can be read or written to on every webpage view, to store listings
data for Yahoos shopping pages, and to store
data to serve its social networking applications. Use cases similar to Amazons
motivated Riak.
In each case, the system typically serves data for webpage constructed on the fly
and shipped to an active website user, and receives online updates. Studies indicate
that latency is a critical factor in online interactions an increase as small as 100 ms
can dramatically reduce the probability that a customer will continue to interact or
return in the future.
4. F1: A Distributed SQL Database That Scales
Authors: Jeff Shute, Radek, Vingralek, Bart Samwel, Ben Handy
Year: 2013.
Description:
F1 is a distributed relational database system built at Google to support the
AdWords business. F1 is a hybrid database that combines high availability, the
scalability of NoSQL systems like Bigtable, and the consistency and us- ability of
traditional SQL databases. F1 is built on Spanner, which provides synchronous
cross-datacenter replication and strong consistency. Synchronous replication
implies higher commit latency, but we mitigate that latency by using a hierarchical
schema model with structured data types and through smart application design. F1
also includes a fully functional distributed SQL query engine and automatic change
tracking and publishing. F1 is a fault-tolerant globally-distributed OLTP and OLAP
database built at Google as the new storage system for Google's AdWords system.
It was designed to replace a sharded MySQL implementation that was not able to
meet our growing scalability and reliability requirements.
5 Big Data and Cloud Computing: Current State and Future Opportunities
Authors: Divyakant Agrawal Sudipto Das Amr El Abbadi
Year: 2010
Description:
Scalable database management systems (DBMS)both for update intensive
application workloads as well as decision support systems for descriptive and deep
analyticsare a critical part of the cloud infrastructure and play an important role
in ensuring the smooth transition of applications from the traditional enterprise
infrastructures to next generation cloud infrastructures. Though scalable data
management has been a vision for more than three decades and much research has
focussed on large scale data management in traditional enterprise setting, cloud
computing brings its own set of novel challenges that must be addressed to ensure
the success of data management solutions in the cloud environment. This tutorial
presents an organized picture of the challenges faced by application developers and
DBMS designers in developing and deploying internet scale applications. Our
background study encompasses both classes of systems: (i) for supporting update
heavy applications, and (ii) for ad-hoc analytics and decision support. We then
focus on providing an in-depth analysis of systems for supporting update intensive
web-applications and provide a survey of the state-of-the art in this domain. We
crystallize the design choices made by some successful systems large scale
database management systems, analyze the application demands and access
patterns, and enumerate the desiderata for a cloud-bound DBMS.
Year: 2010
Description:
Over the past decade, the increasing demands on data-driven business intelligence
have led to the proliferation of large-scale, dataintensive applications that often
have huge amounts of data (often at terabyte or petabyte scale) to process. An
object-oriented programming language such as Java is often the developers choice
for implementing such applications, primarily due to its quick development cycle
and rich community resource.While the use of such languages makes programming
easier, significant performance problems can often be seen the combination of
the inefficiencies inherent in a managed run-time system and the impact of the
huge amount of data to be processed in the limited memory space often leads to
memory bloat and performance degradation at a surprisingly early stage. This
paper proposes a bloat-aware design paradigm towards the development of
efficient and scalable Big Data applications in object-oriented GC enabled
languages. To motivate this work, we first perform a study on the impact of several
typical memory bloat patterns. These patterns are summarized from the user
complaints
on the mailing lists of two widely-used open-source Big Data applications. Next,
we discuss our design paradigm to eliminate bloat. Using examples and real-world
experience, we demonstrate that programming under this paradigm does not incur
significant programming burden. We have implemented a few common data
processing tasks both using this design and using the conventional object-oriented
design. Our experimental results show that this new design paradigm is extremely
effective in improving performance even for the moderate-size data sets
processed, we have observed 2.5+ performance gains, and the improvement
grows substantially with the size of the data set.
1.4.
PROPOSED SYSTEM
In the proposed system we use big data system. That share common
requirements and drive the design of suitable software solutions. And these
requirements represent a significant departure from traditional business systems,
which are relatively well constrained in terms of data growth, analytics and scale.
Our work is proceeding in two complementary directions. First expanding the
collection of architecture and tactics and the second one is encoding in an
environment that supports navigation between quality attributes and tactics.
1.4.1. PROPOSED SYSTEM ADVANTAGES
High availability
CHAPTER 2
PROJECT DESCRIPTION
2.1. GENERAL
We focus our discussion on the new generation of distributed Key-Value
data stores which have been extremely successful and widely adopted. We
highlight the application level changes and the system design level changes that
contributed to the success of these systems.2.2. PROBLEM DEFINITION
Internet facing applications typically generate large
amounts of data from regular usage. Systems capable of handling this large volume
of updates are important to sustain this class of applications. In this System, we
focus on a survey of scalable data management systems targeting this problem, and
present a high-level overview of these systems with the intent of laying the ground
for a detailed analysis to be covered in the latter half of the tutorial.
2.3. METHODOLOGIES
2.3.1. MODULES
Modules:
ADMIN
Authentication.
View Patient Records.
Preference Setting.
Generate EMR.
Generate MIS Report.
USER
Authentication.
Diagnose Schedule
EMR Details
View MIS Report
2.3.2 MODULE DESCRIPTION
USER
AUTHENTICATION
REGISTRATION
If you are the new user going to login into the application then you have to
register first by providing necessary details. After successful completion of sign up
process, the user has to login into the application by providing username and exact
password.
LOGIN
The user has to provide exact username and password which was provided at
the time of registration, if login success means it will take up to main page else it
will remain in the login page itself.
DIAGNOSE SCHEDULE
The user after the successful login goes to view the schedule for take initial
treatment that provides by the admin. It contains records and scheduling
information.
VIEW EMR DETAIL
In this phase the authenticated users view the whole report for that treatment.
The user will see all the information from the initial enquiry up to the final test.
VIEW MIS DETAILS
In this module the user will view the billing information and other
maintenance and financial information such as payment mode or insurance type
and so on.
ADMIN
AUTHENTICATION
Admin has to provide exact username and password which was provided at
the time of registration, if login success means it will take up to main page else it
will remain in the login page itself.
VIEW PATIENT RECORDS
In this scheme Admin can view all the patient information. The record shows
the patient treatment request information and other information stored in the BDS
in the document format.
PREFERENCE SETTING
The admin will be view the patient information and set the priority as based
on the treatment. This is based on the type of treatment which they mention in the
document.
GENERATE EMR
The admin will collect the patient details and stored in the BDS. This EMR
contains all the records from enquiry to till in patient discharge information has
been collected and stored in the BDS.
GENERATE MIS REPORTS
The Admin maintain MIS records for the patient who takes treatment in the
hospital. This sends finally to the patient when they leave from the hospital. It
contains Billing information.
2.3.3. MODULE DIAGRAM:
ADMIN
Authentication
LOGIN
CHECK
STATUS
DB
Login
Admin
Preference setting
Admin
Login
BDS
Generate EMR
Admin
Login
BDS
Login
USER
AUTHENTICATION
Registration
Login
BDS
BDS
LOGIN
CHECK
STATUS
BDS
Diagnose schedule
Patient1
User
Login
BDS
Patient2
Patient3
User
View
MIS details
BDS
BDS
ADMIN
Authentication
Input: Provide username and password to get permission for access.
Output: Became authenticated person to request and process the request.
View Patient Records
Input: The patient information is stored in BDS and it access for Admin
Output: It will show the patient illness and other information.
Preference Setting
Input: Admin provides and set priority for the user based on the disease.
Output: It will set the preference and diagnose schedule to the user
Generate EMR
Input: Admin maintain the patient records in the BDS
Output: It will generate EMR which includes all the reports of a particular
employee
Generate MIS Report
Input: Admin maintain the patient records in the BDS
Output: It will generate MIS Report which includes billing and medicine
USER
Authentication
Input: Provide username and password to get permission for access.
Output: Became authenticated person to request and process the request.
Diagnose Schedule
CHAPTER 3
REQUIREMENTS
3.1. GENERAL
Using this requirement, our application provides high service with
efficiently. Software requirements deal with defining software resource
requirements and pre-requisites that need to be installed on a server that provide
optimal functioning of an application. These requirements or pre-requisites are
generally not included in the software installation package and need to be installed
separately before the software is installed. The most common set of requirements
defined by any operating system or software application is the physical computer
resources, also known as hardware, hardware requirements list is often
accompanied by a hardware compatibility list (HCL), especially in case of
operating systems. An HCL lists tested, compatible, and sometimes incompatible
hardware devices for a particular operating system or application. The following
sub-sections discuss the various aspects of hardware requirements.
3.2. HARDWARE REQUIREMENTS
The hardware requirements may serve as the basis for a contract for
the implementation of the system and should therefore be a complete and
consistent specification of the whole system. They are used by software engineers
as the starting point for the system design. It should what the system do and not
how it should be implemented.
PROCESSOR
RAM
2 GB DD RAM
MONITOR
15 COLOR
HARD DISK
CDDRIVE
:
:
KEYBOARD
MOUSE
LG 52X
:
40 GB
3 BUTTONS
: Windows 07/ 08
: Visual Studio 2010
: C#.NET, Windows Form
Database
CHAPTER 4
SYSTEM DESIGN
4.1 GENERAL
Design Engineering deals with the various UML [Unified
Modeling language] diagrams for the implementation of project. Design is a
meaningful engineering representation of a thing that is to be built. Software
No
Register
Login
User
Admin
View Diagnose
Schedule
Set preference
View EMR
Record
Generate EMR
record
Generate MIS
detail
Logout
the functionality provided by the system in terms of actors, their goals and any
dependencies between those use cases.
Login
USER
View Patient information
Generate EMR
View EMR
Generate MIS
ADMIN
Level 0 DFD
Level 1 DFD
Level 2 DFD
User
Admin
Big Data
System
Login User
Register Details
Admin login
Setting Priority
Generate EMR
Admin Logout
User Logout
1: Login User
2: Register Details
3: View Diagnose Schedule
9: View EMR detail
10: View MIS report
11: User Logout
Big Data
System
4: Admin login
5: Setting Priority
6: Generate EMR
7: Generate MIS report
8: Admin Logout
Admin
Administrator
name
address
mob no
mailid
EMR()
MIS()
Schedule()
view()
registration()
Global Network
Register Details
User Id=xxxx Name=yyyy
View information
User Id=xxxx Name=yyyy
Treatment= t1,t2..
specific time.
Generate EMR
User Id= xxx
Treatment=t1,t2
diagrams,Report=L1,L2..
and are often used
Login
to provide
examples, or act as test cases for the class diagrams. Only those aspects
Username= Admin/
of a model that
PassWord=*****
User
Registration
User Login
Admin Login
View Patient
details
View Schedule
details
Generate EMR
Report
View EMR
Record
Generate MIS
details
View MIS
detail
Logout
View Diagnose
Schedule
View EMR
Record
Logout
Login
Set Preference
Setting
Generate
EMR
Generate MIS
Details
Username
Password
Login
Admin
User
ew Patient information
View
Preference Setting
View MIS details
Generate EMR
View EMR Record
Generate MIS Report
View Diagnose Schedule
Register Patient details
CHAPTER 5
SOFTWARE SPECIFICATION
5.1 GENERAL
This chapter is about the software language and the tools used in the
development of the project. The platform used here is .NET. The Primary
languages are C#, VB, and J#. In this project C# is chosen for implementation.
5.2. DOTNET
5.2 .1 INTRODUCTION TO DOTNET
Microsoft .NET is a set of Microsoft software technologies for rapidly
building and integrating XML Web services, Microsoft Windows-based
applications, and Web solutions. The .NET Framework is a language-neutral
platform for writing programs that can easily and securely interoperate. Theres no
language barrier with .NET: there are numerous languages available to the
developer including Managed C++, C#, Visual Basic and Java Script. The .NET
framework provides the foundation for components to interact seamlessly, whether
locally or remotely on different platforms. It standardizes common data types and
communications protocols so that components created in different languages can
easily interoperate.
.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).
5.2.2 THE .NET FRAMEWORK
The .NET Framework has two main parts:
1. The Common Language Runtime (CLR).
JScript.NET, whereas others, namely C++, do not. Targeting CLR can, depending
on the language youre using, impose certain constraints on the features available.
As with managed and unmanaged code, one can have both managed and
unmanaged data in .NET applications - data that doesnt get garbage collected but
instead is looked after by unmanaged code.
5.2.5 COMMON TYPE SYSTEM (CTS)
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.
5.2.6 COMMON LANGUAGE SPECIFICATION
The CLR provides built-in support for language interoperability. To ensure
that you can develop managed code that can be fully used by developers using any
programming language, a set of language features and rules for using them called
the Common Language Specification (CLS) has been defined. Components that
follow these rules and expose only CLS features are considered CLS-compliant.
5.2.7 THE CLASS LIBRARY
.NET provides a single-rooted hierarchy of classes, containing over
7000 types. The root of the namespace is called System; this contains basic types
like Byte, Double, Boolean, and String, as well as Object. All objects derive from
System. Object. As well as objects, there are value types. Value types can be
allocated on the stack, which can provide useful flexibility. There are also efficient
means of converting value types to object types if and when necessary.
The set of classes is pretty comprehensive, providing collections, file,
screen, and network I/O, threading, and so on, as well as XML and database
connectivity. The class library is subdivided into a number of sets (or namespaces),
each providing distinct areas of functionality, with dependencies between the
namespaces kept to a minimum.
LANGUAGES SUPPORTED BY .NET
The multi-language capability of the .NET Framework and Visual
Studio .NET enables developers to use their existing programming skills to build
all types of applications and XML Web services. The .NET framework supports
new versions of Microsofts old favorites Visual Basic and C++ (as VB.NET and
Managed C++), but there are also a number of new additions to the family.
Visual Basic .NET has been updated to include many new and
improved language features that make it a powerful object-oriented programming
language. These features include inheritance, interfaces, and overloading, among
others. Visual Basic also now supports structured exception handling, custom
attributes and also supports multi-threading.
Visual Basic .NET is also CLS compliant, which means that any CLScompliant language can use the classes, objects, and components you create in
Visual Basic .NET.
Managed Extensions for C++ and attributed programming are just
some of the enhancements made to the C++ language. Managed Extensions
simplify the task of migrating existing C++ applications to the new .NET
Framework.
C# is Microsofts new language. Its a C-style language that is
essentially C++ for Rapid Application Development. Unlike other languages, its
specification is just the grammar of the language. It has no standard library of its
own, and instead has been designed with the intention of using the .NET libraries
as its own.
Microsoft Visual J# .NET provides the easiest transition for Javalanguage developers into the world of XML Web Services and dramatically
improves the interoperability of Java-language programs with existing software
written in a variety of other programming languages.
Active State has created Visual Perl and Visual Python, which
enable .NET-aware applications to be built in either Perl or Python. Both products
can be integrated into the Visual Studio .NET environment. Visual Perl includes
support for Active States Perl Dev Kit.
ASP.NET
Windows Forms
XML
WEB
SERVICES
Base Class Libraries
Common Language Runtime
Operating System
Fig 5.2.1 .Net Framework
FEATURES OF C#
1. C# is a simple, modern, object oriented language derived from C++ and Java.
2. It aims to combine the high productivity of Visual Basic and the raw power of
C++.
3. It is a part of Microsoft Visual Studio7.0.
4. Visual studio supports Vb, VC++, C++, Vbscript, Jscript. All of these languages
provide access to the Microsoft .NET platform.
5. .NET includes a Common Execution engine and a rich class library.
6. Microsoft's JVM equiv. is Common language run time (CLR).
7. CLR accommodates more than one languages such as C#, VB.NET, Jscript,
ASP.NET, C++.
8. Source code --->Intermediate Language code (IL) ---> (JIT Compiler) Native
code.
9.The classes and data types are common to all of the .NET languages.
10. We may develop Console application, Windows application, and Web
application using C#.
11. In C# Microsoft has taken care of C++ problems such as Memory management,
pointers etc.
12.It supports garbage collection, automatic memory management and a lot.
MAIN FEATURES OF C#
1. Pointers are missing in C#.
2. Unsafe operations such as direct memory manipulation are not allowed.
TYPE SAFE
1. In C# we cannot perform unsafe casts like convert double to a Boolean.
2. Value types (primitive types) are initialized to zeros and reference types (objects
and classes are initialized to null by the compiler automatically.
3. Arrays are zero base indexed and are bound checked.
4. Overflow of types can be checked.
INTEROPERABILITY
1. C# includes native support for the COM and windows based applications.
2. Allowing restricted use of native pointers.
3. Users no longer have to explicitly implement the unknown and other COM
interfaces, those features are built in.
4. C# allows the users to use pointers as unsafe code blocks to manipulate your old
code.
5. Components from VB NET and other managed code languages and directly be
used in C#.
5.4 OBJECTIVES OF .NET
The .net framework is one of the tools provided by the .net platform. It provides an
Environment for building, deploying and running web services and other
applications like Console applications; Windows based applications, Web sites. It
is a Common architecture for all .net programming languages.
The Main Objectives of .NET Framework
1) Platform dependent
2) Language Independent
3) Language Interoperability
4) Security
5) Database Connectivity
6) Globalization of Application
1) Platform Independent: As dll or exe files are executable in any operating system
with the help of the CLR (common language runtime), hence .net is called as
platform independent.
2) Language Independent: As .net application logic can be developed in any .net
framework compatible languages, hence it is called as Language Independent.
Specification in ASP.net
It provides set of rules to be followed while integrating with the language.
Language Interoperability: The code written in one language should be used from
the application developed using other language.
Security: The .net applications attain high level of security.
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 promote 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 ASP.NET 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. 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 isolated file storage.
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, thirdparty 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.
Windows GUI applications (Windows Forms).
ASP.NET applications.
XML Web services.
Windows services.
For example, the Windows Forms classes are a comprehensive set of reusable
types that vastly simplify Windows GUI development. If you write an ASP.NET
Web Form application, you can use the Web Forms classes.
FEATURES OF THE COMMON LANGUAGE RUNTIME
Common Language Runtime is a heart of the .net framework. It actually
manages the code during Execution. The Code that runs under the CLR is called
Managed Code. The code that is executed under .net runtime gets benefits like
cross language inheritance,
handling,
enhanced
Platform Independence: - The Compiler compiles code language, which is CPUindependent. This means that the code can be executed from any platform that
supports the .Net CLR.
Security Management: - In .net platform, Security is achieved through the code
access Security (CAS) model. In the model, CLR enforces the restriction an
managed code through the object called permissions. The CLR allows the code
to perform only that task for which it has permissions. In other words, the CAS
model specifies what the code can access instead of specifies who can access
resources.
Type Safety: - This feature ensures that object is always accessed in compatible
ways. Therefore the CLR will prohibit a code from assign a 10-byte value to an
object that occupies 8 bytes.
BENEFITS OF CLR
Performance improvement
The ability to easily use components developed in other languages.
Extensible types provided by library.
New Language features such as inheritance, interfaces etc.
Complete Object-Oriented design.
Very Strong Type Safety.
A good blend of Visual Basic simplicity and c++ power.
Syntax and keywords similar to c and c++.
Use of delegates rather than function pointers for increased type safety and
security.
various pages. ASP.Net session state and server side infrastructure keeps track of
the information collected globally over a session.
The ASP.Net runtime carries the page state to and from the server across page
requests while generating the ASP.Net runtime codes and incorporates the state of
the server side components in hidden fields.
This way the server becomes aware of the overall application state and operates in
a two-tiered connected way.
ASP.Net Component Model:
The ASP.Net component model provides various building blocks of ASP.Net pages.
Basically it is an object model, which describes:
Server side counterparts of almost all HTML elements or tags, like <form>
and <input>.
Server controls, which help in developing complex user-interface for
example the Calendar control or the Gridview control.
ASP.Net is a technology, which works on the .Net framework that contains all
web-related functionalities. The .Net framework is made of an object-oriented
hierarchy. An ASP.Net web application is made of pages. When a user requests an
ASP.Net page, the IIS delegates the processing of the page to the ASP.Net runtime
system.
The ASP.Net runtime transforms the .aspx page into an instance of a class, which
inherits from the base class Page of the .Net framework. Therefore, each ASP.Net
page is an object and all its components i.e., the server-side controls are also
objects.
the
bottom
of
the
and
manipulation.
DatasetsIn
ADO.NET,
almost
all
data
in
parallel,
the
Web
application
model.
Forms
and
Web
Services.
ASP.NET comes with built-in Web Forms controls, which are responsible
for generating the user interface. They mirror typical HTML widgets like
text boxes or buttons. If these controls do not fit your needs, you are free to
create
your
own
user
controls.
Web Services brings you a model to bind different applications over the
Internet. This model is based on existing infrastructure and applications and
is
therefore
standard-based,
simple,
and
adaptable.
Web Services are software solutions delivered via Internet to any device.
Today, that means Web browsers on computers, for the most part, but the
device-agnostic design of .NET will eliminate this limitation.
of the application. In other words, you can write your own code to override the
default code.
The Page class creates a hierarchical tree of all the controls on the page. All the
components on the page, except the directives are part of this control tree. You can
see the control tree by adding trace= "true" to the Page directive. We will cover
page directives and tracing under 'directives' and 'error handling'.
The page life cycle phases are:
Initialization
Instantiation of the controls on the page
Restoration and maintenance of the state
Execution of the event handler codes
Page rendering
Understanding the page cycle helps in writing codes for making some specific
thing happen at any stage of the page life cycle. It also helps in writing custom
controls and initializing them at right time, populate their properties with viewstate data and run control behavior code.
Following are the different stages of an ASP.Net page:
Page request . when ASP.Net gets a page request, it decides whether to
parse and compile the page or there would be a cached version of the page;
accordingly the response is sent
Starting of page life cycle . at this stage, the Request and Response objects
are set. If the request is an old request or post back, the IsPostBack property
of the page is set to true. The UICulture property of the page is also set.
Page initialization . at this stage, the controls on the page are assigned
unique ID by setting the UniqueID property and themes are applied. For a
new request postback data is loaded and the control properties are restored to
the view-state values.
Page load . at this stage, control properties are set using the view state and
control state values.
Validation . Validate method of the validation control is called and if it runs
successfully, the IsValid property of the page is set to true.
Postback event handling . if the request is a postback (old request), the
related event handler is called.
Page rendering . at this stage, view state for the page and all controls are
saved. The page calls the Render method for each control and the output of
rendering is written to the OutputStream class of the Page's Response
property.
Unload . the rendered page is sent to the client and page properties, such as
Response and Request are unloaded and all cleanup done.
ASP.Net Page Life Cycle Events:
At each stage of the page life cycle, the page raises some events, which
could be coded. An event handler is basically a function or subroutine,
bound to the event, using declarative attributes like Onclick or handle.
Following are the page life cycle events:
PreInit . PreInit is the first event in page life cycle. It checks the IsPostBack
property and determines whether the page is a postback. It sets the themes
and master pages, creates dynamic controls and gets and sets profile
property values. This event can be handled by overloading the OnPreInit
method or creating a Page_PreInit handler.
Init . Init event initializes the control property and the control tree is built.
This event can be handled by overloading the OnInit method or creating a
Page_Init handler.
InitComplete . InitComplete event allows tracking of view state. All the
controls turn on view-state tracking.
LoadViewState
. LoadViewState
event
allows
loading
view
state
Load . the Load event is raised for the page first and then recursively for all
child controls. The controls in the control tree are created. This event can be
handled by overloading the OnLoad method or creating a Page_Load
handler.
LoadComplete . the loading process is completed, control event handlers
are run and page validation takes place. This event can be handled by
overloading the OnLoadComplete method or creating a Page_LoadComplete
handler.
PreRender . the PreRender event occurs just before the output is rendered.
By handling this event, pages and controls can perform any updates before
the output is rendered.
PreRenderComplete . as the PreRender event is recursively fired for all
child controls, this event ensures the completion of the pre-rendering phase.
SaveStateComplete . state of control on the page is saved. Personalization,
control state and view state information is saved. The HTML markup is
generated. This stage can be handled by overriding the Render method or
creating a Page_Render handler.
UnLoad . the UnLoad phase is the last phase of the page life cycle. It raises
the UnLoad event for all controls recursively and lastly for the page itself.
Final cleanup is done and all resources and references, such as database
connections, are freed. This event can be handled by modifying the
OnUnLoad method or creating a Page_UnLoad handler.
An ASP.Net page is made of number of server controls along with the HTML
controls, text and images. Sensitive data from the page and the states of different
controls on the page are stored in hidden fields and forms the context of that page
request.
ASP.Net runtime controls all association between a page instance and its state. An
ASP.Net page is an object of the Page Class or inherited from it.
All the controls on the pages are also objects of the related control class inherited
from a parent Control class. When a page is run an instance of the page object is
created along with all its content controls.
An ASP.Net page is also a server side file saved with the .aspx extension. It is
modular in nature and can be divided into the following core sections:
Page directives
Code Section
Page Layout
Page directives:
The page directives set up the environments for the page to run. The @Page
directive defines page-specific attributes used by the ASP.Net page parser and
compiler. Page directives specify how the page should be processed, and which
assumptions are to be taken about the page.
faster insights from analyzing both structured information and unstructured big
data. With the secure, flexible and open platform of IBM Power Systems plus
solutions and software, organizations can outpace their competitors by delivering
faster services, providing differentiated offerings and turning operational cost into
investment opportunity .Improvements to the database engine, the details of which
are not published by Microsoft, and the corresponding changes to the main
infrastructure components are reflected by a substantial number of new features as
well as enhancements to existing ones. The most relevant ones can be grouped into
several categories, such as high availability and scalability, security, data
management, administration and maintenance, and development.
The demand for high availability is becoming increasingly common and is no
longer limited to major corporate and governmental clients. This results not only
from a growing level of customer expectations, but also from the new political
climate associated with more stringent legislative and regulatory requirements, in
which disaster recovery and business continuity are more relevant than ever.
CHAPTER 6
IMPLEMENTATION
6.1 GENERAL
This chapter describes the implementation of our project.
Admin Login:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace Hospital_Infomatics
{
public partial class WebForm3 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
protected void btn_login_Click(object sender, EventArgs e)
{
if (txt_name.Text != string.Empty && txt_pwd.Text != string.Empty)
{
if (txt_name.Text == "Admin" && txt_pwd.Text == "Admin")
{
ScriptManager.RegisterStartupScript(this, this.GetType(),
"validation", "<script language='javascript'>alert('Login Successfully...')</script>",
false);
Response.Redirect("View_Enquiry_Forms.aspx");
}
else
{
ScriptManager.RegisterStartupScript(this, this.GetType(),
"validation", "<script language='javascript'>alert('Invalid User
Name&Password!!')</script>", false);
}
}
else
{
ScriptManager.RegisterStartupScript(this, this.GetType(), "validation",
"<script language='javascript'>alert('Try again...')</script>", false);
}
}
}
}
Enquiry Page
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
namespace Hospital_Infomatics
{
public partial class WebForm3 : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
}
protected void btn_login_Click(object sender, EventArgs e)
{
if (txt_name.Text != string.Empty && txt_pwd.Text != string.Empty)
{
if (txt_name.Text == "Admin" && txt_pwd.Text == "Admin")
{
ScriptManager.RegisterStartupScript(this, this.GetType(),
"validation", "<script language='javascript'>alert('Login Successfully...')</script>",
false);
Response.Redirect("View_Enquiry_Forms.aspx");
}
else
{
ScriptManager.RegisterStartupScript(this, this.GetType(),
"validation", "<script language='javascript'>alert('Invalid User
Name&Password!!')</script>", false);
}
}
else
{
ScriptManager.RegisterStartupScript(this, this.GetType(), "validation",
"<script language='javascript'>alert('Try again...')</script>", false);
}
}
}
}
Faculty Member Login
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using BOL;
using BAL;
namespace Hospital_Infomatics
{
public partial class WebForm6 : System.Web.UI.Page
{
Balclass bal = new Balclass();
Boclass bo = new Boclass();
protected void Page_Load(object sender, EventArgs e)
{
}
protected void btn_login_Click(object sender, EventArgs e)
{
if (txt_name.Text != string.Empty && txt_pwd.Text != string.Empty)
{
if (txt_name.Text == "log" && txt_pwd.Text == "log")
{
bool s = bal.user_log(bo);
Response.Redirect("View_enquiry.aspx");
if (s)
{
ScriptManager.RegisterStartupScript(this, this.GetType(),
"validation", "<script language='javascript'>alert('Login Successfully...')</script>",
false);
}
else
{
ScriptManager.RegisterStartupScript(this, this.GetType(),
"validation", "<script language='javascript'>alert('Invalid Account !!')</script>",
false);
}
}
else
{
ScriptManager.RegisterStartupScript(this, this.GetType(),
"validation", "<script language='javascript'>alert('Please Enter User
Name...')</script>", false);
}
}
else
{
ScriptManager.RegisterStartupScript(this, this.GetType(), "validation",
"<script language='javascript'>alert('Invalid account...')</script>", false);
}
}
}
}
Patient Login
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using BOL;
using BAL;
namespace Hospital_Infomatics
{
public partial class WebForm2 : System.Web.UI.Page
{
Boclass bo_obj = new Boclass();
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using BOL;
using BAL;
using System.Data.OleDb;
using System.Data;
using System.IO;
using System.Configuration;
namespace Hospital_Infomatics
{
public partial class WebForm8 : System.Web.UI.Page
{
Boclass bo = new Boclass();
Balclass bal = new Balclass();
OleDbConnection con = new
OleDbConnection(ConfigurationManager.ConnectionStrings["conn"].ConnectionS
tring);
protected void Page_Load(object sender, EventArgs e)
{
lbl_uname.Text = Session["Patient_Name"].ToString();
}
protected void ImageButton4_Click(object sender, ImageClickEventArgs e)
{
Response.Redirect("Enquiry.aspx");
}
protected void ImageButton1_Click(object sender, ImageClickEventArgs e)
{
View_Reports.ActiveViewIndex = 0;
g_view();
}
//EMR
protected void ImageButton2_Click(object sender, ImageClickEventArgs e)
{
View_Reports.ActiveViewIndex = 1;
emr_grid();
string path = Server.MapPath("~/Big Data
System/Enquiry_Records/EMR/");
string[] dir = Directory.GetFiles(path);
int c = 0;
int len = dir.Count();
foreach (string file in dir)
{
string fname = Path.GetFileNameWithoutExtension(file);
if (lbl_uname.Text == fname)
{
lbl_file.Text = fname + ".pdf";
string filename = fname + ".pdf";
ViewState["file"] = filename;
break;
}
else
{
c++;
}
}
}
//mis
protected void ImageButton3_Click(object sender, ImageClickEventArgs e)
{
View_Reports.ActiveViewIndex = 2;
mis_grid();
string path = Server.MapPath("~/Big Data
System/Enquiry_Records/MIS/");
string[] dir = Directory.GetFiles(path);
int len = dir.Count();
int count = 0;
foreach (string file in dir)
{
string fname = Path.GetFileNameWithoutExtension(file);
if (lbl_uname.Text == fname)
{
lbl_fil.Text = fname + ".pdf";
string filename = fname + ".pdf";
ViewState["file_mis"] = filename;
break;
}
else
{
count++;
}
}
}
protected void btn_signout_Click(object sender, EventArgs e)
{
Response.Redirect("Login.aspx");
Session.Clear();
}
public void g_view()
{
try
{
con.Open();
OleDbCommand cmd = new OleDbCommand("SELECT * FROM
Diagnose_sch WHERE Name='" + lbl_uname.Text + "'", con);
OleDbDataAdapter da = new OleDbDataAdapter(cmd);
DataSet ds = new DataSet();
da.Fill(ds);
DIA_SCH.DataSource = ds;
DIA_SCH.DataBind();
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
//EMR Download
protected void btn_file_Click1(object sender, EventArgs e)
{
string f = ViewState["file"].ToString();
string path1 = Server.MapPath("~/Big Data
System/Enquiry_Records/EMR/" + f + "");
if (File.Exists(path1))
{
Response.Clear();
Response.ContentType = "Application/pdf";
Response.AddHeader("Content-Disposition", "attachment;filename= " +
f + "");
Response.WriteFile(path1);
Response.End();
return;
}
}
//MIS
protected void btn_viw_Click(object sender, EventArgs e)
{
string f = ViewState["file_mis"].ToString();
string path1 = Server.MapPath("~/Big Data
System/Enquiry_Records/MIS/" + f + "");
if (File.Exists(path1))
{
Response.Clear();
Response.ContentType = "Application/pdf";
Patient Registration:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Data;
using System.Data.OleDb;
using System.Text;
using BOL;
using BAL;
namespace Hospital_Infomatics
{
public partial class WebForm1 : System.Web.UI.Page
{
Boclass bo = new Boclass();
Balclass bal = new Balclass();
protected void Page_Load(object sender, EventArgs e)
{
}
}
}
View Enquiry Details
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;
using BAL;
using BOL;
using System.Data;
using System.IO;
namespace Hospital_Infomatics
{
public partial class WebForm5 : System.Web.UI.Page
{
Boclass bo = new Boclass();
Balclass bal = new Balclass();
protected void Page_Load(object sender, EventArgs e)
{
string path = Server.MapPath("~/Big Data System/Enquiry_Records/");
string[] dir = Directory.GetFiles(path);
foreach (string sdf in dir)
{
string str = Path.GetFileNameWithoutExtension(sdf);
ListBox1.Items.Add(str);
}
DataSet ds = new DataSet();
ds = bal.Gridbind();
GridView1.DataSource = ds;
GridView1.DataBind();
}
protected void btn_log_Click(object sender, EventArgs e)
{
Response.Write("FacultyMem_Login.aspx");
}
protected void btn_view_rec_Click(object sender, EventArgs e)
{
//ListBox1.Items.Clear();
ScriptManager.RegisterStartupScript(this, this.GetType(), "validation",
"<script language='javascript'>alert('Privacy Issues!! You are not able to view
this..')</script>", false);
}
}
}
View Forms
namespace Hospital_Infomatics
{
public partial class WebForm7 : System.Web.UI.Page
{
DataSet dt = new DataSet();
Boclass bo = new Boclass();
Balclass bal = new Balclass();
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
}
}
public void bind()
{
DataSet ds = new DataSet();
ds = bal.Gridbind();
grid_enq.DataSource = ds;
grid_enq.DataBind();
ListBox1.Items.Clear();
string path = Server.MapPath("~/Big Data System/Enquiry_Records/");
string[] dir = Directory.GetFiles(path);
bo.Patient_id = Convert.ToInt32(txt_pid.Text);
bo.Disease = txt_treat.Text;
bo.T_days = Convert.ToInt32(txt_days.Text);
bo.Admit_date = Convert.ToDateTime(txt_adm.Text);
bo.Discharge = Convert.ToDateTime(txt_d.Text);
bo.Specialist = txt_doc.Text;
bo.Diagnosed = Convert.ToDateTime(txt_sch.Text);
bo.Payment = rdbtn_pay.SelectedValue.ToString();
bool k = bal.mis(bo);
if (k)
{
mis_records();
ScriptManager.RegisterStartupScript(this, this.GetType(), "validation",
"<script language='javascript'>alert('MIS Report Generated!!')</script>", false);
}
else
{
ScriptManager.RegisterStartupScript(this, this.GetType(), "validation",
"<script language='javascript'>alert('Failed!!')</script>", false);
}
}
public void emr_records()
{
using (StringWriter sw = new StringWriter())
{
using (HtmlTextWriter hw = new HtmlTextWriter(sw))
{
try
{
string filename = txt_nam.Text;
string path = Server.MapPath("~/Big Data
System/Enquiry_Records/EMR/" + filename + ".pdf");
string imagepath = Server.MapPath("~/img/icon.png");
string image = Server.MapPath("~/img/logo.png");
StringReader sr = new StringReader(sw.ToString());
Document pdfDoc = new Document(PageSize.A4, 7f, 7f, 7f, 0f);
PdfWriter.GetInstance(pdfDoc, new FileStream(path,
FileMode.Create));
pdfDoc.Open();
}
}
}
}
public void mis_records()
{
using (StringWriter sw = new StringWriter())
{
using (HtmlTextWriter hw = new HtmlTextWriter(sw))
{
try
{
string filename = txt_pat.Text;
string path =Server.MapPath("~/Big Data
System/Enquiry_Records/MIS/" + filename + ".pdf");
string imagepath = Server.MapPath("~/img/icon.png");
string image = Server.MapPath("~/img/logo.png");
StringReader sr = new StringReader(sw.ToString());
Document pdfDoc = new Document(PageSize.A4, 7f, 7f, 7f, 0f);
PdfWriter.GetInstance(pdfDoc, new FileStream(path,
FileMode.Create));
pdfDoc.Open();
iTextSharp.text.Rectangle page = pdfDoc.PageSize;
PdfPTable head = new PdfPTable(1);
head.TotalWidth = page.Width;
iTextSharp.text.Image gif =
iTextSharp.text.Image.GetInstance(imagepath);
gif.Alignment = iTextSharp.text.Image.MIDDLE_ALIGN;
gif.ScalePercent(50f);
iTextSharp.text.Image gif1 =
iTextSharp.text.Image.GetInstance(image);
gif1.Alignment = iTextSharp.text.Image.ALIGN_CENTER;
gif1.ScalePercent(50f);
Paragraph t1 = new Paragraph("Patient Name: " + txt_pat.Text +
"");
Paragraph t2 = new Paragraph("Patient_ID: " + txt_pid.Text + "");
Paragraph t3 = new Paragraph("Disease: " + txt_treat.Text + "");
Paragraph t4 = new Paragraph("Total Date: " + txt_days.Text + "");
}
}
protected void btn_out_Click(object sender, EventArgs e)
{
Response.Redirect("Admin.aspx");
}
protected void btn_view_rec_Click(object sender, EventArgs e)
{
string file = ListBox1.SelectedItem.Text;
string f = file + ".pdf";
string path1 = Server.MapPath("~/Big Data System/Enquiry_Records/" + f
+ "");
WebClient cl = new WebClient();
Byte[] b = cl.DownloadData(path1);
if (b != null)
{
Response.Clear();
Response.ContentType = "Application/pdf";
Response.AddHeader("content-length", b.Length.ToString());
Response.BinaryWrite(b);
}
}
}
}
DALL
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Data.OleDb;
using BOL;
using System.Configuration;
namespace DAL
{
public class Dalclass
{
DataSet dt = new DataSet();
OleDbCommand cmd;
OleDbConnection con = new
OleDbConnection(ConfigurationManager.ConnectionStrings["conn"].ConnectionS
tring);
public bool registration(Boclass bo)
{
try
{
con.Open();
cmd = new OleDbCommand("INSERT INTO register values
(@Name,@Password,@Mail,@Age,@Gender,@City,@State)", con);
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue("@Name", bo.Name);
cmd.Parameters.AddWithValue("@Password", bo.Password);
cmd.Parameters.AddWithValue("@Mail", bo.Mail);
cmd.Parameters.AddWithValue("@Age", bo.Age);
cmd.Parameters.AddWithValue("@Gender", bo.Gender);
cmd.Parameters.AddWithValue("@City", bo.City);
cmd.Parameters.AddWithValue("@State", bo.State);
if (con.State == ConnectionState.Open)
{
int i = cmd.ExecuteNonQuery();
if (i > 0)
{
return true;
}
else
{
return false;
}
}
return false;
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
public bool login(Boclass bo)
{
try
{
con.Open();
OleDbDataReader dr;
cmd = new OleDbCommand("SELECT Name,Password from register
where Name='" + bo.Name + "' and Password='" + bo.Password + "'", con);
dr = cmd.ExecuteReader();
if (dr.Read())
{
return true;
}
else
{
return false;
}
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
public bool Enquiry(Boclass bo)
{
try
{
con.Open();
cmd = new OleDbCommand("INSERT INTO
User_details(Name,Age,Blood_Group,Gender,Mail,Surgery,Treatment_taken,Addr
ess,City,State) values
(@Name,@Age,@Blood_Group,@Gender,@Mail,@Surgery,@Treatment_taken,
@Address,@City,@State)", con);
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue("@Name", bo.Name);
cmd.Parameters.AddWithValue("@Age", bo.Age);
cmd.Parameters.AddWithValue("@Blood_Group", bo.Blood);
cmd.Parameters.AddWithValue("@Gender", bo.Gender);
cmd.Parameters.AddWithValue("@Mail", bo.Mail);
cmd.Parameters.AddWithValue("@Mobile", bo.Mob);
cmd.Parameters.AddWithValue("@Surgery", bo.Surgery);
cmd.Parameters.AddWithValue("@Treatment_taken", bo.Treatment);
cmd.Parameters.AddWithValue("@Address", bo.Address);
cmd.Parameters.AddWithValue("@City", bo.City);
cmd.Parameters.AddWithValue("@State", bo.State);
if (con.State == ConnectionState.Open)
{
int i = cmd.ExecuteNonQuery();
if (i > 0)
{
return true;
}
else
{
return false;
}
}
return false;
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
public DataSet bind()
{
try
{
con.Open();
cmd = new OleDbCommand("SELECT * FROM User_details", con);
DataSet dt = new DataSet();
OleDbDataAdapter da = new OleDbDataAdapter(cmd);
da.Fill(dt);
return dt;
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
public bool schedule(Boclass bo)
{
try
{
con.Open();
cmd = new OleDbCommand("INSERT INTO
Diagnose_sch(Name,Consulting_date,Specialist) values
(@Name,@Consulting_date,@Specialist)", con);
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue("@Name", bo.Patient);
cmd.Parameters.AddWithValue("@Consulting_date", bo.Consu);
cmd.Parameters.AddWithValue("@Specialist", bo.Specialist);
if (con.State == ConnectionState.Open)
{
int i = cmd.ExecuteNonQuery();
if (i > 0)
{
return true;
}
else
{
return false;
}
}
return false;
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
public bool EMR_record(Boclass bo)
{
try
{
con.Open();
cmd = new OleDbCommand("INSERT INTO EMR values
(@Patient,@ID,@Disease,@Admit_Date,@Discharge_Date,@Specialist,@Status,
@Diagnosed)", con);
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue("@Patient", bo.Patient);
cmd.Parameters.AddWithValue("@ID", bo.Patient_id);
cmd.Parameters.AddWithValue("@Disease", bo.Disease);
cmd.Parameters.AddWithValue("@Admit_Date", bo.Admit_date);
cmd.Parameters.AddWithValue("@Discharge_Date", bo.Discharge);
cmd.Parameters.AddWithValue("@Specialist", bo.Specialist);
cmd.Parameters.AddWithValue("@Status", bo.Status);
cmd.Parameters.AddWithValue("@Diagnosed", bo.Diagnosed);
if (con.State == ConnectionState.Open)
{
int j = cmd.ExecuteNonQuery();
if (j > 0)
{
return true;
}
else
{
return false;
}
}
return false;
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
public bool MIS_record(Boclass bo)
{
try
{
con.Open();
cmd = new OleDbCommand("INSERT INTO Mis values
(@Patient,@ID,@Disease,@Total_Days,@Admit_Date,@Discharge_Date,@Speci
alist,@Diagnosed,@Payment)", con);
cmd.CommandType = CommandType.Text;
cmd.Parameters.AddWithValue("@Patient", bo.Patient);
cmd.Parameters.AddWithValue("@ID", bo.Patient_id);
cmd.Parameters.AddWithValue("@Disease", bo.Disease);
cmd.Parameters.AddWithValue("@Total_Days", bo.T_days);
cmd.Parameters.AddWithValue("@Admit_Date", bo.Admit_date);
cmd.Parameters.AddWithValue("@Discharge_Date", bo.Discharge);
cmd.Parameters.AddWithValue("@Specialist", bo.Specialist);
cmd.Parameters.AddWithValue("@Diagnosed", bo.Diagnosed);
cmd.Parameters.AddWithValue("@Payment", bo.Payment);
if (con.State == ConnectionState.Open)
{
int j = cmd.ExecuteNonQuery();
if (j > 0)
{
return true;
}
else
{
return false;
}
}
return false;
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
public DataSet view_diagnose()
{
try
{
con.Open();
cmd = new OleDbCommand("SELECT * FROM Diagnose_sch", con);
OleDbDataAdapter da = new OleDbDataAdapter(cmd);
da.Fill(dt);
return dt;
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
public DataSet view_emr_report()
{
try
{
con.Open();
cmd = new OleDbCommand("SELECT * FROM EMR", con);
OleDbDataAdapter da = new OleDbDataAdapter(cmd);
da.Fill(dt);
return dt;
}
catch (Exception)
{
throw;
}
finally
{
con.Close();
}
}
}
}
BO
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BOL
{
public class Boclass
{
private string name;
public string Name
{
get { return name; }
set { name = value; }
}
{
get { return user; }
set { user = value; }
}
private string blood;
public string Blood
{
get { return blood; }
set { blood = value; }
}
}
}
BALL
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using BOL;
using DAL;
namespace BAL
{
public class Balclass
{
Boclass bo = new Boclass();
Dalclass dal = new Dalclass();
public bool reg(Boclass bo)
{
return dal.registration(bo);
}
public bool user_log(Boclass bo)
{
return dal.login(bo);
}
CHAPTER 7
SNAPSHOTS
7.1 GENERAL
Snapshot is nothing but every moment of the application while running. It
gives the clear elaborated of application. It will be useful for the new user to
understand for the future steps.
7.2.2 Login:
The above screenshot shows the report of the Management information System.
This shows the details of patient billing information.
The above figure shows the two datacenter. The data center1 holds the
records for the new user where as the data center2 contains the records for the
members.
In this page user/patient will search the content which will be based on their
disease.
CHAPTER 8
SOFTWARE TESTING
8.1 GENERAL
The purpose of testing is to discover errors. Testing is the process of trying
to discover every conceivable fault or weakness in a work product. It provides a
way to check the functionality of components, sub assemblies, assemblies and/or a
finished product It is the process of exercising software with the intent of ensuring
that the Software system meets its requirements and user expectations and does not
fail in an unacceptable manner. There are various types of test. Each test type
addresses a specific testing requirement.
8.2 DEVELOPING METHODOLOGIES
The test process is initiated by developing a comprehensive plan to test the
general functionality and special features on a variety of platform combinations.
Strict quality control procedures are used.
The process verifies that the application meets the requirements specified in
the system requirements document and is bug free. The following are the
considerations used to develop the framework from developing the testing
methodologies.
Invalid Input
Functions
Output
exercised.
Systems/Procedures: interfacing systems or procedures must be invoked.
CHAPTER 9
9.1. GENERAL
This section gives the details of our application usage in Big Data System.
9.2. APPLICATION:
It can be applied to the following areas,
Online Banking System
Financial Management system
Health Care System
9.3. FUTURE ENHANCEMENT
Description
In the future, we plan to conduct an empirical evaluation to assess how the
replicate can store in the Big data system.
User
Provid
e
periodi
c
BDS
ADVANTAGES
High availability
Write heavy workloads
Variable request loads
CHAPTER 10
10.1 CONCLUSION
We have described Big table, a distributed system for storing structured data
at Google. Our users like the performance and high availability provided by the
Big table implementation, and that they can scale the capacity of their clusters by
simply adding more machines to the system as their resource demands change over
time.
10.2. REFERENCES
1.P. Ciuccarelli, M.I. Sessa, and M. Tucci, Code: A Graphic Language for
Complex System Visualization, Proc. Italian Assoc. for Information Systems
(ItAIS), 2010.
2. J. Bertin, Semiology of Graphics: Diagrams, Networks, Maps/Jacques Bertin;
Translated by William J. Berg., Univ. of Wisconsin Press, 1983.
3. S.K. Card, J.D. Mackinlay, and B. Shneiderman, Readings in Information
Visualization: Using Vision to Think. Morgan Kaufmann Publishers Inc., 1999.
4. E.R. Tufte, The Visual Display of Quantitative Information, second ed. Graphics
Press, May 2001.
5. A. Unger, P. Muigg, H. Doleisch, and H. Schumann, Visualizing Statistical
Properties of Smoothly Brushed Data Subsets, Proc. Fourth Intl Conf.
Information Visualisation, pp. 233-239, 2008.