Web Time Tracking

System
Abstract

The web tracking is used to track the details about the real
time visitors. The details will contain the information like Name of
the visitor and the E-mail Id of the visitors. The visitors are
categorized into three types. They are:
User
Guest
Admin.

The Tracking system will maintain the history about the

visitors. The history may contain the information about which
category the visitor belongs to like whether they are a user or a
Guest or Admin. And it will track the information about the login
time and logout time.
 Introduction

User Module:
The user module contains the information about the
regular users of our website. Some condition will be given to
become a user. The conditions will be like giving more
information about the user than the guest module. It will track the
history of the user. The history will have the information about the
user login time and logout time. It will maintain for how long the
user present in our website. The user module will give permission
to access some special features like downloading to the user.

Guest Module:

The Guest Module consists of the information about the

activities which are happening under the guest category. The guest
user can access only some features of our website. The guest can
view the information in our website but they cannot do further
activities like downloading until they become a user of our
website. The tracking system will maintain the details about the
particular guest login time and logout time and what are the
features used by the guest and the feedback.
 Admin Module:
The Admin module is used to change some features of
our website according to the feedback. The admin module users
will have all the controls over the website. The tracking system
will track what are the activities done under this module. It will
maintain the details which happened in that module like what are
the changes has done and what is the feedback for that process.

Time Scale:
This module contains the information about the number
of visitors visiting our website in different categories. It will
maintain the reports like daily, weekly and monthly visitors and
the usage time of the visitors according to the category.
SYTEM CONFIGURATION

2.1 HARDWARE CONFIGURATION

Processor

Base Memory

Cache Memory

RAM

Hard Disk Capacity

Floppy Disk Drive

CD-ROM

Key Board

Display Device
2.2 SOFTWARE CONFIGURATION

Operating System : Windows XP

Presentation Layer : C#
 SOFTWARE CONFIGURATION

.NET FRAMEWORK

The .NET Framework is many things, but it is worthwhile

listing its most

important aspects. In short, the .NET Framework is:

A Platform designed from the start for writing Internet-aware

and

Internet-enabled applications that embrace and adopt open

standards such

as XML, HTTP, and SOAP. A Platform that provides a

number of very

rich and powerful application development technologies,

such as Windows
 Forms, used to build classic GUI applications, and of course
ASP.NET, used

to build web applications.

A Platform with an extensive class library that provides

extensive

support for date access (relational and XML), a director

services, message

queuing, and much more. A platform that has a base class

library that

contains hundreds of classes for performing common tasks

such as file

manipulation, registry access, security, threading, and

searching of text using

regular expressions.

A platform that doesn’t forget its origins, and has great

 interoperability support for existing components that you or
third parties

have written, using COM or standard DLLs. A Platform with

an independent

code execution and management environment called the

Common Language

Runtime(CLR), which ensures code is safe to run, and

provides an abstract

layer on top of the operating system, meaning that elements

of the .NET

framework can run on many operating systems and devices.

C#.Net

That's a lot to assimilate, but all that was just the runtime
engine,
 the foundation. Unfortunately, there are thousands of classes2
in the

C# "framework classes," so I can't even begin to introduce

you to what is in

the framework - the best I can do is give you an idea of why

you should take

the trouble to learn it.

The framework classes constitute the runtime library that

all .Net languages

and applications share. For portability between Delphi for

Windows and

Delphi for .Net you can just stick to the Delphi RTL
wrappings for various

framework features. However, to really take advantage of

.Net, you should
 make an effort to learn the framework classes. Beyond what
learning the

framework classes can do for today's projects, learning the

framework

classes is what will make you a .Net programmer who can

find work in

any .Net shop on the planet. ["Learn once, work anywhere."]

You've probably all seen the dog and pony shows where .Net
turns all the

complexity of XML, SOAP, and WSDL into straightforward

remote calls

that pass objects between systems. This is great stuff - but

there's a lot more

to the framework classes than web services. .Net includes

cryptography
 classes, Perl-compatible regex classes, and a great suite of
collection classes

that goes just light years beyond TList.

One thing to note is that even though C# is easy for Delphi

programmers to

read, you don't have to learn C# to learn the framework

