Report

A
PROJECT
ON
BUG TRACKING SYSTEM –JAVA SE Desktop Application
By:
JASPREET SINGH
Computer Science & Engineering
02576802715
Department of Computer Science & Engineering

Guru TeghBahadur Institute of Technology
Guru Gobind Singh Indraprastha University

Dwarka,New Delhi
Year(2015-2019)
ACKNOWLEDGEMENT
The successful completion of this project makes the beginning of an ever going learning
experience of converting ideas & concepts into real life, practical system. This project was
quite a learning experience for me & at each & every step. At the same time it has given me
the confidence to work in a professional setup. I feel the experience I gained during this
project would lead me to a bright prospect in future from this prestigious organization under
the guidance of such dedicated & knowledgeable people.
I wish to express my sincere gratitude to MTA- NOIDA to provide me the opportunity to

conduct this project at the organization which not only increased our awareness about the
latest field but also taught me the importance of discipline & dedication towards our work. I
am highly thankful
To Mr Naresh sir for giving me the opportunity to work upon this project.
I would also thanks to TEAMMEMBERS for excellent coordination, motivation and help
without which this project would not have been a success. I choose this moment to
acknowledge his contribution gratefully.
Date: 25/10/2017 Jaspreet Singh
02576802715
Jassi80singh80@gmail.com
Abstract
For many years, bug-tracking mechanism is employed only in some of the large
software development houses. Most of the others never bothered with the bug
tracking at all, and instead simply relied on shared lists and email to monitor the
status of the 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 Defect Tracking System.
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 and changing bugs at ease
 Query bug list to any depth
 Reporting and charting in more comprehensive way
 User accounts to control the access and maintain security
 Simple status and resolutions
 Multi-level Severities
 Targets and milestones for guarding the programmers
 Robust database back-end
INDEX
Title Page (i)
Acknowledgement (ii)
Abstract (iii)
About Bug-Tracking system
1. Chapter-one Introduction
i. Java SE& Key Features
ii. Java SE applications
iii. Java SE features
iv. EXE making
2. Chapter-Two Software and Requirement Specifications
3. Chapter-Three System Design
i. E-R Diagrams
ii. Data Flow Diagram
4. Chapter-Four Result and Conclusion
i. References
5. Chapter-Five Appendixes
i. Appendix-A Screenshots
ii. Appendix-B Source Code
About BUG-TRACKING SYSTEM
A bug tracking system or defect tracking system is
a software application that keeps track of reported software
bugs in software development projects. It may be regarded as
a type of issue tracking system.
Many bug tracking systems, such as those used by most open
source software projects, allow end-users to enter bug reports
directly. Other systems are used only internally in a company
or organization doing software development. Typically bug
tracking systems are integrated with other software project
management applications.
A bug tracking system is usually a necessary component of a
good software development infrastructure, and consistent use
of a bug or issue tracking system is considered one of the
"hallmarks of a good software team".
Key Features : -
The main objectives of the Bug Tracking System are:
-Identifying the bugs in the developed application.

-No bug will be unfixed in the developed application.
-Not merely identifying the bugs but also providing the bug information.
As soon as the bugs are identified. They are reported to the project manager and
developer.
To ensure that who needs to know about the bug can learn soon after it is
reported.
Existing System
In the existing system, the project manager assigns the projects to the
developers. The developers develops the projects as per customer requirements.
The project manager itself assign the developed applications to the tester for
testing. In the testing phase, when the tester encounters no. of bugs then he
reports to the project manager and developer about the bug information.
Bottlenecks of the Existing System

