Main Con Hss
Main Con Hss
Main Con Hss
INTRODUCTION
1.1 ABOUT THE ORGANIZATION
Beyond their core services, Spell Global Services is dedicated to leveraging advanced
technologies and innovative methods to enhance their offerings. Their expertise in
printing and reproduction ensures precise and high-quality outputs, which are essential
for businesses that require reliable and visually appealing printed materials. The
company's commitment to sustainability is evident in their materials recovery services,
which focus on recycling and efficient waste management practices. By combining their
design prowess with robust manufacturing capabilities and eco-friendly initiatives, Spell
Global Services not only meets the diverse needs of their clients but also contributes to
environmental conservation, positioning themselves as a forward-thinking and
responsible company in the industry.
1
2.2 ABOUT THE PROJECT
Nowadays, Helpdesk ticketing system is the most widely used tool for solving the
day-to-day queries in the organization. Previously, the conventional system such as e-
mail were used for solving the queries which was much time consuming & irrelevant.
The Help Desk Ticketing system has shown 25% reduction in costs, 40% increase in
users’ satisfaction & 31% increase in productivity. This ticketing system has proved
many organizations to solve the queries in a efficient & effective manner thereby giving
solution to queries as soon as possible in mean time.
The time of ticket creation till the time of solving the ticket consumes a lot of time for
solving any level of ticket/query. The timeline for solution of queries can be reduced by
proposing three tier architecture for helpdesk ticketing system which is divided as User,
IT coordinator & Engineers. This proposed system will result in getting the tickets
resolution in the meanest time.
The Help Desk Ticketing System is designed to streamline the management of IT support
requests within an organization, providing a centralized platform for users to report issues
and track their resolution status. The system enhances communication between end-users
and IT staff, ensuring that all support requests are handled efficiently and effectively. By
consolidating all tickets in one place, the system aims to reduce response times and
improve overall IT support operations, leading to increased user satisfaction and
productivity.
Key features of the system include ticket creation and management, user and role
management, department management, and comprehensive reporting and analytics. Users
can easily submit tickets with detailed descriptions, and IT staff can update the status of
these tickets as they work on resolving the issues. Administrators have the ability to
configure the system, manage user roles, and generate reports to monitor performance
and identify areas for improvement. The system is designed to be intuitive and user-
friendly, ensuring that all users can navigate and utilize its features with ease.
2
The system's technical architecture is built to ensure security, scalability, and
compatibility. Robust security measures protect sensitive data from unauthorized access,
while the system's scalable design allows it to handle an increasing number of users and
tickets without compromising performance. Additionally, the system is compatible with
various devices and operating systems, providing users with the flexibility to access the
platform from different environments. Future enhancements, such as AI integration and
mobile access, will further improve the system's functionality and user experience,
making it an indispensable tool for managing IT support within any organization.
3
CHAPTER 2
PROBLEM DEFINITION AND FEASIBILITY ANALYSIS
Help Desk System’s primary objective is to give solution to the tickets raised at
the possible earliest time. In the traditional system of Help Desk Ticketing system when
the user raises any query for the solution, the query gets pushed into the ticketing system
where the engineers can view the tickets raised. This consumes a lot of time for the
engineers as engineers are unaware of the problem & nature of the query when they open
any ticket. The solution to this traditional system is three tier architecture mainly divided
as User, IT coordinator & engineer. When the user raises ticket for the query for the
problem arising, firstly, the ticket gets reflected onto the portal of IT coordinator. The IT
coordinators work is to assign the query to the engineer according to the nature of the
problem arising. The three-tier architecture will provide an effective solution to the
queries not getting the delays in giving solutions while giving resolutions as soon as
possible.
The Helpdesk systems are widely used by the organizations to manage support
requests from the user. When the user creates a query with the problem definition, the
tickets gets logged into the system. The tickets logged are reflected directly to the support
engineer’s management system, which are then opened/viewed for the resolution of the
ticket. The status of the ticket changes to “Opened” so as to start work on the query. After
resolution of the ticket by giving solution to the query, the ticket is then closed & in turn
notified to the user as closed. The helpdesk systems are typically based on the web based
interfaces where users can log the tickets for the queries. i.e., raise the tickets, which gets
routed to the support engineers for providing a solution to the queries. The system tracks
the ticket lifecycle which can be easily viewed by the by the user such as updates to the
ticket, which also notifies the user whether the issue has been resolved or not. Some of
the popular helpdesk ticketing systems include Zendesk, Freshdesk & Servicenow. The
4
Helpdesk ticketing system has become an essential part of the organizations. It provides
hassle free experiences to the users within the least amount of time while solving queries
at the earliest.
DRAWBACKS:
5
infections, phishing attacks, or unauthorized access, pose significant risks and are often
due to lack of antivirus software or outdated security measures. Providing detailed
information in help desk tickets, such as specific error messages, steps already taken to
resolve the issue, and any relevant screenshots, can greatly assist the IT team in
diagnosing and resolving these problems efficiently.
This proposed system will help users to easily generate tickets for the queries
while giving desired solution for the users. The solution to ticket raised will be given by
the specialized engineer according to the nature of the query. It will not only provide a
solution to the query but also reduce the timeline for resolving the queries for the better
working. When user generates a ticket for the query, the ticket will reflect into the
ticketing system of the IT coordinator by logging with his/her credentials. The tickets are
only visible to IT coordinator on the ticketing system unless & until it is assigned to the
engineer. IT coordinator then assigns the ticket to the engineer according to the nature of
the query. Also, it checks which engineer is specialized in solving these types of queries.
The ticket is then assigned to the engineer for the solution of the query with the given
timeline. The timeline given is based on the problem statement for which the query
should be resolved in given timeline only. Suppose, If the engineer is unable to solve the
query, then, the query gets passed on to the other engineer of the same specialization.
Other engineer of the same specialization takes down the work of solving the query
which is unresolved.
6
fees, implementation, and maintenance) against anticipated benefits like improved
productivity and reduced resolution times. Legal feasibility ensures compliance with data
protection laws and industry regulations, assessing data security measures and user
privacy protections.
Operational feasibility for an help desk ticketing system evaluates whether the
proposed system will effectively integrate with the organization's current operations and
improve efficiency. This involves examining how the new system will fit into existing
workflows and processes, ensuring it aligns with the daily activities of the IT help desk
and other related departments. Key considerations include the system's user-friendliness,
the ease of incorporating it into routine tasks, and its potential to streamline problem
resolution processes. Additionally, operational feasibility assesses the system's ability to
handle the volume and complexity of support tickets the organization typically
encounters, ensuring it can meet current and future demands without causing disruptions.
Another critical aspect of operational feasibility is evaluating the training and support
required for staff to use the new system effectively. This includes analyzing the learning
curve associated with the new ticketing system and determining the resources needed for
comprehensive training programs. Ensuring that staff can quickly adapt to the new
system is essential for minimizing downtime and maintaining productivity during the
transition. Furthermore, operational feasibility involves assessing the potential for
7
improved customer satisfaction through faster response times and more efficient issue
resolution. By thoroughly evaluating these factors, the organization can ensure that the
new IT help desk ticketing system will enhance operational efficiency and support long-
term goals.
Technical feasibility for an help desk ticketing system assesses whether the
organization's current technology infrastructure can support the new system. This
involves evaluating the compatibility of existing hardware, software, and network
components with the proposed ticketing solution. Key considerations include ensuring
that servers, workstations, and other devices meet the system's requirements and that the
network bandwidth can handle the additional load without performance degradation.
Additionally, the feasibility study should examine the scalability of the system to
accommodate future growth, ensuring it can integrate seamlessly with other tools and
platforms already in use, such as email systems, customer relationship management
(CRM) software, and remote support tools.
Another crucial aspect of technical feasibility is the system's reliability and security. This
includes assessing the robustness of the ticketing system against potential technical
failures, data breaches, and cyber threats. It is essential to ensure that the system has
adequate security measures, such as encryption, user authentication, and regular security
updates, to protect sensitive data. The analysis should also consider the ease of
maintenance and support, including the availability of technical support from the vendor
and the complexity of system upgrades and patches. By thoroughly evaluating these
technical aspects, the organization can determine whether the new ticketing system is
capable of operating effectively within its existing technical environment and maintaining
the desired level of performance and security.
8
Initial costs include software purchase or subscription fees, hardware upgrades if
necessary, and implementation expenses such as consulting and customization.
Additionally, there are ongoing costs to consider, such as maintenance, support, and
potential future upgrades. These costs must be weighed against the organization's budget
to ensure the investment is financially viable. A detailed cost-benefit analysis should be
conducted, considering both direct financial impacts and indirect benefits like improved
productivity and reduced downtime.
On the benefits side, economic feasibility assesses the potential financial gains from
improved efficiency and productivity. A well-implemented ticketing system can lead to
faster issue resolution, reducing the time employees spend on troubleshooting and
increasing overall productivity. This can translate into cost savings and a higher return on
investment. Moreover, better tracking and management of IT issues can prevent minor
problems from escalating into major disruptions, potentially saving significant repair and
recovery costs. By comparing these benefits against the initial and ongoing expenses, the
organization can determine whether the financial outlay for the new system is justified
and likely to result in a positive financial outcome.
Number of Tables: 4
Number of Database: 1
9
CHAPTER 3
Requirement analysis for an help desk ticketing system involves gathering and
documenting the needs and expectations of stakeholders to ensure the system meets
organizational goals and user needs. This process includes identifying functional and
non-functional requirements, engaging with stakeholders, and prioritizing the features
and capabilities needed for the system to be effective. Here’s an overview of the key
components involved in requirement analysis:
10
1. Ticket Management: The system must allow for the creation, tracking, and
resolution of support tickets. This includes features like ticket categorization,
prioritization, assignment, and status updates.
2. User Management: It should support user authentication and role-based access
control to ensure that users have appropriate access to features and data.
3. Knowledge Base: A repository for common issues and their resolutions, enabling
users and IT staff to find solutions quickly.
4. Reporting and Analytics: Tools to generate reports on ticket volume, response
times, resolution times, and other key performance indicators (KPIs) to help
manage and improve the support process.
5. Integration Capabilities: The ability to integrate with other systems and tools,
such as email, chat, CRM systems, and remote support tools.
3.2.1 PURPOSE
The purpose of an IT help desk ticketing system is to streamline and improve the
management of technical support requests within an organization. This system serves
multiple essential functions, including:
3.2.2 SCOPE
11
The scope of an help desk ticketing system encompasses a wide range of
functionalities and activities designed to manage and streamline IT support within an
organization. Below are the key components included in the scope:
1. Ticket Management:
2. User Management:
3. Communication Tools:
3.2.3 OVERVIEW
12
3.2.4 GENERAL DESCRIPTIONS
The system also features a knowledge base, offering a repository of solutions for
common issues, which empowers users to find answers independently and reduces the
volume of support requests. Robust reporting and analytics tools provide insights into
ticket volumes, response times, and resolution times, helping to identify trends and areas
for improvement. Integration capabilities with other IT systems, such as CRM and ERP,
enhance the overall functionality and streamline workflows.
The functions of an help desk ticketing system can be categorized into several key areas,
each serving to streamline and enhance the management of technical support requests.
These functions include:
13
Tickets are logged into the system with relevant information such as the
user's contact details, issue description, and priority level.
Priority levels are assigned to tickets to ensure that critical issues are
addressed promptly, while less urgent matters are handled accordingly.
IT staff can track the progress of each ticket, monitor its status, and update
relevant information as needed.
1. Technical Proficiency:
Users may vary in their technical knowledge and abilities. Some may be
experienced and capable of troubleshooting minor issues independently,
while others may require more guidance and support.
2. Communication Preferences:
14
Users may have different preferences for how they prefer to communicate
with the IT help desk, whether through email, phone calls, chat, or self-
service portals. Understanding these preferences helps tailor the system's
communication channels accordingly.
1. Budget Constraints:
2. Time Constraints:
15
Implementation Timeline: The project must be completed within a
specific timeframe, which can limit the scope of the system and the extent
of customizations and integrations.
3. Technical Constraints:
Functional requirements for an help desk ticketing system outline the specific
behaviors, functions, and capabilities that the system must possess to effectively manage
technical support requests. Here are the key functional requirements:
1. Ticket Management:
Ticket Tracking: The system tracks the status and progress of each ticket
from creation to resolution.
16
Ticket Categorization: Tickets can be categorized based on the type of
issue (e.g., software, hardware, network).
2. User Management:
3. Communication Tools:
17
1. Integration Challenges:
2. Performance Issues:
Scalability: As the number of users and tickets grows, the system must
scale effectively without performance degradation. This can be
challenging if the system is not designed for high scalability.
3. Security Concerns:
Data Protection: Ensuring that sensitive user data and support ticket
information are adequately protected against unauthorized access and
breaches.
1. Integration Challenges:
18
System Compatibility: Integrating the ticketing system with existing IT
infrastructure, such as CRM, ERP, and other enterprise systems, can be
complex and may require custom development.
2. Performance Issues:
Scalability: As the number of users and tickets grows, the system must
scale effectively without performance degradation. This can be
challenging if the system is not designed for high scalability.
3. Security Concerns:
Data Protection: Ensuring that sensitive user data and support ticket
information are adequately protected against unauthorized access and
breaches.
19
1. User Interface Design
Requirement: The system must have an intuitive, user-friendly interface.
2. Accessibility
Requirement: The interface must be accessible to all users, including those with
disabilities.
20
support the software.
Server: If the system is going to be used by multiple users, a server may be necessary to
manage the data and allow for simultaneous access to the software.
Networking Equipment: If the system is going to be used by multiple users, networking
equipment such as routers and switches may be necessary to connect the computers and
the server.
Storage Devices: Adequate storage devices such as hard drives or solid-state drives
(SSDs) are required to store the data generated by the system.
Backup Devices: It is important to have backup devices such as external hard drives or
cloud storage to ensure that the data is secure and can be recovered in case of a system
failure.
It is important to note that these hardware requirements are not exhaustive and
may vary depending on the specific needs of the system.
The software requirements document is the specification of the system. It should include
both a definition and a specification of requirements. It is a set of what the system should
do rather than how it should do it. The software requirements provide a basis for creating
the software requirements specification.
21
In addition to the key functional requirements previously mentioned, here are
additional functional requirements that an IT help desk ticketing system should meet to
ensure comprehensive functionality and optimal performance:
1. Workflow Automation
Requirement: Automate routine processes to enhance efficiency.
SLA Definition: Define SLAs with specific response and resolution time targets.
SLA Tracking: Track SLA compliance and notify IT staff of impending
breaches.
SLA Reporting: Generate reports on SLA performance to identify areas for
improvement.
3.2.7.1 SECURITY
Security is a critical aspect of any software solution, especially for a Helpdesk
ticketing system that deals with sensitive customer and business data. Here are some
security measures that a Helpdesk ticketing system have:
Authentication and Authorization: The system should require strong authentication to
ensure that only authorized users can access it. Multi-factor authentication is a good
practice to enhance security.
Access control: The system should have access controls in place to restrict access to
22
sensitive data and functionalities. Access should be granted based on the principle of least
privilege.
Regular security updates: The system should be regularly updated to ensure that
security patches are installed to address known vulnerabilities.
3.2.7.2 RELIABILITY
Reliability is crucial for any software solution, especially for a Helpdesk ticketing
system where any disruption can result in significant consequences. Here are some
measures that a Helpdesk ticketing system should have to ensure reliability:
Fault-tolerance: The system should have redundancy and failover mechanisms to ensure
that critical functionalities remain available in the event of hardware or software failure.
Scalability: The system should be able to handle increasing volumes of data and users as
the users grows without impacting the system's performance.
Regular backups: The system should have regular backups of data and configurations to
ensure that data can be restored in the event of a system failure or other disaster.
3.2.7.3 MAINTIANABILITY
23
3.2.7.3 USABILITY
Usability is a quality attribute that assesses how easy user interfaces are to use.
The word usability also refers to methods for improving ease of use during the design
process. On the testing usability is a necessary condition for survival. Website design can
be opened in any of the devices like PC and Laptops because the helpdesk ticketing
system was designed only for this company.
Intuitive Onboarding: Ensure a user-friendly and intuitive onboarding process for
donors, allowing them to easily register, understand system functionalities, and
efficiently list surplus food items.
Dashboard Clarity: Design a clear and concise donor dashboard that provides real-time
insights into donation status, pickup schedules, and overall engagement metrics.
User-Friendly Request Interface: Create a straightforward and visually appealing
interface for submitting food requests, guiding users through the process with clear
instructions.
Transparent Prioritization: Communicate the prioritization algorithm transparently to
users, ensuring they understand how the system determines the urgency and relevance of
their requests.
Automated Confirmation: Implement an automated confirmation system to
acknowledge users when their requested food items are available, enhancing
communication and user satisfaction.
24
CHAPTER 4
SYSTEM ANALYSIS
4.1 INTRODUCTION
26
Fig 4.1: Use Case Diagram
27
Fig 4.2: Admin Use Case Diagram
28
4.3 SEQUENCE DIAGRAM
Sequence diagrams describe how and in what order the objects in a system
function. These diagrams are widely used by businessmen and software developers to
document and understand requirements for new and existing systems.
29
Fig 4.4: ACTIVITY DIAGRAM
30
4.5 CLASS DIAGRAM
31
CHAPTER 5
SYSTEM DESIGN
5.1 INTRODUCTION
The system design phase translates the requirements gathered during the analysis phase
into a detailed blueprint that guides the development of the help desk ticketing system.
By defining the architecture, database schema, user interfaces, application logic,
integrations, and security measures, the design ensures that the final system will be
robust, scalable, and secure, meeting the needs of all stakeholders.
32
Fig 5.2: Architectural design
Data design is a crucial aspect of system design that involves defining the
structure, organization, and storage of data to ensure efficient data management, retrieval,
and integrity. For an IT help desk ticketing system, the data design phase includes
creating a detailed data model, defining database schemas, establishing relationships
between data entities, and ensuring data normalization and integrity.
5.4 ER DIAGRAM
33
the ER diagram for an IT Help Desk Ticketing System, which includes entities such as
Admin, User, Department, Ticket, SLA, and Action
34
The issue of usability is an important issue that must be addressed during the design
of the user interface. Though the system is not intensively used, it is still important
to try to reduce the time it takes to carry out a task. While it is perceivable that
cutting the time it takes to carry out a task by fractions of a second may save
certain companies, employing hundreds of people carrying out the same task, a lot
of money, it simply won’t be the case at spell global services. More importantly
for the company is the need for the interface to be designed so that learning the
system is simple and carrying out day-to-day tasks is more efficient than the
current system. Many web based systems fail to combat basic usability issues and
end up being less efficient than their predecessors.
35
CHAPTER 6
IMPLEMENTATION
INTRODUCTION
LIST OF MODULES
Admin
Dashboard
Sub-Admin
department
Tickets
Reports
View ticket
User
36
ADMIN
DASHBOARD
In this section, admin can briefly view total sub-admin, all tickets received, Total New
Tickets, Total In-Process Tickets, Total On-Hold Tickets, Total Tickets Resolved, Total
department.
37
Fig 6.2: Dashboard
SUB-ADMIN
38
DEPARTMENT
TICKETS:
In this section, admin can manage tickets and resolved user’s queries. This module allows
users to submit new tickets detailing their IT issues, track the status of their tickets, and
receive updates. IT staff can access and update these tickets, assign priority levels,
provide resolutions, and close tickets upon completion. Administrators can oversee all
tickets, ensuring efficient handling and timely resolution of support requests, thereby
maintaining smooth IT operations and enhancing user satisfaction.
39
Fig 6.5: Tickets
REPORTS:
In this section, admin can view the and check tickets details in a particular period. It
includes features for creating reports on ticket resolution times, ticket volumes by
department, and IT staff performance metrics. The module offers real-time dashboards,
customizable report templates, and options to export reports in various formats such as
PDF and Excel, enabling data-driven decision-making and effective monitoring of IT
support operations.
40
Fig 6.6: Reports
View ticket:
Users can view and update the ticket. The View Ticket module allows users, IT staff, and
administrators to access detailed information about individual support tickets within the
IT Help Desk Ticketing System. Users can view the status, priority, description, and
updates related to their submitted tickets, enabling them to track the progress of their
issues. IT staff can access all assigned tickets, seeing specific details needed for
troubleshooting and resolution. Administrators can view any ticket in the system to
monitor the support process, reassign tickets, and ensure timely resolution.
41
Fig 6.7: View ticket
USERS:
42
Fig 6.8: Users
43
CHAPTER 7
TESTING
7.1 INTRODUCTION
Testing is a critical phase in the development lifecycle of the Help Desk Ticketing
System, ensuring the system's functionality, reliability, and performance meet the
specified requirements. It involves various testing methods such as unit testing,
integration testing, system testing, and user acceptance testing to identify and rectify
defects, validate that the system performs as expected under different conditions, and
confirm that the end-user experience aligns with the intended use. Comprehensive testing
helps to minimize risks, enhance the system's robustness, and ensure a smooth
deployment and operation in a live environment.
A Test Plan refers to a detailed document that catalogs the test strategy,
objectives, schedule, estimations, deadlines, and the resources required for completing
that particular project. A Software testing strategy provides a road map for the software
developer. Testing is set of activity that can be planned in advance and connected
systematically.
Introduction: This section provides an overview of the system and the purpose of the
test plan, including the testing objectives, scope, and timeline.
Test objectives: This section outlines the goals and objectives of the testing effort,
including what the testing should achieve and what the testers are looking for.
Testing scope: This section defines the scope of the testing effort, including what areas
of the system will be tested, what functionalities will be tested, and what testing methods
will be used.
Testing approach: This section describes the testing approach, including the types of
testing that will be performed, the testing tools and techniques that will be used, and the
44
roles and responsibilities of the testing team.
Test environment: This section outlines the hardware, software, and other resources that
will be needed to conduct the testing, including the testing environment, test data, and
test cases
45
Fig 7.3 Unit testing
Integration points: The first step in integration testing is to identify the integration
points between the different modules or components of the system. This could include
interfaces, APIs, or data exchanges between modules.
Test cases: For each integration point, test cases should be developed that cover all
possible scenarios and inputs. This may include testing data flows, error handling, and
system behavior under different conditions.
Test environment: A test environment should be set up that mimics the production
46
environment, including all necessary hardware, software, and data.
Test execution: The actual testing involves running the integration tests in the defined
test environment. This may include manual or automated testing, and results should be
recorded and analyzed.
Test coverage: It is important to ensure that all integration points are tested, and that
each test case covers all possible inputs and outputs.
The result of system testing is the observed behaviour of a component or a system when
it is tested. System Testing is carried out on the whole system in the context of either
system requirement specifications or functional requirement specifications or in the
context of both. System testing tests the design and behaviour of the system and also the
expectations of the customer. It is performed to test the system beyond the bounds
mentioned in the software requirements specification (SRS). System Testing is basically
performed by a testing team that is independent of the development team that helps to test
the quality of the system impartial.
Validation testing is a type of testing that focuses on verifying that the helpdesk
ticketing system meets the requirements and expectations of its users and stakeholders.
Here are the key elements of validation testing for a food distribution management
system:
Requirements: The first step in validation testing is to ensure that all requirements for
the system have been captured and documented. This includes both functional and non-
functional requirements.
Test cases: For each requirement, test cases should be developed that cover all possible
scenarios and inputs. This may include testing data flows, error handling, and system
behavior under different conditions.
Test environment: A test environment should be set up that mimics the production
environment, including all necessary hardware, software, and data.
Test execution: The actual testing involves running the validation tests in the defined
test environment. This may include manual or automated testing, and results should be
recorded and analyzed.
Test coverage: It is important to ensure that all requirements are tested, and that each test
case covers all possible inputs and outputs.
Test reporting: Test results should be recorded and reported, including any failures
or errors encountered during testing. These results can be used to identify and fix any
48
defects in the system.
49
Fig No 6.4: Validation testing for Admin
50
CHAPTER 8
CONCLUSION
In conclusion, the IT Help Desk Ticketing System is designed to streamline and
enhance the efficiency of managing support requests within an organization. Through
robust features such as user and ticket management, SLA enforcement, and
comprehensive reporting, the system ensures timely and effective resolution of issues.
Rigorous testing phases ensure that the system is reliable, secure, and performs optimally
under various conditions. By implementing this system, organizations can significantly
improve their IT support operations, leading to higher user satisfaction, better resource
management, and overall enhanced productivity.
FUTURE ENHANCEMENTS
Future enhancements for the IT Help Desk Ticketing System could focus on
several key areas to further improve its functionality, user experience, and adaptability to
evolving technological trends. Potential enhancements include:
Mobile Application: Develop a mobile app version of the system to provide on-the-go
access for users and IT staff, enabling them to manage tickets, view reports, and receive
notifications from their smartphones or tablets.
51
Enhanced User Interface: Continuously improve the user interface for better usability
and accessibility, incorporating user feedback to streamline navigation and enhance the
overall user experience.
Integration with Other Systems: Expand integration capabilities with other enterprise
systems such as customer relationship management (CRM), enterprise resource planning
(ERP), and third-party communication tools to create a more cohesive IT ecosystem.
BIBLIOGRAPHY
52
1. Arora, A., & Singh, P. (2018). "Implementing IT Help Desk Systems: A
Comprehensive Guide". Springer Publishing.
This book provides an in-depth look at the design and implementation of
IT help desk systems, offering practical insights and case studies from
various organizations.
4. Basu, S., & Gupta, R. (2020). "AI and Machine Learning in IT Service
Management". Pearson.
5. IEEE Computer Society. (2021). "IEEE Standard for Software and Systems
Engineering—Software Testing". IEEE Std 829-2008.
APPENDIX A - SCREENSHOTS
53
A[1]: Admin Login
A[2]: Dashboard
54
A[3]: Add User
A[4]: Reports
55
A[5]: Department
56
APPENDIX B - TABLES
57
[T2]: Tickets Table
PRIMARY KEY:ticketid
58
T[3]: Department Table
PRIMARY KEY: id
59
DESCRIPTION: This table contains User information
60
include 'init.php';
if(!$users->isLoggedIn()) {
header("Location: login.php");
} else {
header("Location: ticket.php");
}
include('inc/header.php');
$user = $users->getUserInfo();
?>
<title>Helpdesk System with PHP & MySQL</title>
<script src="js/jquery.dataTables.min.js"></script>
<script src="js/dataTables.bootstrap.min.js"></script>
<link rel="stylesheet" href="css/dataTables.bootstrap.min.css" />
<script src="js/general.js"></script>
<script src="js/tickets.js"></script>
<link rel="stylesheet" href="css/style.css" />
<?php include('inc/container.php');?>
<div class="container">
<div class="row home-sections">
<h2>Helpdesk System</h2>
<?php include('menus.php'); ?>
</div>
<div class="">
<p>View and manage tickets that may have responses from support
team.</p>
<div class="panel-heading">
<div class="row">
<div class="col-md-10">
<h3 class="panel-title"></h3>
</div>
61
<div class="col-md-2" align="right">
<button type="button" name="add"
id="createTicket" class="btn btn-success btn-xs">Create Ticket</button>
</div>
</div>
</div>
<table id="listTickets" class="table table-bordered table-striped">
<thead>
<tr>
<th>S/N</th>
<th>Ticket ID</th>
<th>Subject</th>
<th>Department</th>
<th>Created By</th>
<th>Created</th>
<th>Status</th>
<th></th>
<th></th>
<th></th>
</tr>
</thead>
</table>
</div>
<?php include('add_ticket_model.php'); ?>
</div>
<?php include('inc/footer.php');?>
<?php
62
private $dbConnect = false;
public function __construct(){
$this->dbConnect = $this->dbConnect();
}
public function listDepartment(){
if(!empty($_POST["search"]["value"])){
$sqlQuery .= ' (id LIKE "%'.$_POST["search"]["value"].'%"
';
$sqlQuery .= ' OR name LIKE "%'.$_POST["search"]
["value"].'%" ';
$sqlQuery .= ' OR status LIKE "%'.$_POST["search"]
["value"].'%" ';
}
if(!empty($_POST["order"])){
$sqlQuery .= ' ORDER BY '.$_POST['order']['0']['column'].'
'.$_POST['order']['0']['dir'].' ';
} else {
$sqlQuery .= ' ORDER BY id DESC ';
}
if($_POST["length"] != -1){
$sqlQuery .= ' LIMIT ' . $_POST['start'] . ', ' .
$_POST['length'];
}
63
$departmentData = array();
while( $department = mysqli_fetch_assoc($result) ) {
$departmentRows = array();
$status = '';
if($department['status'] == 1) {
$status = '<span class="label label-
success">Enabled</span>';
} else if($department['status'] == 0) {
$status = '<span class="label label-
danger">Disabled</span>';
}
$departmentRows[] = $department['id'];
$departmentRows[] = $department['name'];
$departmentRows[] = $status;
64
}
mysqli_query($this->dbConnect, $queryInsert);
}
}
65
SET name = '".$this->department."', status = '".$this-
>status."'
WHERE id = '".$this->departmentId."'";
mysqli_query($this->dbConnect, $queryUpdate);
}
}
mysqli_query($this->dbConnect, $queryUpdate);
}
}
}
<?php
66
if(!isset($_SESSION["admin"])) {
$sqlWhere .= " WHERE t.user = '".$_SESSION["userid"]."'
";
if(!empty($_POST["search"]["value"])){
$sqlWhere .= " and ";
}
} else if(isset($_SESSION["admin"]) && !
empty($_POST["search"]["value"])) {
$sqlWhere .= " WHERE ";
}
$time = new time;
$sqlQuery = "SELECT t.id, t.uniqid, t.title, t.init_msg as message,
t.date, t.last_reply, t.resolved, u.name as creater, d.name as department,
u.user_type, t.user, t.user_read, t.admin_read
FROM hd_tickets t
LEFT JOIN hd_users u ON t.user = u.id
LEFT JOIN hd_departments d ON t.department = d.id
$sqlWhere ";
if(!empty($_POST["search"]["value"])){
$sqlQuery .= ' (uniqid LIKE "%'.$_POST["search"]
["value"].'%" ';
$sqlQuery .= ' OR title LIKE "%'.$_POST["search"]
["value"].'%" ';
$sqlQuery .= ' OR resolved LIKE "%'.$_POST["search"]
["value"].'%" ';
$sqlQuery .= ' OR last_reply LIKE "%'.$_POST["search"]
["value"].'%") ';
}
if(!empty($_POST["order"])){
$sqlQuery .= 'ORDER BY '.$_POST['order']['0']['column'].'
'.$_POST['order']['0']['dir'].' ';
67
} else {
$sqlQuery .= 'ORDER BY t.id DESC ';
}
if($_POST["length"] != -1){
$sqlQuery .= 'LIMIT ' . $_POST['start'] . ', ' .
$_POST['length'];
}
$result = mysqli_query($this->dbConnect, $sqlQuery);
$numRows = mysqli_num_rows($result);
$ticketData = array();
while( $ticket = mysqli_fetch_assoc($result) ) {
$ticketRows = array();
$status = '';
if($ticket['resolved'] == 0) {
$status = '<span class="label label-
success">Open</span>';
} else if($ticket['resolved'] == 1) {
$status = '<span class="label label-
danger">Closed</span>';
}
$title = $ticket['title'];
if((isset($_SESSION["admin"]) && !$ticket['admin_read']
&& $ticket['last_reply'] != $_SESSION["userid"]) || (!isset($_SESSION["admin"])
&& !$ticket['user_read'] && $ticket['last_reply'] != $ticket['user'])) {
$title = $this->getRepliedTitle($ticket['title']);
}
$disbaled = '';
if(!isset($_SESSION["admin"])) {
$disbaled = 'disabled';
}
68
$ticketRows[] = $ticket['id'];
$ticketRows[] = $ticket['uniqid'];
$ticketRows[] = $title;
$ticketRows[] = $ticket['department'];
$ticketRows[] = $ticket['creater'];
$ticketRows[] = $time->ago($ticket['date']);
$ticketRows[] = $status;
$ticketRows[] = '<a href="view_ticket.php?id='.
$ticket["uniqid"].'" class="btn btn-success btn-xs update">View Ticket</a>';
$ticketRows[] = '<button type="button" name="update"
id="'.$ticket["id"].'" class="btn btn-warning btn-xs update"
'.$disbaled.'>Edit</button>';
$ticketRows[] = '<button type="button" name="delete"
id="'.$ticket["id"].'" class="btn btn-danger btn-xs delete"
'.$disbaled.'>Close</button>';
$ticketData[] = $ticketRows;
}
$output = array(
"draw" =>
intval($_POST["draw"]),
"recordsTotal" => $numRows,
"recordsFiltered" => $numRows,
"data" => $ticketData
);
echo json_encode($output);
}
public function getRepliedTitle($title) {
$title = $title.'<span class="answered">Answered</span>';
return $title;
}
public function createTicket() {
69
if(!empty($_POST['subject']) && !empty($_POST['message'])) {
$date = new DateTime();
$date = $date->getTimestamp();
$uniqid = uniqid();
$message = strip_tags($_POST['subject']);
$queryInsert = "INSERT INTO ".$this->ticketTable."
(uniqid, user, title, init_msg, department, date, last_reply, user_read, admin_read,
resolved)
VALUES('".$uniqid."', '".$_SESSION["userid"]."', '".
$_POST['subject']."', '".$message."', '".$_POST['department']."', '".$date."', '".
$_SESSION["userid"]."', 0, 0, '".$_POST['status']."')";
mysqli_query($this->dbConnect, $queryInsert);
echo 'success ' . $uniqid;
} else {
echo '<div class="alert error">Please fill in all fields.</div>';
}
}
public function getTicketDetails(){
if($_POST['ticketId']) {
$sqlQuery = "
SELECT * FROM ".$this->ticketTable."
WHERE id = '".$_POST["ticketId"]."'";
$result = mysqli_query($this->dbConnect, $sqlQuery);
$row = mysqli_fetch_array($result, MYSQLI_ASSOC);
echo json_encode($row);
}
}
public function updateTicket() {
if($_POST['ticketId']) {
$updateQuery = "UPDATE ".$this->ticketTable."
SET title = '".$_POST["subject"]."', department = '".
70
$_POST["department"]."', init_msg = '".$_POST["message"]."', resolved = '".
$_POST["status"]."'
WHERE id ='".$_POST["ticketId"]."'";
$isUpdated = mysqli_query($this->dbConnect,
$updateQuery);
}
}
public function closeTicket(){
if($_POST["ticketId"]) {
$sqlDelete = "UPDATE ".$this->ticketTable."
SET resolved = '1'
WHERE id = '".$_POST["ticketId"]."'";
mysqli_query($this->dbConnect, $sqlDelete);
}
}
public function getDepartments() {
$sqlQuery = "SELECT * FROM ".$this->departmentsTable;
$result = mysqli_query($this->dbConnect, $sqlQuery);
while($department = mysqli_fetch_assoc($result) ) {
echo '<option value="' . $department['id'] . '">' . $department['name'] .
'</option>';
}
}
public function ticketInfo($id) {
$sqlQuery = "SELECT t.id, t.uniqid, t.title, t.user, t.init_msg as
message, t.date, t.last_reply, t.resolved, u.name as creater, d.name as department
FROM ".$this->ticketTable." t
LEFT JOIN hd_users u ON t.user = u.id
LEFT JOIN hd_departments d ON t.department = d.id
WHERE t.uniqid = '".$id."'";
$result = mysqli_query($this->dbConnect, $sqlQuery);
71
$tickets = mysqli_fetch_assoc($result);
return $tickets;
}
public function saveTicketReplies () {
if($_POST['message']) {
$date = new DateTime();
$date = $date->getTimestamp();
$queryInsert = "INSERT INTO ".$this-
>ticketRepliesTable." (user, text, ticket_id, date)
VALUES('".$_SESSION["userid"]."', '".
$_POST['message']."', '".$_POST['ticketId']."', '".$date."')";
mysqli_query($this->dbConnect, $queryInsert);
mysqli_query($this->dbConnect, $updateTicket);
}
}
public function getTicketReplies($id) {
$sqlQuery = "SELECT r.id, r.text as message, r.date, u.name as
creater, d.name as department, u.user_type
FROM ".$this->ticketRepliesTable." r
LEFT JOIN ".$this->ticketTable." t ON r.ticket_id = t.id
LEFT JOIN hd_users u ON r.user = u.id
LEFT JOIN hd_departments d ON t.department = d.id
WHERE r.ticket_id = '".$id."'";
$result = mysqli_query($this->dbConnect, $sqlQuery);
$data= array();
72
while ($row = mysqli_fetch_array($result, MYSQLI_ASSOC)) {
$data[]=$row;
}
return $data;
}
public function updateTicketReadStatus($ticketId) {
$updateField = '';
if(isset($_SESSION["admin"])) {
$updateField = "admin_read = '1'";
} else {
$updateField = "user_read = '1'";
}
$updateTicket = "UPDATE ".$this->ticketTable."
SET $updateField
WHERE id = '".$ticketId."'";
mysqli_query($this->dbConnect, $updateTicket);
}
}
APPENDIX D - TECHNOLOGY/SOFTWARE
INTRODUCTION TO PHP
73
development ever since. The main implementation of PHP is now produced by The PHP
Group and serves as the de facto standard for PHP as there is no formal
specification .PHP is free software released under the PHP License, which is
incompatible with the GNU General Public License (GPL) because of restrictions on the
use of the term PHP.PHP has evolved to include a command line interface capability and
can also be used in standalone graphical applications.
USAGE
HTML
HTML, which stands for Hyper Text Markup Language, is the predominant
markup language for web pages. It provides a means to create structured documents by
denoting structural semantics for text such as headings, paragraphs, lists etc as well as for
links, quotes, and other items. It allows images and objects to be embedded and can be
used to create interactive forms. It is written in the form of HTML elements consisting of
74
"tags" surrounded by angle brackets within the web page content. It can include or can
load scripts in languages such as JavaScript which affect the behavior of HTML
processors like Web browsers; and Cascading Style Sheets (CSS) to define the
appearance and layout of text and other material. The W3C, maintainer of both HTML
and CSS standards, encourages the use of CSS over explicit presentational markup.
Hyper Text Markup Language (HTML) is the encoding scheme used to create and format
a web document. A user need not be an expert programmer to make use of HTML for
creating hypertext documents that can be put on the internet.
JAVASCRIPT
USAGE
MYSQL
75
There are a large number of database management systems currently available,
some commercial and some free. Some of them: Oracle, Microsoft Access, MySQL and
Postgre SQL.
ABBREVATION DESCRIPTION
UI User Interface
76
API Application Programming Interface
VS Visual Studio
ER Entity Relationship
77