classes. Microsoft

does not currently provide source to the library code, so that

you can't

Ctrl+Click on TObject.ToString and see the implementation,

any more than

you can Ctrl+Click on CreateCompatibleDC() in Delphi for

Windows.

This is the future

 Historically, the Windows API has been a set of 'flat'
function calls. If you

were feeling particularly charitable, you could say it was

"object like", in

that you created an object (like a window or a font) and then

kept passing

the "handle" to various routines that manipulated it. Of

course, few people

have ever been particularly willing to be quite so charitable.

Learning the

Windows API was always a slow and frustrating exercise,

and almost all

Windows code manipulates the flat API from behind various

layers of

incompatible object-oriented wrappers. Knowing MFC didn't

help much
 with Delphi and vice versa.

More, if you weren't working in C or C++, you were always

working at a

disadvantage. When a new API came out, you'd either have

to take the time

to translate the headers and maybe write some wrapper

classes yourself, or

you'd have to wait for someone else to do it. Either way,

there was always

the danger that a translation might be wrong in some way -

the pad bytes are

off, an optional parameter might be required, a routine might

be declared

with the wrong calling convention, and so on.

 All these problems disappear with .Net and the framework
classes. The

framework is object-oriented from top to bottom. No more

"handles" to

pass to an endless set of flat functions - you work with a

window or a font

by setting properties and calling methods. Just like Delphi, of

course - but

now this is the native API, not a wrapper. The wrapper

classes are organized

into hierarchical namespaces, which reduce the endless

searching through

alphabetical lists of function names. Looking for file

functions? System.IO

is a pretty logical place to look. Want a hash table like in

Perl? System.
 Collections has a pretty nice one.

Finally, Microsoft promises that all future API's will be

released as CLS-

compliant parts of the framework class library. This means

that your Delphi

for .Net programs can use a new API the day it's released,
without having to

do any header translation, and without any danger that the

header translation

might be wrong.

You might be skeptical about that promise. Perhaps you

remember that

COM was once touted as Windows' object-oriented future.

This is a sensible
 attitude - but .Net is a lot better than COM ever was. Most
people's first

COM experiments produced a sort of stunned disbelief at just

how complex

Microsoft had managed to make something as simple as

object orientation.

Most people's first .Net experiments leave them pleasantly

surprised that

something this good could have come from the same

company that gave us

COM and the Windows API.

Visual C# .NET Overview

Strong C++ heritage immediately familiar to C++ and Java

developers

Allows C-style memory management and pointers

 First component-oriented language in C family Properties,
methods,

indexers, delegates, events

Design-time and runtime attributes Enables one-stop

programming

No header files, IDL

Embeddable in ASP .NET

Component-Oriented

What defines a component?

Properties, methods, events

Design-time and runtime information

Integrated help and documentation

First class support in C#

Not naming patterns, adapters, etc.

Not external files

Easy to build and consume

Comparison to Visual Basic

Syntactic Differences

Visual Basic is NOT case sensitive

In C# but not in Visual Basic

Pointers, shift operators, inline documentation

Overloaded operators, unsigned integers

In Visual Basic but not in C#

Select Case, Interface implementation

 Dynamic arrays, modules, optional parameters

Need for C#

Existing languages are powerful. Why do we need another

language?

Important features are spread out over multiple languages

Example: must choose between pointers (C++) or garbage

collection (Java)?

Old languages + new features = poor syntax

Garbage collection in C++?

Event-driven GUIs in Java?

Goals of C#

Give developers a single language with

 A full suite of powerful features

A consistent and simple syntax

Increase developer productivity!

Type safety

Garbage collection

Exceptions

Leverage existing skills

Goals of C# cont.

l Support component-oriented programming

Ø First class support for component concepts such as

properties,

events, attributes
l Provide unified and extensible type system

Ø Where everything can be treated as an object

l Build foundation for future innovation

Ø Concise language specification

Ø Standardization

Design of C#

• Derived from the features and syntaxes of other languages

o The safety of Java

o The ease of Visual Basic

o The power of C++

• Uses the .NET Framework

 • Plus several unique features

3. SYSTEM ANALYSIS

3.1 SYSTEM STUDY