The tester report which is called Bug Report is in the form of physical
document. If the document is damaged then the total information about the bug
will be lost.
The bug information is not stored in the database for future reference.
Proposed System
The purpose of the Bug Tracking System is to test the application for the bugs
and report it to the project manager and developer. The main intention behind
the Bug Tracking System is that to track bugs and report them. Store the bug
information with a unique id in the database for future reference. So, this makes
the job of handling the bugs easy.The project entitled "Bug tracking system" is
an online bug tracking tool initiated with the objective to setup a user-friendly
Online bug tracking system. It can be used both for bug tracking and for project
management. In this system the project manager can have full details of the
work assigned to each team member. Moreover when a new work comes he can
assign the work to different persons by having a view at the programmer with
minimum work. This software assists to track the work flow of the work given
to each team member by a project leader. This software assists the project
managers , the team members and equally the top officials of a software
company to know how the work is progressing. Project usually comes to the
company in the form of bugs. Usually, when certain enhancements of a product
is being done i.e. when. certain version updates a product is being done, work is
assigned to different programmers in the form of Bugs.
This software is mainly focused on the work coming in the form of Bugs. The
project manager can fully understand what the status of each bug is ;whether it
is fixed, assigned, or won’t fix.
Components
A major component of a bug tracking system is
a database that records facts about known bugs. Facts
may include the time a bug was reported, its severity,
the erroneous program behavior, and details on how to
reproduce the bug; as well as the identity of the person
who reported it and any programmers who may be
working on fixing it.
Typical bug tracking systems support the concept of the
life cycle for a bug which is tracked through the status
assigned to the bug. A bug tracking system should
allow administrators to configure permissions based on
status, move the bug to another status, or delete the bug.
The system should also allow administrators to
configure the bug statuses and to what extent a bug in a
particular status can be moved. Some systems will e-
mail interested parties, such as the submitter and
assigned programmers, when new records are added or
the status changes.
Usage : -
The main benefit of a bug-tracking system is to provide a
clear centralized overview of development requests (including
both bugs and improvements, the boundary is often fuzzy),
and their state. The prioritized list of pending items (often
called backlog) provides valuable input when defining the
product road map, or maybe just "the next release".
In a corporate environment, a bug-tracking system may be
used to generate reports on the productivity of programmers at
fixing bugs. However, this may sometimes yield inaccurate
results because different bugs may have different levels of
severity and complexity. The severity of a bug may not be
directly related to the complexity of fixing the bug. There may
be different opinions among the managers and architects.
A local bug tracker (LBT) is usually a computer program used
by a team of application support professionals (often a help
desk) to keep track of issues communicated to software
developers. Using an LBT allows support professionals to
track bugs in their "own language" and not the "language of
the developers." In addition, an LBT allows a team of support
professionals to track specific information about users who
have called to complain — this information may not always
be needed in the actual development queue. Thus, there are
two tracking systems when an LBT is in place.
Part of integrated project management systems

Bug and issue tracking systems are often implemented as a
part of integrated project management systems. This approach
allows including bug tracking and fixing in a general product
development process, fixing bugs in several product versions,
automatic generation of a product knowledge base and release
notes.
Distributed bug tracking

Some bug trackers are designed to be used with distributed revision
control software. These distributed bug trackers allow bug reports to
be conveniently read, added to the database or updated while a
developer is offline. Fossil and Veracity both include distributed bug
trackers.
Recently, commercial bug tracking systems have also begun to
integrate with distributed version control. FogBugz, for example,
enables this functionality via the source-control tool, Kiln.
Although wikis and bug tracking systems are conventionally viewed
as distinct types of software, ikiwiki can also be used as a distributed
bug tracker. It can manage documents and code as well, in an
integrated distributed manner. However, its query functionality is not
as advanced or as user-friendly as some other, non-distributed bug
trackers such as Bugzilla. Similar statements can be made about org-
mode, although it is not wiki software as such.
Bug tracking and test management

While traditional test management tools such as HP Quality
Center and IBM Rational Quality Manager come with their
own bug tracking systems, other tools integrate with popular
bug tracking systems.
CHAPTER – 1 : INTRODUCTION
1. Java SE
Java Platform, Standard Edition or Java SE is a computing platform for development and
deployment of portable code for desktop and server environments Java SE was formerly
known as Java 2 Platform, Standard Edition or J2SE. The platform uses Java programming
language and is part of the Java software-platform family..
2. Java SE APPLICATIONS
 The platform was known as Java 2 Platform, Standard Edition or J2SE from version
1.2, until the name was changed to Java Platform, Standard Edition or Java SE in
version 1.5. The "SE" is used to distinguish the base platform from the Enterprise
Edition (Java EE) and Micro Edition (Java ME) platforms. The "2" was originally
intended to emphasize the major changes introduced in version 1.2, but was removed
in version 1.6. The naming convention has been changed several times over the Java
version history. Starting with J2SE 1.4 (Merlin), Java SE has been developed under
the Java Community Process, which produces descriptions of proposed and final
specifications for the Java platform called Java Specification Requests (JSR).JSR 59
was the umbrella specification for J2SE 1.4 and JSR 176 specified J2SE 5.0 (Tiger).
Java SE 6 (Mustang) was released under JSR 270.
 The Java Platform, Enterprise Edition (Java EE) is a related specification that includes
