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

 

  1. Product and Component based
  2. Creating & Changing Bugs at ease
  3. Query Bug List to any depth
  4. Reporting & Charting in more comprehensive way
  5. User Accounts to control the access and maintain security
  6. Simple Status & Resolutions
  7. Multi-level Priorities & Severities.
  8. Targets & Milestones for guiding the programmers
  9. 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

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

 

                               4. SYSTEM DESIGN

 

        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"]) + "&nbsp;&nbsp;&nbsp;";

          } 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"]) + "&nbsp;&nbsp;&nbsp;";

          } 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:

 

              www.asp.net

             www.google.com

 

Comments

Popular posts from this blog

Chemical test for Tragacanth

Chemical test for Benzoin

Chemical test for Agar/Agar-Agar / Japaneese Isinglass