E-Defect Tracker
1. INTRODUCTION
Bug
Tracking System is an ideal solution to track the bugs of a product, solution
or an application. Bug Tracking System allows individual or groups of developers
to keep track of outstanding bugs in their product effectively. This can also
be called as Defect Tracking System.
1.1Project Overview
The Bug Tracking System can
dramatically increase the productivity and accountability of individual
employees by providing a documented workflow and positive feedback for good
performance.
Some salient features are
- Product and Component
based
- Creating & Changing
Bugs at ease
- Query Bug List to any
depth
- Reporting &
Charting in more comprehensive way
- User Accounts to
control the access and maintain security
- Simple Status &
Resolutions
- Multi-level Priorities
& Severities.
- Targets &
Milestones for guiding the programmers
- Attachments &
Additional Comments for more information
10.
Robust database back-end
Project will be done in ASP. NET with C#
2.0 as front end and SQL Server 2005 as back end.
1.2 OBJECTIVE AND SCOPE OF
THE PROJECT
For many years, bug-tracking
mechanism is employed only in some of the large software development houses. Most
of the others never bothered with bug tracking at all, and instead simply
relied on shared lists and email to monitor the status of defects. This
procedure is error-prone and tends to cause those bugs judged least significant
by developers to be dropped or ignored.
Bug
Tracking System is an ideal solution to track the bugs of a product, solution
or an application. Bug Tracking System allows individual or groups of
developers to keep track of outstanding bugs in their product effectively. This
can also be called as Defect Tracking System.
Project will be
done in ASP. NET with C# 2.0 as front end and SQL Server 2005 as back end.
Microsoft .NET is software that connects information, people, systems and
devices. It spans clients, servers and developer tools and consists of:
Ø
The
.NET Framework programming model that enables developers to build Web-based
applications which expose their functionality programmatically over a network
using standard protocols such as SOAP and HTTP.
Ø
Developer
tools such as Microsoft Visual Studio .NET, which provide a rapid application
integrated development environment for programming with the .NET Framework.
Ø
A
set of servers including Microsoft Windows 2000, Microsoft SQL, Server and
Microsoft BizTalk Server that integrates, runs, operates and manages XML Web
services and applications.
Client
software such as Windows XP, Windows CE and Microsoft Office XP that helps
developers deliver a deep and compelling user experience across a family of
devices and existing products
2. SYSTEM
ANALYSIS
2.1 PROBLEM STATEMENT
System Analysis
is the detailed study of the various operations performed by the system and
their relationships within and outside the system. Analysis is the process of breaking
something into its parts so that the whole may be understood. System analysis
is concerned with becoming aware of the problem, identifying the relevant and
most decisional variables, analyzing and synthesizing the various factors and
determining an optimal or at least a satisfactory solution. During this a
problem is identified, alternate system solutions are studied and
recommendations are made about committing the resources used to design the
system.
2.2 DESCRIPTION OF PRESENT SYSTEM
In
any software development bugs are inevitable. Let it be in any kind of product
bugs arise at any phase of development. one has to take a great care in the
proper maintenance and resolution of the bugs. In the Existing system the bugs
are not properly maintained and they are simply relied on shared lists and
email to monitor the bugs. In this type of system it becomes difficult to track
a bug if a bug is over looked then it may cause tremendous errors in the next
phase and can improve the cost of project whatever necessary effort spent on
the bug maintenance may not be worthy. So bug history has to be maintained
properly. And there is no efficient search technique. One has to search the
whole database for the details of particular bug which might have occurred sometime
earlier. It is both time consuming and error prone. And it is very difficult to
share the bug among several users as there is no proper maintenance of the
bugs.
In order to have
an efficient product bugs must be maintained properly and should be resolved in
time both to reduce time and money spent on the development.
LIMITATIONS OF PRESENT SYSTEM
·
Transactions
are done manually.
·
Time
consuming to do the tracking out the bugs again.
·
Files are
not given for the access.
·
Chance of
Data loss.
·
Accessing
is slow.
·
Developed
in windows application.
·
All works
is done by a single
2.3 PROPOSED SYSTEM
User can Speed up the access. The proposed system has many
advantages over the existing system. This system maintains the products, Bugs
and bug Tracking. It has advantage of maintaining bug history it stores all the
details from bug origin to bug resolution.
So that it would not
be difficult for the user to know how much effort spent on the bug. Each
product can have versions for easy maintenance of the product and all the user
of the product is stored in the database. It provides the advantage of
maintaining users to the bugs and resolutions provided by them. This product
provides efficient search technique. As the number of bugs for a product
increases tremendously it would be difficult to search for a single record. Our
system provides the searching based on status, priority, and operating system.
It provides with user and bug hierarchy, which would be helpful in knowing the
relation between bugs and users allotted to the bug. It is provided with a
fully authenticated system with password encryption. And has the facility for
storing attachments for a bug. One can keep a track of the bug in a product
with much lower cost and effort. The most advantage of this system is
maintaining log records which are helpful in knowing any errors or misuse of
the system by other users.
ADVANTAGES
·
User can
continue the communication with admin.
·
No data loss
is avoided.
·
Easily
tracking out the bugs in the software product.
·
All the
service can be provided without any problem.
·
Files can
be easily accessed.
·
Works are
divided to their teams.
·
Develop in
web application.
2.4 FEASIBILTY STUDY
This project are feasible if we give
uncontrolled resources and time but a project is said to be feasible if it
produces estimated results at the earliest possible time with enough resources.
A feasibility study is a high level
capsule version of the system analysis and design process. Its objective is to
determine quickly and at a minimum possible expense if the problem can be
solved
The thereof feasibility that are carried
out are
Ø Technical
Feasibility
Ø Operational
Feasibility
Ø Economic Feasibility
2.4.1 Technical Feasibility
Evaluating the technical feasibility is the trickiest part of a
feasibility study. This is because at this point in time, not too many-detailed
design of the system are present, making it difficult to access issues like
performance, costs on (on account of the kind of technology to be deployed)
etc. A number of issues have to be considered while doing a technical analysis.
2.4.2 Operational Feasibility
Proposed projects
are beneficial only if they can be turned into information systems that will
meet the organizations operating requirements. Simply stated, this test of
feasibility asks if the system will work when it is developed and installed.
Are there major barriers to Implementation? Here are questions that will help
test the operational feasibility of a project:
Ø
Is
there sufficient support for the project from management from users? If
Ø
The
current system is well liked and used to the extent that persons will not be
able to see reasons for change, there may be resistance.
Ø
Are
the current business methods acceptable to the user? If they are not,
Ø
Users
may welcome a change that will bring about a more operational and useful
systems.
Ø
Have
the user been involved in the planning and development of the project?
Early
involvement reduces the chances of resistance to the system and in general and
increases the likelihood of successful project. Since the proposed system was
to help reduce the hardships encountered in the existing manual system, the new
system was considered to be operational feasible.
Economical
feasibility
Economic feasibility attempts 2 weigh the
costs of developing and implementing a new system, against the benefits that
would accrue from having the new system in place. This feasibility study gives
the top management the economic justification for the new system.
A simple economic analysis which gives
the actual comparison of costs and benefits are much more meaningful in this
case. In addition, this proves to be a useful point of reference to compare
actual costs as the project progresses. There could be various types of
intangible benefits on account of automation. These could include increased
customer satisfaction, improvement in product quality better decision making
timeliness of information, expediting activities, improved accuracy of operations,
better documentation and record keeping, faster retrieval of information,
better employee morale.
3. SYSTEM SPECIFICATION
3.1 Hardware Specification
Processor : INTEL Pentium III
RAM : 256MB
Hard Disk Drive : 20GB
3.2 Software Specification
Operating
System : Windows XP
Front- End : C#.
NET with ASP. NET
Back- End : MS
SQL SERVER 2005
3.3 Brief Overview of Software Tools
MICROSOFT
VISUAL STUDIO
Microsoft Visual Studio is Microsoft’s flagship software development
product for computer programmers. It centers on an integrated distribution
environment which has programmers create stand alone, and web services that run
on any platforms supported by Microsoft’s .Net Framework (for all versions
after 6). Supported platforms include Microsoft windows, servers and
workstations, Pocket PC, Smart Phones and World Wide Web browsers not the Java
Virtual Machine that all other java tools target.
VISUAL STUDIO 2008
The most important language added in this version was the
introduction of generics, which are similar in many aspects to C++ templates.
This potentially increases the number of bugs caught at compile- time instead
of run- time by encouraging the use of strict type checking in areas where it
was not possible before, C++ also got a similar upgrade with the addition of
C++/CLI which is slated to replace the use of Managed C++. Other new features
of Visual Studio 2005 include the “Development Designer” which allows
application designs to be validated before deployments, an improved environment
for web publishing when combined with ASP.NET 2.0 and load testing to see
application performance under various sorts of user loads. Visual Studio 2005
also added extensive 64- bit support. While the development environment itself
only available as a 32- bit application, visual C++ 2008 supports compiling for
(x64AMD64 and EM64T) as well as IA- 64 (Itanium). The platforms SDK include 64-
bit and 64-bit versions of the libraries.
INTRODUCTION
TO C#.NET:
C# (pronounced C Sharp) is a multi-paradigm programming language that
encompasses functional, imperative, generic, object-oriented (class-based), and
component-oriented programming disciplines. It was developed by Microsoft as
part of the .NET initiative and later approved as a standard by ECMA (ECMA-334)
and ISO (ISO/IEC 23270). C# is one of the programming languages
supported by the .NET Framework's Common Language Runtime. C# is intended to be a simple, modern, general-purpose,
object-oriented programming language. Its development team is led by Anders
Hejlsberg, the designer of Borland's Object Pascal language. It has an
object-oriented syntax based on C++ and is heavily influenced by Java. It was
initially named Cool, which stood for "C-like Object Oriented
Language." However, in July 2000, when Microsoft made the project public,
the name of the programming language was given as C#. The most recent version
of the language is 3.0 which were released in conjunction with the .NET
Framework 3.5 in 2007. The next proposed version, 4.0, is in development.
.NET
FRAMEWORK SDK:
The .NET framework is an integral windows component that supports
building and running the next generation of applications and XML web services.
The key component of the .NET frame work are the common language run time and
the . NET frame work class library, which includes ADO.NET, ASP.NET and windows
forms. The .NET framework provides a managed execution environment simplified
development and deployment and integration with a wide variety of programming
languages.
This framework is made up of the following parts:
·
The common language
runtime(CLR)
·
The base class libraries.
·
Object oriented internet development
with ASP.NET
·
Rich client user interface
using windows forms
·
RAD for the internet using web
forms
OVERVIEW OF THE .NET FRAME WORK:
The .NET
framework is a new computing platform that simplifies application development
in the highly distributed environment of the internet. The .NET framework is
designed to fulfill following objectives:
·
To provide a consistent object
oriented programming environment whether object code is stored and executed
locally but internet- distributed or executed remotely.
·
To provide a code execution
environment that minimizes software deployment and versioning conflicts.
·
To provide a code execution
environment that guarantees safe execution of code, including code created by
an unknown or semi trusted third party.
·
To provide a code execution
environment that eliminates the performance problem of scripted or interpreted
environments.
·
To make the developer
experience consistent across widely types of application, such as windows based
applications and web based applications.
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, and remoting while also enforcing strict
type safely and other forms of code accuracy that ensure security and robustness in fact the
concept of code management is a fundamental principle of the runtime.
Code that
targets the runtime is known as managed code, while code that does not target
the runtime is known as un managed code.
The class library, the other main component of the .NET frameworks is a
comprehensive, object-oriented collection reusable types that you can use to
develop applications ranging from traditional command line or graphical user
interface (FGUI) applications to application base d on the latest innovations
provided by ASP.NET, such as web forms and XML web services.
The .NET framework can be hosted by
unmanaged component that load the common language runtime into their processes
and initiate the execution of managed code.
ASP.NET works directly with the runtime to enable ASP.NET application
and XML web services, both of which are discussed later in this topic, Internet explorer is an example of unmanaged
application that hosts the runtime (in the form of a MIME type extension). Using internet explorer to the host runtime
enables you to embed managed components or windows forms controls in HTML
documents. Hosting the runtime in this
way makes mobile code 9similar to Microsoft Active Xr controls) possible, but
with significant improvement that only managed code can offer, such as
semi-trusted execution and secure isolated file storage.
The
following illustration shows the relationship of the common language runtime
and the class library to your application and to the over all system. The illustration also shows how managed code
operated with in a larger architecture.
We can use the
.NET framework to develop the following types of application and services:
·
Console
applications
·
Window
GUI application (Windows Forms) ASP.NET applications
·
XML
Web services
- Windows services
COMMON
LANGUAGE RUNTIME (CLR)
The common language runtime (CLR) is responsible
for runt-time services such as language integration; security enforcement; and
memory, process and thread management.
In addition, it has a roll at development time when features such as
life cycle management strong type naming, cross-language exception handling,
dynamic binding and so on, reduce the amount of code that a developer must
write to turn the business logic the reusable component. The runtime can be hosted by high
performance, server-side applications, such a s Microsoft Internet Information
Services (IIS) for building web applications with ASP.NE and the next release
of Microsoft SQL Server. This infrastructure
enables you to use code “managed “ by the .NET framework to write your business
logic, while still enjoying the superior performance of the industry’s best
enterprises servers that support runtime hosting.
ASP.NET
ASP.NET is a set
of Microsoft.NET framework technologies used for building web applications and
XML Web services. ASP.NET page execute
on the server and generate mark up such as HTML, WML or XML that is sent to a
desktop or mobile browser. ASP.NET pages
use a compiled, event-driven programming model that improves performance and
enables the separation of application logic and user interface. Both ASP.NET pages and ASP.NET web services
files contain server-side (as opposed to client side logic) written in Visual
basic .NET, C#.NET or any .NET compatible language, Web applications and XML Web Services take
advantage of the features of the common language runtime, such as type safety,
inheritance, language, interoperability, versioning, and integrated
security.
IIS
Microsoft Internet Information S4ervices (IIS; formerly called
Server is a set of Internet-based services for servers using Microsoft
Windows. It is the world’s second most
popular web server in terms of overall websites. As of September 2007 it served 34.94% of all
websites and 36.63% of all active websites according to Net craft. The servers currently include FTP, SMTP,
NNTOP, and HTTP/HTTPS.
ADO.NET
ADO.NET provides
consistent access to data sources such a Microsoft SQL Server and XML, as well
as to data sources exposed through OLE DB and ODBC. Data sharing consumer applications can use
ADO.NET to connect to these data sources and retrieve, manipulate and update
the data that they contain.
ADO.NET
separates data access from data manipulation into discrete components that can
be used separately or in tandem. ADO.NET
includes .NET Frame work data providers for connecting to a database, executing
commands and retrieving results. Those
results are either processed directly, placed in and ADO.NET Dataset objects in
order to be exposed to the used in an ad hoc manner, combined with data from
multiple sources or remote between tiers.
The ADO.NET Dataset object can also be used independently of a .NET
Framework data provider to manage data local to the application or sourced from
XML.
The ADO.NET classes are found in
System.Data.dll and are integrated with the XML classes found in
System.Xml.dll. When compiling code that
uses the
System. Data, namespace reference both System.Data.dll and System.Xml.dll.
ADO.NET provided functionality to developers writing managed code
similar to the functionality provided to native component object model (COM)
developers by ActiveX Data Objects (ADO).
ADO.NET
COMPONENTS
There are two
components of ADO.NET that you can use to access and manipulate data:
·
.NET
Framework data providers.
- The Dataset
.NET
FRAMEWORK DATA PROVIDERS
The
.NET Framework Data providers are components that have been explicitly designed
for data manipulation and fast, forward-only, read-only access to data. The connection object provides connectivity
to a data source. The command object
enables access to database commands to return data, modify data, run stored
procedures and send or retrieve parameter information. The Data Adapter provides a high-performance
stream of data from the data source. Finally, the Data Adapter provides the
bridge between the Dataset object and the data source. The Data Adapter uses command object to
execute SQL commands at the data source to both load the Dataset with data and
reconcile changes made to the data in the Dataset back to the data source.
THE DATASET
The
ADO.NET Dataset is explicitly designed for data access independent of any data
source. As a result, it can be used with
multiple and differing data sources used with XML data or used to manage data
local to the application. The Dataset
contains a collection n of one or more Data Table objects made up to rows and columns
of data as well as primary key, foreign key, constraint and relation
information about the data in the Data Table objects.
BENEFITS OF
ADO.NET
ADO.NET offers several
advantages over previous versions of ADO and over other data access
components. These benefits fall into the
following categories:
1.
Interoperability
2.
Maintainability
3.
Programmability
- Scalability
BACK END
MICROSOFT
SQL SERVER 2005
Microsoft SQL
server is designed to work effectively in a number of environments:
As a two-tier or
multitier client/server database system
As a desktop
database system
Client/Server
Database Systems
Client/server
systems are constructed so that the database can reside on a central computer,
known as a server and be shared among several running SQL server. The client
application runs both business logic and the code to display output to the
user, and is also known as a thick client.
In a multi tier
client/server system, the client application logic is run in two locations: The
thin client is run on the user’s local computer and is focused on displaying results
to the user. The business logic is located in server applications running on a
server.
Thin clients
request functions from the server application, which is itself a multithreaded
application capable of working with many concurrent users. The server
application is the one that opens connections to the database server and can be
running on the same server as the database, or it can connect across the
network to a separate server operating as a database server.
The most
creative and challenging face of the system development is System Design. It
provides the understanding and procedural details necessary for implementing
the system recommended in the feasibility study. Design goes through the
logical and physical stages of development.
In designing a new system, the
system analyst must have a clear understanding of the objectives, which the
design is aiming to fulfill. The first step is to determine how the output is
to be produced and in what format. Second, input data and master files have to
be designed to meet the requirements of the proposed output. The operational
phases are handled through program construction and testing.
Design of a system can be defined as
a process of applying various techniques and principles for the purpose of
defining a device, a process or a system in sufficient detail to permit its
physical realization. Thus system design is a solution to “how to” approach to
the creation of a new system. Thus important phase provides the understanding
and the procedural details necessary for implementing the system recommended in
the feasibility study. The design step provides a data design, architectural
design, and a procedural design.
4.1 Object oriented analysis and design
Object-oriented analysis and design
(OOAD) is a software engineering approach that models a system as a group of
interacting objects. Each object represents some entity of interest in the
system being modeled, and is characterized by its class, its state (data
elements), and its behavior. Various models can be created to show the static
structure, dynamic behavior, and run-time deployment of these collaborating
objects. There are a number of different notations for representing these
models, such as the Unified Modeling Language (UML).
Object-oriented analysis (OOA) applies object-modeling techniques to
analyze the functional requirements for a system. Object-oriented design (OOD)
elaborates the system does, OOD on how the system does it.
Object-oriented system
An object-oriented system is composed of objects. The behavior of
the system results from the collaboration of those objects. Collaboration
between objects involves those sending messages to each other. Sending a
message differs from calling a function in that when a target object receives a
message, it itself decides what function to carry out to service that message.
The same message may be implemented by many different functions, the one
selected depending on the state of the target object.
The implementation of “message sending” varies depending on the
architecture of the system being modeled, and the location of the objects being
communicated with.
Object oriented analysis
Object-oriented analysis (OOA) looks at the problem domain, with the
aim of producing a conceptual model of the information that exists in the area
being analyzed. Analysis models do not consider any implementation constraints
that might exist, such as concurrency, distribution, persistence, or how the
system is to be built. Implementation constraints are dealt during
object-oriented design (OOD).
The sources for the analysis can be a written requirements
statement, a formal vision document, and interviews with stakeholders or other
interested parties. A system may be divided into multiple domains, representing
different business, technological, or other areas of interest, each of which
are analyzed separately.
Object-oriented design
Object-oriented design (OOD) transforms the conceptual model
produced in object-oriented analysis to take account of the constraints imposed
by the chosen architecture and any non-functional – technological or
environmental- constraints, such as transaction throughput, response time,
run-time platform, development environment, or programming language.
The concepts in the analysis model are mapped onto implementation
classes and interfaces. The result is a model of the solution domain, a
detailed description of how the system is to be built.
6. Pseudo code
Login Form
Code
namespace
Bug_Management
{
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.OleDb;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
/// <summary>
///
Summary description for Login.
/// </summary>
public partial class Login :
System.Web.UI.Page
{
//Login
CustomIncludes begin
protected CCUtility Utility;
//Login form Login variables
and controls declarations
protected
System.Web.UI.HtmlControls.HtmlInputHidden Login_querystring;
protected
System.Web.UI.HtmlControls.HtmlInputHidden Login_ret_page;
// For each Login form
hiddens for PK's,List of Values and Actions
protected string
Login_FormAction="Default.aspx?";
public Login()
{
this.Init += new
System.EventHandler(Page_Init);
}
// Login
CustomIncludes end
//-------------------------------
public void ValidateNumeric(object
source, ServerValidateEventArgs args) {
try{
Decimal
temp=Decimal.Parse(args.Value);
args.IsValid=true;
}catch{
args.IsValid=false; }
}
//===============================
// Login Show begin
protected void Page_Load(object sender,
EventArgs e)
{
Utility=new CCUtility(this);
//===============================
// Login Open Event
begin
// Login Open Event
end
//===============================
//===============================
// Login OpenAnyPage
Event begin
// Login OpenAnyPage
Event end
//===============================
//
//===============================
// Login PageSecurity begin
// Login PageSecurity end
//===============================
if (Session["UserID"]
!= null && Int16.Parse(Session["UserID"].ToString()) > 0)
Login_logged = true;
if (!IsPostBack){
Page_Show(sender,
e);
}
}
protected void Page_Unload(object
sender, EventArgs e)
{
//
// CODEGEN: This call is
required by the ASP+ Windows Form Designer.
//
if(Utility!=null)
Utility.DBClose();
}
protected void Page_Init(object
sender, EventArgs e)
{
//
// CODEGEN: This call is
required by the ASP+ Windows Form Designer.
//
InitializeComponent();
Login_login.Click += new
System.EventHandler (this.Login_login_Click);
}
/// <summary>
///
Required method for Designer support - do not modify
///
the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
}
protected void Page_Show(object sender,
EventArgs e)
{
Login_Show();
}
// Login Show end
/*===============================
Display Login Form
-------------------------------*/
protected bool
Login_logged = false;
void Login_Show() {
// Login Show begin
// Login Open Event
begin
// Login Open Event
end
// Login BeforeShow
Event begin
// Login BeforeShow
Event end
if (Login_logged) {
// User logged in
Login_login.Text =
"Logout";
Login_trpassword.Visible =
false;
Login_trname.Visible = false;
Login_labelname.Visible =
true;
Login_labelname.Text = Utility.Dlookup("employees",
"login", "employee_id=" + Session["UserID"]) +
" ";
} else {
// User is not logged in
Login_login.Text =
"Login";
Login_trpassword.Visible =
true;
Login_trname.Visible = true;
Login_labelname.Visible =
false;
}
// Login Close Event
begin
// Login Close Event
end
// Login Show end
}
void
Login_login_Click(Object Src, EventArgs E) {
if (Login_logged) {
// Login Logout begin
// Login OnLogout
Event begin
// Login OnLogout
Event end
Login_logged =
false;
Session["UserID"] =
0;
Session["UserRights"]
= 0;
Login_Show();
// Login Logout end
} else {
// Login Login begin
int iPassed =
Convert.ToInt32(Utility.Dlookup("employees", "count(*)",
"login ='" + Login_name.Text + "' and pass='" +
CCUtility.Quote(Login_password.Text) + "'"));
if (iPassed > 0) {
// Login OnLogin
Event begin
// Login OnLogin
Event end
Login_message.Visible=false; Session["UserID"]=Convert.ToInt32(Utility.Dlookup("employees",
"employee_id", "login ='" + Login_name.Text + "' and
pass='" + CCUtility.Quote(Login_password.Text) +"'"));
Login_logged =
true;
Session["UserRights"=Convert.ToInt32(Utility.Dlookup("employees",
"security_level", "login ='" + Login_name.Text + "'
and pass='" + CCUtility.Quote(Login_password.Text) + "'"));
string sQueryString
= Utility.GetParam("querystring");
string sPage =
Utility.GetParam("ret_page");
if(!sPage.Equals(Request.ServerVariables["SCRIPTsPage.Length
> 0) {
Response.Redirect(sPage
+ "?" + sQueryString);
}
else {
Response.Redirect(Login_FormAction);
}
}
else {
Login_message.Visible
= true;
}
// Login Login end
}
}
// End of Login form
}
}
Administration code
namespace
Bug_Management
{
using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.OleDb;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
/// <summary>
///
Summary description for Administration.
/// </summary>
public partial class Administration :
System.Web.UI.Page
{
//Administration
CustomIncludes begin
protected CCUtility Utility;
//Login form Login variables
and controls declarations
protected
System.Web.UI.HtmlControls.HtmlInputHidden Login_querystring;
protected
System.Web.UI.HtmlControls.HtmlInputHidden Login_ret_page;
// For each Administration
form hiddens for PK's,List of Values and Actions
protected string
Administration_FormAction=".aspx?";
// For each Login form
hiddens for PK's,List of Values and Actions
protected string
Login_FormAction="Administration.aspx?";
public Administration()
{
this.Init += new System.EventHandler(Page_Init);
}
// Administration
CustomIncludes end
//-------------------------------
public void
ValidateNumeric(object source, ServerValidateEventArgs args) {
try{
Decimal
temp=Decimal.Parse(args.Value);
args.IsValid=true;
}catch{
args.IsValid=false; }
}
//===============================
// Administration
Show begin
protected void Page_Load(object sender,
EventArgs e)
{
Utility=new CCUtility(this);
//===============================
// Administration
Open Event begin
// Administration
Open Event end
//===============================
//===============================
// Administration
OpenAnyPage Event begin
// Administration OpenAnyPage
Event end
//===============================
//
//===============================
// Administration
PageSecurity begin
Utility.CheckSecurity(3);
// Administration
PageSecurity end
//===============================
if (Session["UserID"]
!= null && Int16.Parse(Session["UserID"].ToString()) > 0)
Login_logged = true;
if (!IsPostBack){
Page_Show(sender,
e);
}
}
protected void Page_Unload(object
sender, EventArgs e)
{
//
// CODEGEN: This call is
required by the ASP+ Windows Form Designer.
//
if(Utility!=null)
Utility.DBClose();
}
protected void Page_Init(object
sender, EventArgs e)
{
//
// CODEGEN: This call is
required by the ASP+ Windows Form Designer.
//
InitializeComponent();
Login_login.Click += new
System.EventHandler (this.Login_login_Click);
}
/// <summary>
///
Required method for Designer support - do not modify
///
the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
}
protected void Page_Show(object sender,
EventArgs e)
{
Administration_Show();
Login_Show();
}
// Administration
Show end
// End of Login form
protected void Administration_Show(){
// Administration
Open Event begin
// Administration
Open Event end
//
Administration Show begin
// Administration
BeforeShow Event begin
// Administration
BeforeShow Event end
// Administration Show end
}
/*===============================
Display Login Form
-------------------------------*/
protected bool
Login_logged = false;
void Login_Show() {
// Login Show begin
// Login Open Event
begin
// Login Open Event
end
// Login BeforeShow
Event begin
// Login BeforeShow
Event end
if (Login_logged) {
// User logged in
Login_login.Text =
"Logout";
Login_trpassword.Visible =
false;
Login_trname.Visible = false;
Login_labelname.Visible =
true;
Login_labelname.Text =
Utility.Dlookup("employees", "login",
"employee_id=" + Session["UserID"]) +
" ";
} else {
// User is not logged in
Login_login.Text =
"Login";
Login_trpassword.Visible =
true;
Login_trname.Visible = true;
Login_labelname.Visible =
false;
}
// Login Close Event
begin
// Login Close Event
end
// Login Show end
}
void
Login_login_Click(Object Src, EventArgs E) {
if (Login_logged) {
//
Login Logout begin
// Login OnLogout
Event begin
// Login OnLogout
Event end
Login_logged =
false;
Session["UserID"] =
0;
Session["UserRights"]
= 0;
Login_Show();
// Login Logout end
} else {
// Login Login begin
int iPassed =
Convert.ToInt32(Utility.Dlookup("employees", "count(*)",
"login ='" + Login_name.Text + "' and pass='" +
CCUtility.Quote(Login_password.Text) + "'"));
if (iPassed > 0) {
// Login OnLogin
Event begin
// Login OnLogin
Event end
Login_message.Visible
= false;
Session["UserID"]
= Convert.ToInt32(Utility.Dlookup("employees",
"employee_id", "login ='" + Login_name.Text + "' and
pass='" + CCUtility.Quote(Login_password.Text) +"'"));
Login_logged =
true;
Session["UserRights"]
= Convert.ToInt32(Utility.Dlookup("employees",
"security_level", "login ='" + Login_name.Text + "'
and pass='" + CCUtility.Quote(Login_password.Text) + "'"));
string sQueryString
= Utility.GetParam("querystring");
string sPage =
Utility.GetParam("ret_page");
if(!sPage.Equals(Request.ServerVariables["SCRIPT_NAME"])
&& sPage.Length > 0) {
Response.Redirect(sPage
+ "?" + sQueryString);
} else {
Login_Show();
}
} else {
Login_message.Visible
= true;
}
// Login Login end
}
}
// End of Login form
}
}
*Bug record code
namespace Bug_Management
usig System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.OleDb;
using System.Drawing;
using System.Web;
using System.Web.SessionState;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.HtmlControls;
/// <summary>
/// Summary description for
BugRecord.
/// </summary>
public
partial class BugRecord : System.Web.UI.Page
{
//BugRecord CustomIncludes begin
protected
CCUtility Utility;
//Record
form Bugs variables and controls declarations
//
For each Bugs form hiddens for PK's,List of Values and Actions
protected
string Bugs_FormAction="Default.aspx?";
public
BugRecord()
{
this.Init
+= new System.EventHandler(Page_Init);
}
// BugRecord CustomIncludes end
//-------------------------------
public void ValidateNumeric(object
source, ServerValidateEventArgs args) {
try{
Decimal
temp=Decimal.Parse(args.Value);args.IsValid=true;
}
catch{
args.IsValid=false; }
}
//===============================
// BugRecord Show begin
protected void Page_Load(object sender,
EventArgs e)
{
Utility=new
CCUtility(this);
//===============================
// BugRecord Open Event begin
// BugRecord Open Event end
//===============================
//===============================
// BugRecord OpenAnyPage Event begin
// BugRecord OpenAnyPage Event end
//===============================
//
//===============================
//
BugRecord PageSecurity begin
Utility.CheckSecurity(1);
//
BugRecord PageSecurity end
//===============================
if
(!IsPostBack){
p_Bugs_bug_id.ValueUtility.GetParam("bug_id");Page_Show(sende);
}
}
protected
void Page_Unload(object sender, EventArgs e)
{
//
//
CODEGEN: This call is required by the ASP+ Windows Form Designer.
//
if(Utility!=null)
Utility.DBClose();
}
protected
void Page_Init(object sender, EventArgs e)
{
//
//
CODEGEN: This call is required by the ASP+ Windows Form Designer.
//
InitializeComponent();
Bugs_insert.ServerClick
+= new System.EventHandler (this.Bugs_Action);
Bugs_update.ServerClick
+= new System.EventHandler (this.Bugs_Action);
Bugs_delete.ServerClick
+= new System.EventHandler (this.Bugs_Action);
Bugs_cancel.ServerClick
+= new System.EventHandler (this.Bugs_Action);
}
/// <summary>
///
Required method for Designer support - do not modify
///
the contents of this method with the code editor.
/// </summary>
private void InitializeComponent()
{
}
protected void Page_Show(object sender,
EventArgs e)
{
Bugs_Show();
}
// BugRecord Show end
// End of Login form
private bool Bugs_Validate(){
bool
result=true;
Bugs_ValidationSummary.Text="";
for(int
i=0;i<Page.Validators.Count;i++){
if(((System.Web.UI.WebControls.BaseValidator)Page.Validators[i]).ID.ToString().StartsWith("Bugs")){
if(!Page.Validators[i].IsValid){
Bugs_ValidationSummary.Text+=Page.Validators[i].ErrorMessage+"<br>";
result=false;
}
}
}
Bugs_ValidationSummary.Visible=(!result);
return
result;
}
/*===============================
Display Record Form
-------------------------------*/
void Bugs_Show() {
//
Bugs Show begin
Utility.buildListBox(Bugs_project_id.Items,"select
project_id,project_name from projects order by
2","project_id","project_name",null,"");
Utility.buildListBox(Bugs_priority_id.Items,"select
priority_id,priority_desc from priorities order by
2","priority_id","priority_desc",null,"");
Utility.buildListBox(Bugs_assigned_to.Items,"select
employee_id,employee_name from employees order by
2","employee_id","employee_name",null,"");
Utility.buildListBox(Bugs_status_id.Items,"select
status_id,status from statuses order by
2","status_id","status",null,"");
bool
ActionInsert=true;
if
(p_Bugs_bug_id.Value.Length > 0 ) {
string
sWhere = "";
sWhere
+= "bug_id=" + CCUtility.ToSQL(p_Bugs_bug_id.Value,
FieldTypes.Number);
// Bugs Open Event begin
// Bugs Open Event end
string
sSQL = "select * from bugs where " + sWhere;
OleDbDataAdapter
dsCommand = new OleDbDataAdapter(sSQL, Utility.Connection);
DataSet
ds = new DataSet();
DataRow
row;
if
(dsCommand.Fill(ds, 0, 1, "Bugs") > 0) {
row
= ds.Tables[0].Rows[0];
Bugs_bug_id.Value
= CCUtility.GetValue(row, "bug_id");
Bugs_bug_name.Text
= CCUtility.GetValue(row, "bug_name");
Bugs_bug_desc.Text
= CCUtility.GetValue(row, "bug_desc");
{string
s;
s=CCUtility.GetValue(row,
"project_id");
try
{Bugs_project_id.SelectedIndex=Bugs_project_id.Items.IndexOf(Bugs_project_id.Items.FindByValue(s));
}catch{}}
{string
s;
s=CCUtility.GetValue(row,
"priority_id");
if(s.Length==0)
s= "3";
try
{Bugs_priority_id.SelectedIndex=Bugs_priority_id.Items.IndexOf(Bugs_priority_id.Items.FindByValue(s));
}catch{}}
Bugs_assigned_by.Text
=Server.HtmlEncode( Utility.Dlookup("employees",
"employee_name", "employee_id=" +
CCUtility.ToSQL(CCUtility.GetValue(row, "assigned_by"),
FieldTypes.Number)).ToString());
{
string s;
s=CCUtility.GetValue(row,
"assigned_to");
try
{Bugs_assigned_to.SelectedIndex=Bugs_assigned_to.Items.IndexOf(Bugs_assigned_to.Items.FindByValue(s));
}catch{}
}
Bugs_date_assigned.Text =
CCUtility.GetValue(row, "date_assigned");
{string
s;
s=CCUtility.GetValue(row,
"status_id");
if(s.Length==0)
s= "1";
try
{Bugs_status_id.SelectedIndex=Bugs_status_is_id.Items.FindByValue(s));
}catch{}
}
Bugs_date_resolved.Text =
CCUtility.GetValue(row, "date_resolved");
Bugs_resolution.Text
= CCUtility.GetValue(row, "resolution");
Bugs_insert.Visible=false;
ActionInsert=false;
// Bugs ShowEdit Event begin
// Bugs ShowEdit Event end
}
}
if(ActionInsert){
String
pValue;
pValue
= Utility.GetParam("bug_id");Bugs_bug_id.Value = pValue;
if(Session["UserID"]!=null)
pValue
= Session["UserID"].ToString();
else
pValue="";if
(pValue.Length>0){Bugs_assigned_by.Text =
Utility.Dlookup("employees", "employee_name",
"employee_id=" + pValue);}Bugs_delete.Visible=false;
Bugs_update.Visible=false;
// Bugs ShowInsert Event begin
Bugs_date_assigned.Text=DateTime.Today.ToString("d");
// Bugs ShowInsert Event end
}
// Bugs Open Event begin
// Bugs Open Event end
// Bugs Show Event begin
// Bugs Show Event end
//
Bugs Show end
// Bugs Close Event begin
// Bugs Close Event end
}
//
Bugs Action begin
bool Bugs_insert_Click(Object Src,
EventArgs E) {
string
sSQL="";
bool
bResult=Bugs_Validate();
// Bugs Check Event begin
// Bugs Check Event end
string
s1_UserID=CCUtility.ToSQL(Session["UserID"].ToString(), FieldTypes.Number);
string
p2_bug_name=CCUtility.ToSQL(Utility.GetParam("Bugs_bug_name"),
FieldTypes.Text) ;
string
p2_bug_desc=CCUtility.ToSQL(Utility.GetParam("Bugs_bug_desc"),
FieldTypes.Text) ;
string
p2_project_id=CCUtility.ToSQL(Utility.GetParam("Bugs_project_id"),
FieldTypes.Number) ;
string
p2_priority_id=CCUtility.ToSQL(Utility.GetParam("Bugs_priority_id"),
FieldTypes.Number) ;
string
p2_assigned_to=CCUtility.ToSQL(Utility.GetParam("Bugs_assigned_to"),
FieldTypes.Number) ;
string
p2_date_assigned=CCUtility.ToSQL(Utility.GetParam("Bugs_date_assigned"),
FieldTypes.Text) ;
string
p2_status_id=CCUtility.ToSQL(Utility.GetParam("Bugs_status_id"),
FieldTypes.Number) ;
string
p2_date_resolved=CCUtility.ToSQL(Utility.GetParam("Bugs_date_resolved"),
FieldTypes.Text) ;
string
p2_resolution=CCUtility.ToSQL(Utility.GetParam("Bugs_resolution"),
FieldTypes.Text) ;
// Bugs Insert Event begin
// Bugs Insert Event end
if(bResult){
if(sSQL.Length==0){
sSQL
= "insert into bugs (" +
"[assigned_by],"
+
"bug_name,"
+
"bug_desc,"
+
"project_id,"
+
"priority_id,"
+
"assigned_to,"
+
"date_assigned,"
+
"status_id,"
+
"date_resolved,"
+
"resolution)"
+
"
values (" +
s1_UserID
+ "," +
p2_bug_name
+ "," +
p2_bug_desc
+ "," +
p2_project_id
+ "," +
p2_priority_id
+ "," +
p2_assigned_to
+ "," +
p2_date_assigned
+ "," +
p2_status_id
+ "," +
p2_date_resolved
+ "," +
p2_resolution
+ ")";
}
Bugs_BeforeSQLExecute(sSQL,"Insert");
OleDbCommand
cmd = new OleDbCommand(sSQL, Utility.Connection);
try
{
cmd.ExecuteNonQuery();
}
catch(Exception e) {
Bugs_ValidationSummary.Text
+= e.Message;
Bugs_ValidationSummary.Visible
= true;
return
false;
}
// Bugs AfterInsert Event begin
// Bugs AfterInsert Event end
}
return
bResult;
}
void
Bugs_BeforeSQLExecute(string SQL,String Action){
// Bugs BeforeExecute Event begin
// Bugs BeforeExecute Event end
}
bool
Bugs_update_Click(Object Src, EventArgs E) {
string sWhere = "";
string
sSQL ="";
bool
bResult=Bugs_Validate();
if(bResult){
if (p_Bugs_bug_id.Value.Length > 0)
{
sWhere = sWhere + "bug_id=" +
CCUtility.ToSQL(p_Bugs_bug_id.Value, FieldTypes.Number);
}
// Bugs Check Event begin
// Bugs Check Event end
if
(bResult){
sSQL
= "update bugs set " +
"[bug_name]="
+CCUtility.ToSQL(Utility.GetParam("Bugs_bug_name"),FieldTypes.Text) +
",[bug_desc]="
+CCUtility.ToSQL(Utility.GetParam("Bugs_bug_desc"),FieldTypes.Text) +
",[project_id]="
+CCUtility.ToSQL(Utility.GetParam("Bugs_project_id"),FieldTypes.Number) +
",[priority_id]="
+CCUtility.ToSQL(Utility.GetParam("Bugs_priority_id"),FieldTypes.Number) +
",[assigned_to]="
+CCUtility.ToSQL(Utility.GetParam("Bugs_assigned_to"),FieldTypes.Number) +
",[date_assigned]="
+CCUtility.ToSQL(Utility.GetParam("Bugs_date_assigned"),FieldTypes.Text) +
",[status_id]="
+CCUtility.ToSQL(Utility.GetParam("Bugs_status_id"),FieldTypes.Number) +
",[date_resolved]="
+CCUtility.ToSQL(Utility.GetParam("Bugs_date_resolved"),FieldTypes.Text) +
",[resolution]="
+CCUtility.ToSQL(Utility.GetParam("Bugs_resolution"),FieldTypes.Text)
;
sSQL = sSQL + " where " +
sWhere;
// Bugs Update Event begin
// Bugs Update Event end
Bugs_BeforeSQLExecute(sSQL,"Update");
OleDbCommand
cmd = new OleDbCommand(sSQL, Utility.Connection);
try
{
cmd.ExecuteNonQuery();
}
catch(Exception e) {
Bugs_ValidationSummary.Text
+= e.Message;
Bugs_ValidationSummary.Visible
= true;
return
false;
}
}
if
(bResult){
// Bugs AfterUpdate Event begin
// Bugs AfterUpdate Event end
}
}
return
bResult;
}
bool Bugs_delete_Click(Object Src,
EventArgs E) {
string
sWhere = "";
if
(p_Bugs_bug_id.Value.Length > 0) {
sWhere
+= "bug_id=" + CCUtility.ToSQL(p_Bugs_bug_id.Value, FieldTypes.Number);
}
string
sSQL = "delete from bugs where " + sWhere;
// Bugs Delete Event begin
// Bugs Delete Event end
Bugs_BeforeSQLExecute(sSQL,"Delete");
OleDbCommand
cmd = new OleDbCommand(sSQL, Utility.Connection);
try
{
cmd.ExecuteNonQuery();
}
catch(Exception e) {
Bugs_ValidationSummary.Text
+= e.Message;
Bugs_ValidationSummary.Visible
= true;
return
false;
}
// Bugs AfterDelete Event begin
// Bugs AfterDelete Event end
return
true;
}
bool Bugs_cancel_Click(Object Src,
EventArgs E) {
// Bugs BeforeCancel Event begin
// Bugs BeforeCancel Event end
return
true;
}
void Bugs_Action(Object Src,
EventArgs E) {
bool bResult=true;
if(((HtmlInputButton)Src).ID.IndexOf("insert")>0)
bResult=Bugs_insert_Click(Src,E);
if(((HtmlInputButton)Src).ID.IndexOf("update")>0)
bResult=Bugs_update_Click(Src,E);
if(((HtmlInputButton)Src).ID.IndexOf("delete")>0)
bResult=Bugs_delete_Click(Src,E);
if(((HtmlInputButton)Src).ID.IndexOf("cancel")>0)
bResult=Bugs_cancel_Click(Src,E);
if(bResult)Response.Redirect(Bugs_FormAction+"");
}
// Bugs Action end
}
}
7. TESTING AND IMPLEMENTATION
Testing is a process to show the correctness of the program. Testing
is needed to show completeness, to improve the quality of the software and to
provide the maintenance aid. Some testing standards are therefore necessary
reduce the testing costs and operation time. Testing software extends throughout
the coding phase and it represents the ultimate review of configurations,
design and coding. Based on the way the software reacts to these testing, we
can decide whether the configuration that has been built is study or not. All
components of an application are tested, as the failure to do so many results
in a series of bugs after the software is put to use.
Black box Testing
Black box testing also called behavioral testing, focuses on the
functional requirements of software. This testing approach enables the software
engineer to derive the input conditions that will fully exercise all
requirements for a program. Blackbox testing attempts to find the errors like
Ø
Incorrect or missing functions
Ø
Interface errors
Ø
Errors in data structures or external
database access
Ø
Behavior or performance errors
Ø
Initialization and termination
errors
In Black box
testing software is exercised over a full range of inputs and outputs are
observed for correctness.
White box Testing
White box testing is also called Glassbox testing is a test case
design control structure of the procedural design to derive test cases using
Whitebox testing method, the software engineer can derive the test cases that
guarantee that all independent paths within the module have been exercised at
least once. Exercise all logic decisions on their true or false sides. Execute
all loops at their boundaries and within their operational bounds. Exercise
internal data structure to ensure their validity.
Software
Testing Strategies
Testing involves
Ø
Unit testing
Ø
Integration testing
Ø
Acceptance testing
The first level of test is unit testing. The purpose of unit testing
is to ensure that each program is fully tested.
The second step is integration
testing. In this individual program units or programs are integrated and tested
as a complete system to ensure that the software requirements are met.
Acceptance Testing involves planning
and the execution of various types of tests in order to demonstrate that the
implemented software system satisfies the requirements. Finally our project
meets the requirements after going through all the levels of testing.
FUTURE ENHANCEMENT
This project is having a broad future
scope as it can extend. This developed system has to good extend succeeded in
rectifying the problems that are present in the manual system. The newly
developed system consumes less processing time and reduces the manual work.
The goals have been achieved by the
development of this project are:
Ø
It simplifies the operation.
Ø
The less Processing time
increase the productivity.
Ø
Avoids errors by minimizing
human intervention.
Ø
User friendly screens to enter
the data and require the data.
Ø
Help message to operate the
system.
Ø
Reduce more manpower
requirements.
Ø
Reduce processing time.
Ø
Reduce use of stationary
8.
CONCLUSION
This software is developed to overcome the problems in the present
system. This software is a more user friendly. It is developed using ASP.NET
language as a front-end and SQL Server database as back-end whose
friendliness has already been described. It is successfully working integrated
with the consents workflow product.
9.
BIBLIOGRAPHY
1.
Microsoft visual Basic.NET
By: Michael Halvorson
Step
by Step
Publisher:
Microsoft Press
2.
Microsoft visual Basic.NET
By: Michael Halvorson
Deluxe
learning Edition
Publisher:
Microsoft Press
3.
Learning VB.NET (2nd Edition)
By:Richards Blair et al
Publisher:
Wrox Press
4.
Microsoft SQL Server
By: Robert Vieira
Web Sites:
Comments
Post a Comment