all the classes in Java SE, plus a number that are more useful to programs that run
on servers as opposed to workstations.
 Java Platform, Micro Edition (Java ME) is a related specification intended to provide a
certified collection of Java APIs for the development of software for small, resource-
constrained devices such as cell phones, PDAs and set-top boxes.
 The Java Runtime Environment (JRE) and Java Development Kit (JDK) are the actual
files downloaded and installed on a computer to run or develop Java programs,
respectively.
3. Java SE Features
The following list contains links to the the enhancements pages in the Java SE 7 guides
documentation.
1) SWING :-
JLayer Class
The JLayer class is a flexible and powerful decorator for Swing
components. It enables you to draw on components and respond to
component events without modifying the underlying component directly.
For more information, read How to Decorate Components with JLayer in
the Java Tutorial.
Nimbus Look & Feel
The Nimbus Look & Feel (L&F) has moved
from com.sun.java.swing to a standard API
namespace, javax.swing; see
the javax.swing.plaf.nimbus package for more information.
Although it is not the default L&F, you can easily use it. Consult
the Nimbus Look and Feel section in the Java Tutorial for more
information and examples of three simple methods for using Nimbus in
your applications.
Heavyweight and Lightweight Components
Historically, mixing heavyweight (AWT) and lightweight (Swing)
components in the same container has been problematic. However,
mixing heavyweight and lightweight components is easy to accomplish in
Java SE 7. The Mixing Heavyweight and Lightweight Component article
shows you how.
Shaped and Translucent Windows
The Java SE 7 release supports windows with transparency and non-
rectangular shapes. See How to Create Translucent and Shaped
Windows, part of the Java Tutorial.
Hue-Saturation-Luminance (HSL) Color Selection in JColorChooser
Class
An HSV tab has been added to the JColorChooser class, which allows
users to select colors using the Hue-Saturation-Luminance (HSL) color
model.
2) Java.lang Package :- The function of a java.lang.ClassLoader is to locate

the bytecode for a particular class, then transform that bytecode into a usable
class in the runtime system. The runtime system provides class loaders that can
locate bootstrap classes, extension classes, and user classes.
The CLASSPATH environment variable is one way to indicate to the runtime
system where the bytecode is located.Knowing about
the CLASSPATH environment variable is all you may need to know about class
loading. In some specific situations, however, customizing the behavior of a class
loader by creating your own subclass may be necessary.Custom class loaders
will not run into deadlocks if they adhere to an acyclic class loader delegation
model. Acyclic delegation is what the architects of ClassLoader envisioned. In
this model, every class loader has a parent (delegate). When a class is
requested, the class loader first checks if the class was loaded previously. If the
class is not found, the class loader asks its parent to locate the class. If the
parent cannot find the class, the class loader attempts to locate the class itself.
3) Java Virtual Machine(JVMs) : - On platforms typically used for client

applications, the JDK comes with a VM implementation called the Java
HotSpot™ Client VM (client VM). The client VM is tuned for reducing start-up
time and memory footprint. It can be invoked by using the -client command-
line option when launching an application.On all platforms, the JDK comes with
an implementation of the Java virtual machine called the Java HotSpot Server
VM (server VM). The server VM is designed for maximum program execution
speed. It can be invoked by using the -servercommand-line option when
launching an application.
4) JDBC : - The Java Database Connectivity (JDBC) API provides universal data
access from the Java programming language. Using the JDBC API, you can
access virtually any data source, from relational databases to spreadsheets and
flat files. JDBC technology also provides a common base on which tools and
alternate interfaces can be built.
The JDBC API is comprised of two packages:
 java.sql
 javax.sql
You automatically get both packages when you download the Java Platform
Standard Edition (Java SE) 7.
To use the JDBC API with a particular database management system, you need a
JDBC technology-based driver to mediate between JDBC technology and the
database. Depending on various factors, a driver might be written purely in the Java
programming language or in a mixture of the Java programming language and Java
Native Interface (JNI) native methods. To obtain a JDBC driver for a particular
database management system, see JDBC Data Access API.
What can I build using JAVA SE?
Java SE is for developing desktop applications and it is the