Planning future endeavors though difficult is important in

managing

operations .System development is no exception. Identifying

the need for

a new information system and launching an investigation and

a feasibility

study must be based on an MIS master plan that has a

management support.

Understanding MIS planning functions and their relationship

to systems

analysis and design then is crucial to successful computer

installations.
 The first step in the system development life cycle is
identification

of a need. This may be a user’s request to improve or to

enhance an existing

system. The objective is to determine whether the request is

valid and

feasible before a recommendation is reached to do nothing,

improve or

modify the existing system or build a new one.

The next step in system study is information gathering. The

methodology and tools for gathering require training and

experience that the

analyst is expected to have. This means that information

gathering is neither
 easy nor routine. Much preparation, experience and training
are required.

Structured analysis is a set of techniques and graphical tools

that allow the

Analyze to develop system specifications that are

understandable to

the user. The structured analysis considers new goals and

structured tools for

analysis.
TESTING

The goal of testing is to improve the program’s quality.

Quality is

assured primarily through some form of software testing. The

history of

testing goes back to the beginning of the computing field.

Testing is done at
 two Levels of Testing of individual modules and testing the
entire system.

During the system testing, the system is used experimentally

to ensure that

the software will run according to the specifications and in

the way the

user expects. Testing is very tedious and time consuming.

Each test case is

designed with the intent of finding errors in the way the

system will process

it.
 LEVELS OF TESTING

The software underwent the following tests by the system

analyst.

WHITE BOX TESTING

By using this technique it was tested that all the individual

logical

paths were executed at least once. All the logical decisions

were tested on

both their true and false sides. All the loops were tested with
data in between

the ranges and especially at the boundary values.

BLACK BOX TESTING

 By the use of this technique, the missing functions were
identified

and placed in their positions. The errors in the interfaces were

identified

and corrected. This technique was also used to identify the

initialization and

termination errors and correct them.

UNIT TESTING

It is the verification of a single module usually in the isolated

environment. The System Analyst tests each and every

module individually

by giving a set of known input data and verifying for the

required output

data. The System Analyst tested the software Top Down

model starting from
 the top of the model. The units in a system are the modules
and routines that

are assembled to perform a specific function. The modules

should be tested

for correctness of login applied and should detect errors in

coding. This is

the verification of the system to its initial objective. This is a

verification

process when it is done in a simulated environment and it is a

validation

process when it is done in a line environment.

INTEGRATION TESTING

The purpose of unit testing is to determine that each

independent
 module is correctly implemented. This gives little chance to
determine that

the interface between modules is also correct and for this

reason integration

testing must be performed. One specific target of integration

testing is the

interface. Whether parameters match on both sides as to type,

permissible

ranges, meaning and utilization. Module testing assures us

that the detailed

design was correctly implemented; now it is necessary to

verity that

the architectural design specifications were met. Chosen

portions of the

structure tree of the software are put together. Each sub tree
should have
 some logical reason for being tested. It may be a particularly
difficult or

tricky part of the code; or it may be essential to the function

of the rest of the

product. As the testing progresses, we find ourselves putting

together larger

and longer parts of the tree, until the entire product has been
integrated.

VALIDATION TESTING

The main aim of this testing is to verify that the software

system does

what it was designed for the system was tested to ensure that
the purpose of

automating the system “Machine Order”. Alpha testing was

carried out to
 ensure the validity of the system.

OUTPUT TESTING

Asking the users about the format required by them tests the
outputs

generated by the system under consideration .The output

format on the

screen is found to be correct as the format was designed in

the system

design. Output testing was done and it did not result in any
change or

correction in the system.

USER ACCEPTANCE TESTING

The system under consideration is tested for user acceptance

by
 constantly keeping in touch with prospective system users at
time of

developing and making changes whenever required. The

following points

are considered.

Input screen design

Output screen design

Online message to guide the user

PERFORMANCE TESTING

Performance is taken as the last part of implementation.

Performance

is perceived as response time for user queries, report

generation and process
related activities.

BIBLIOGRAPHY

Mastering VB.net with c#.net: BPB publications.

Websites:

www.googlesearch.com

www.gotdotnet.com

www.devasp.net

www.learnvisualstudio.net