foundation for developing in Java language. It consists of
development tools, deployment technologies, and other class
libraries and toolkits used in Java applications. Strictly
speaking, these platforms are specifications; they are norms,
not software. The Java Platform, Standard Edition
Development Kit (JDK) is an official implementation of the
Java SE specification, provided by Oracle. There are also
other implementations, like OpenJDK and IBM's J9.
4. EXE making (in eclipse)
The Simplest and most standard process for running a java project is to run an executable file
(.exe). To make an executable file first we make a .jar file.
Steps to make a JAR file are:
1. Right click on project and click“Refresh”.

2. Right click on project and click “Export”.
3. Expand the “Java” folder and double click the “JAR file” option.
4. Configure the specifications of the JAR file.
 Firstly, select the main classfrom the drop down menu under “Launch
configuration”.
 Secondly, select the”Export destination” via the “browse…” button or by
manually typing the location.
 Lastly, ensure the “Extract required libraries into generated JAR” radio button
is selected. Click “Finish” when you are satisfied with your selections.
Steps to make EXE file is:
1. Download the latest version of jdk from Oracle website: Java SE Development Kit 7 or
8. Just select your OS from the list and click on the provided link to download.
2. Install the jdk setup (it also contains the jre so you don't need to download it
separately).
3. After finishing installation,
a. )in your pc open the directory where jdk(not jre) is installed. Open the folder named
"bin". Copy the whole directory name from the top. It will be like C:\Program Files\
Java\jdk1.8.0_40\bin. Your directory name can vary.
b.) Now open "This pc" and right click to get its properties, open it and and click on
"Advanced system settings".
b.) Under "Advanced" tab, click on environment variables.
c.) Under user variables, if there is a variable named path, modify it. Just paste the
copied directory name in the front of the value.
d.) If it doesn't exist, then create a new one and copy the directory name in the value.
Click OK from all the opened windows of settings.
e.) Now open command prompt, go to the directory where java file is located, type the
command "javac FileName.java" to compile and hit enter.
f.) To run the program just write in command prompt "java FileName". Remember the
name should be same as specified in file name.
g.)That's it...
CHAPTER 2 : SOFTWARE REQUIREMENT
SPECIFICATIONS
2.1 Introduction
2.1.1 Purpose
This Software Requirements Specification (SRS) specifies the requirements of

the BugTracking Software, which will be used by the people to understand
about bugs and tracking
them. This document will be used by the developer to ensure all
specifications are correct and verified
by the software engineer to design the system.
2.1.2 Scope
This desktop application is a great platform for those people who have no idea
about Bug Tracking System Software. The scope of this application is
extensive. This software provides full inventory management. The users can
get updated with the notifications in future stages and along with the web
integration. This desktop application has a scope of running from lower to the
latest JDK version so that it is compatible with almost all computers making it
more users friendly.
2.1.3 Overview
This desktop application gives all the details about Bug management system
from tracking bug to see their solutions. It is a viable option to replace the use
of hand written invoices. The selecting product, bug records and generate and
see their solutions or searching all are features are present.
2.3 Main Features of the Desktop Application
 Modern UX
 Easy to use UI
 Searching product for tracking bug and their details
 Adding information about different bugs
 Their solutions
 Bug records
 Login manual for bug tracking detail
 Low cost as compared to current competitors
 Secure
4.2.3System Requirements
4. 2.3.1 Hardware Requirements
On Developer Side:
Processor: Intel Core™ i3 or above.
RAM : 4GB.
Hard disk: 40GB or above.
Monitor : 15’’ LCD or CRT Monitor or above.
Keyboard: Standard windows keyboard
GPU: NVidia GeForce 500 series and above (or any equivalent GPU)
On Client Side:
Processor: Dual core or above.
RAM : 4GB.
Hard disk: 40GB or above.
Monitor : 15’’ LCD or CRT Monitor or above.
Keyboard: Standard windows keyboard
GPU : NVidia GeForce 500 series and above (or any equivalent GPU)
4. 2.3.2Software Requirements
Development Kit: JRE 1.8.0_91 and Java JDK 1.8.
Languages : Core Java
IDE : NetBeans 8.2
Build id : M20160212-1500
Platform : Any OS.
1.2.4 Assumptions and Dependencies:
Manage Dependencies carefully to keep you’re:
 code up to date
 secure system
 service working as intended
No internet connections required for this version of desktop application.
4.2.5 Overview of Data Requirements
The product is completely data oriented.

4.3 Non Functional Requirements:
 Performance Requirements:
Application must respond within seconds if key is pressed or shortcuts are

called. Switching between tabs should be quick. Connection to database and
printing invoices should be automatic which add a key feature to the
performance.
 Reliability:
This application has features of tracking bug management as well as and

saving their details for future reference. The Key orientation and shortcuts
make it a user friendly and easy to navigate software for fast and efficient
usage.
 Availability:
This proposed system finds extended application to users who have installed
this application as the tracking bug management can be done using this
software. The users can get updated with the notifications in future stages and
along with the web integration.
 Maintainability:
Since it is a desktop application it is mandatory to maintain its database and

keeping the records safe for future purposes. Checks should be made timely to
ensure all the data is stored securely in the database.
CHAPTER 3 : SYSTEM DESIGN
E-R DIAGRAM
CHAPTER 4 : CONCLUSION
In review my training was excellent and rewarding experience. I have been able
to meet and network with so many people that I am sure will be able to help me
with opportunities in the future.
One main thing that I have learnt through my training is time management skills
as well as self-motivation.
Training at Microsoft Associate experienced me with the training and startup

culture and the Software development process. Startup and organization are
very different from each other in many aspects like
 In startup, you can see every kind of people on various roles and you can
interact most of them. In larger organizations, this is not easy.
 Bigger organizations provide your more respect by outsiders.
 Training can give you opportunity to write raw code whereas many
mature organizations uses Framework.
In enjoyed this line of work, and will continue to work hard in my position and
hope to continue to learn about the industry and meet new people. This was an
excellent experience and I hope I would make more interesting projects in
future!
REFERENCES
LINKS
1. www.google.com
2. www.jdbcdocs.com
3. www.javadocs.com
4. www.stackoverflow.com
5. www.tutorialpoint.com
6. www.w3school.com
7. www.wikipedia.com
REFERENCE BOOKS
1. Balaguruswamy for java

2. Java Complete Reference
3. Let us C++
CHAPTER 5 : APPENDIXES
APPENDIX-A SCREENSHOTS
1. Main User module which consists of : -

 User Login
 Selecting Product
 Selecting Bug Type
 Solution
 Contact Details
2. By clicking Login,Login page appears which consists of
Username and password text field ,if u already have account

enter details or if u are new u can register clicking Register
button.
3. Now after clicking Select Product button window appears where

product’s Id ,name and version can be saved. If details of some products
are already saved u can search them by entering their id and tapping
search button. Get Details button conveys the details of all the products
saved in the database.
4. Upon clicking Select Bug Type helps you to save a particular bug’s details
so that it could be identified in future. A window appears which consists
of BUG ID, AUTHOR ID, AUTHOR, PRODUCT ID, PRODUCT NAME, ENV,
TYPE, DESCRIPTION,REP_DATE, PRIORITY. Details of a bug can be saved
by clicking submit. If bug details already exists in database it can be
searched by entering BIG ID and clicking Search button.
5. See Solution button helps to find a solution to a particular bug. It
consists of BUG ID, EXPERT ID, EXPERT, SOLUTION, SOLN.DATE textfield.
We can save them using Save button ,search an already stored solution
using search button, And get details of all solutions using Get Details
button.
6. Contact button gives the contact details of the developer.

APPENDIX-B SOURCE CODE
Source code for Menu page: -

package BugTracking;
public class Login extends javax.swing.JFrame {
public Login() {
initComponents();
}
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">
private void initComponents() {
jPanel1 = new javax.swing.JPanel();
jButton1 = new javax.swing.JButton();
jLabel1 = new javax.swing.JLabel();
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
jPanel1.setBackground(new java.awt.Color(180, 180, 240));

jPanel1.setToolTipText("");
jPanel1.setCursor(new java.awt.Cursor(java.awt.Cursor.DEFAULT_CURSOR));
jPanel1.setName("BUG TRACKER"); // NOI18N
jButton1.setText("LOGIN");
jButton1.addActionListener(new java.awt.event.ActionListener() {
public void actionPerformed(java.awt.event.ActionEvent evt) {
jButton1ActionPerformed(evt);
}
});
jButton2.setText("SELECT PRODUCT");
}
});
jButton3.setText("SELECT BUG TYPE");
}
});
jButton5.setText("SEE SOLUTION");
}
});
jLabel1.setFont(new java.awt.Font("Times New Roman", 3, 24)); // NOI18N
jLabel1.setHorizontalAlignment(javax.swing.SwingConstants.CENTER);
jLabel1.setText("BUG TRACKING SYSTEM");
jButton4.setText("Contact");
}
});
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

Loginpage s = new Loginpage();
s.setVisible(true);
}
// TODO add your handling code here:
Product r = new Product();
r.setVisible(true);
}
Solution a = new Solution();
a.setVisible(true);
}
Bugtype y = new Bugtype();
y.setVisible(true);
}
Contact z = new Contact();
z.setVisible(true);
}
public static void main(String args[]) {
try {
for (javax.swing.UIManager.LookAndFeelInfo info :
javax.swing.UIManager.getInstalledLookAndFeels()) {
if ("Nimbus".equals(info.getName())) {
javax.swing.UIManager.setLookAndFeel(info.getClassName());
break;
}
}
} catch (ClassNotFoundException ex) {
java.util.logging.Logger.getLogger(Login.class.getName()).log(java.util.logging.Level.SEVERE,
null, ex);
} catch (InstantiationException ex) {
null, ex);
} catch (IllegalAccessException ex) {
null, ex);
} catch (javax.swing.UnsupportedLookAndFeelException ex) {
null, ex);
}
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Login().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
Souce code for Login page : -

import java.sql.*;
public class Loginpage extends javax.swing.JFrame {
public Loginpage() {
initComponents();
}

jTextField1 = new javax.swing.JTextField();
jPasswordField1 = new javax.swing.JPasswordField();
}
try
{
Class.forName("com.mysql.jdbc.Driver");
Connection
cn=DriverManager.getConnection("jdbc:mysql://localhost:3306/bug","root","root");
Statement stmt = cn.createStatement();
String username = jTextField1.getText();
String password = jPasswordField1.getText();
if(jButton1.getText().equals("LOGIN"))
{
String str ="select LOGINID,PASSWORD from login_master where LOGINID='"+username+"'
AND PASSWORD='"+password+"'";
ResultSet rs = stmt.executeQuery(str);
jTextField1.setText("");
jPasswordField1.setText("");
if(rs.next()== true)
{
Administrator d = new Administrator();
d.setVisible(true);
}
else
{
jLabel5.setText("Either username or password is not correct");
}
}
// Administrator d = new Administrator();

// d.setVisible(true);
}
catch(ClassNotFoundException | SQLException ex)
{
ex.printStackTrace();
}
}
Loginmaster s = new Loginmaster();
s.setVisible(true);
}
public void run() {
new Loginpage().setVisible(true);
}
});
}

private javax.swing.JPasswordField jPasswordField1;
private javax.swing.JTextField jTextField1;
// End of variables declaration
}
Source code for Register page : -
import java.sql.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class Loginmaster extends javax.swing.JFrame {
public Loginmaster() {
initComponents();
}
// <editor-fold defaultstate="collapsed" desc="Generated Code">

}
});
private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {

}

try
{
Connection
String LOGINID = jTextField1.getText();
String NAME = jTextField2.getText();
String PASSWORD = jTextField3.getText();
String EMAILID = jTextField4.getText();
String TYPE = jTextField5.getText();
if(jButton1.getText().equals("Register"))
{
String insert = "insert into login_master
values('"+LOGINID+"','"+NAME+"','"+PASSWORD+"','"+EMAILID+"','"+TYPE+"')";
int row = stmt.executeUpdate(insert);
if(row>0)
{
jLabel6.setText("Record has been saved!!!");
}
} cn.close();
}
{
}
}
public void run() {
new Loginmaster().setVisible(true);
}
});
}

}
Source code for Product Details page :-

import java.sql.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class Product extends javax.swing.JFrame {
public Product() {
initComponents();
}

jScrollPane1 = new javax.swing.JScrollPane();
jTextArea1 = new javax.swing.JTextArea();
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);

jLabel1.setText("PRODUCT DETAILS");

jLabel2.setText("PRODUCT ID :");

jLabel3.setText("PRODUCT NAME :");

jLabel4.setText("VERSION:");
jTextField1.addActionListener(new java.awt.event.ActionListener() {
jTextField1ActionPerformed(evt);
}
});
jTextField2.addActionListener(new java.awt.event.ActionListener() {
jTextField2ActionPerformed(evt);
}
});
jButton1.setFont(new java.awt.Font("Tahoma", 0, 12)); // NOI18N

jButton1.setText("Save");
}
});

jButton2.setText("Get Details");
}
});

jButton3.setText("Search");
}
});

}

}

try
{
Connection
String str = "select * from products where PRODUCTID= "+jTextField1.getText();
jTextArea1.setText("PRODUCTID \t PRODUCTNAME \t VERSION \n");
if(rs.next())
{
jTextField2.setText(rs.getString(2));
jButton1.setText("Update");
}
cn.close();
}
{
jLabel5.setText(ex.getMessage());
}
}

try
{
Connection
String PRODUCTID = jTextField1.getText();
String PRODUCT_NAME = jTextField2.getText();
String VERSION = jTextField3.getText();
if(jButton1.getText().equals("Save"))
{
String insert = "insert into products
values('"+PRODUCTID+"','"+PRODUCT_NAME+"','"+VERSION+"')";
if(row>0)
{
}
}
if((jButton1.getText().equals("Update")))
{
String str = "update products set
PRODUCT_NAME='"+PRODUCT_NAME+"',VERSION='"+VERSION+"' where
PRODUCTID='"+PRODUCTID+"'";
int row = stmt.executeUpdate(str);
if(row>0)
{
jLabel5.setText("Record has been Updated!!!");
}
}
}
{
}
}

try
{
Connection
String str = "select * from products";
jTextArea1.setText("PRODUCTID \t PRODUCT NAME \t VERSION\n");
while(rs.next())
{
jTextArea1.append(rs.getString(1)+ "\t" +rs.getString(2)+ "\t\t" +rs.getString(3)+ "\n");
}
cn.close();
}
{
}
}
static void main(String args[]) {
try {
break;
}
}
java.util.logging.Logger.getLogger(Product.class.getName()).log(java.util.logging.Level.SEVERE,
null, ex);
null, ex);
null, ex);
null, ex);
}
/* Create and display the form */

public void run() {
new Product().setVisible(true);
}
});
}

private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextArea jTextArea1;
}
Source code for Solution page : -
try
{
Connection
String str = "select * from SOLUTIONS where BUGId= "+jTextField1.getText();
jTextArea1.setText(" BUGId\t EXPERTID \t EXPERT \t SOLUTION \t SOLN DATE \n");
if(rs.next())
{
}
cn.close();
}
{
}
}

try
{
Connection
String str = "select * from SOLUTIONS";
jTextArea1.setText(" BUGId \t EXPERTID \t EXPERT \t SOLUTION \t SOLN DATE \n");
while(rs.next())
{
jTextArea1.append(rs.getString(1)+ "\t" +rs.getString(2)+ "\t" +rs.getString(3)+ "\t"
+rs.getString(4)+ "\t" +rs.getString(5)+ "\n");
}
cn.close();
}
{
}
}

try
{
Connection
String BUGId = jTextField1.getText();
String EXPERTID = jTextField2.getText();
String EXPERT = jTextField3.getText();
String SOLUTION = jTextField4.getText();
String SOLN_Date = jTextField5.getText();
if(jButton2.getText().equals("Save"))
{
String insert = "insert into SOLUTIONS
values('"+BUGId+"','"+EXPERTID+"','"+EXPERT+"','"+SOLUTION+"','"+SOLN_Date+"')";
if(row>0)
{
}
}
{
String str = "update SOLUTIONS set
EXPERTID='"+EXPERTID+"',EXPERT='"+EXPERT+"',SOLUTION='"+SOLUTION+"',SOLN_Date='"+SOLN_D
ate+"' where BUGId='"+BUGId+"'";
if(row>0)
{
}
}
}
{
}
}
public void run() {
new Solution().setVisible(true);
}
});
}

private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JTextArea jTextArea1;
}
Source code for Select Bug type page :-

try
{
Connection
String str = "select * from Bug1 where BUGId= "+jTextField1.getText();
if(rs.next())
{
// jTextField10.setText(rs.getString(10));
}
cn.close();
}
{
}
}
try
{
Connection
String BUGId = jTextField1.getText();
String AUTHORID = jTextField2.getText();
String AUTHOR = jTextField3.getText();
String PRODUCTID = jTextField4.getText();
String PRODUCTNAME = jTextField5.getText();
String ENV = jTextField6.getText();
String TYPE = jTextField7.getText();
String DESCRIPTION = jTextField8.getText();
String REP_DATE = jTextField9.getText();
String PRIORITY = jTextField10.getText();
String STATUS = jTextField11.getText();
// String ASSIGN_TO = jTextField12.getText();
if(jButton2.getText().equals("Submit"))
{
String insert = "insert into Bug1
values('"+BUGId+"','"+AUTHORID+"','"+AUTHOR+"','"+PRODUCTID+"','"+PRODUCTNAME+"','"+ENV+"
','"+TYPE+"','"+DESCRIPTION+"','"+REP_DATE+"','"+PRIORITY+"','"+STATUS+"')";
if(row>0)
{
}
// jTextField12.setText("");
}
{
String str = "update Bug1 set
AUTHORID='"+AUTHORID+"',AUTHOR='"+AUTHOR+"',PRODUCTID='"+PRODUCTID+"',PRODUCTAME=
'"+PRODUCTNAME+"',ENV='"+ENV+"',TYPE='"+TYPE+"',DESCRIPTION='"+DESCRIPTION+"',rep_date='
"+REP_DATE+"',PRIORITY='"+PRIORITY+"',STATUS='"+STATUS+"' where BUGId='"+BUGId+"'";
if(row>0)
{
// jButton2.setText("Submit");
}
jButton2.setText("Submit");
}
}
{
}
}
public static void main(String args[]) {
try {
break;
}
}
java.util.logging.Logger.getLogger(Bugtype.class.getName()).log(java.util.logging.Level.SEVERE, null,
ex);
ex);
ex);
ex);
}
public void run() {
new Bugtype().setVisible(true);
}
});
}
}

Report

Uploaded by

Copyright:

Available Formats

You might also like

Report

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Report

Uploaded by

Copyright:

Available Formats

A

BUG TRACKING SYSTEM –JAVA SE Desktop Application

Department of Computer Science & Engineering

Guru Gobind Singh Indraprastha University

I wish to express my sincere gratitude to MTA- NOIDA to provide me the opportunity to

Date: 25/10/2017 Jaspreet Singh

Some salient features are :-

-Identifying the bugs in the developed application.

Bottlenecks of the Existing System

Part of integrated project management systems

Distributed bug tracking

Bug tracking and test management

2) Java.lang Package :- The function of a java.lang.ClassLoader is to locate

3) Java Virtual Machine(JVMs) : - On platforms typically used for client

The JDBC API is comprised of two packages:

What can I build using JAVA SE?

Java SE is for developing desktop applications and it is the

Steps to make a JAR file are:

1. Right click on project and click“Refresh”.

Steps to make EXE file is:

3. After finishing installation,

b.) Under "Advanced" tab, click on environment variables.

This Software Requirements Specification (SRS) specifies the requirements of

4. 2.3.1 Hardware Requirements

Processor: Dual core or above.

Development Kit: JRE 1.8.0_91 and Java JDK 1.8.

Languages : Core Java

IDE : NetBeans 8.2

Platform : Any OS.

1.2.4 Assumptions and Dependencies:

Manage Dependencies carefully to keep you’re:

4.2.5 Overview of Data Requirements

The product is completely data oriented.

Application must respond within seconds if key is pressed or shortcuts are

This application has features of tracking bug management as well as and

Since it is a desktop application it is mandatory to maintain its database and

Training at Microsoft Associate experienced me with the training and startup

1. Balaguruswamy for java

1. Main User module which consists of : -

Username and password text field ,if u already have account

3. Now after clicking Select Product button window appears where

6. Contact button gives the contact details of the developer.

Source code for Menu page: -

jPanel1.setBackground(new java.awt.Color(180, 180, 240));

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

Souce code for Login page : -

jPanel1 = new javax.swing.JPanel();

// Administrator d = new Administrator();

// Variables declaration - do not modify

jPanel1 = new javax.swing.JPanel();

private void jTextField1ActionPerformed(java.awt.event.ActionEvent evt) {

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

// Variables declaration - do not modify

Source code for Product Details page :-

jPanel1 = new javax.swing.JPanel();

jLabel1.setFont(new java.awt.Font("Times New Roman", 1, 24)); // NOI18N

jLabel2.setFont(new java.awt.Font("Times New Roman", 1, 12)); // NOI18N

jLabel3.setFont(new java.awt.Font("Times New Roman", 1, 12)); // NOI18N

jLabel4.setFont(new java.awt.Font("Times New Roman", 1, 12)); // NOI18N