IT Asset Management System

IT Asset Management System

Project Report

Guided By, Prepared By,

Abdul Wadhood Rehman Shiraz Rehman K K P

1
 IT Asset Management System

Executive Summary:
The IT Asset Management System (ITAMS) is a centralized platform designed to
streamline the tracking, monitoring, and management of IT assets within an organization.
By automating routine tasks such as asset tracking, maintenance scheduling, and license
renewals, the system significantly improves operational efficiency and reduces costs. The
ITAMS provides real-time visibility into asset health and utilization, enabling better
decision-making and resource allocation.
Key features of the system include a comprehensive asset inventory, lifecycle tracking,
automated reminders, and customizable reports. The system is built using modern
technologies such as Spring Boot, MySQL, and Thyme leaf, ensuring scalability and
maintainability.
The ITAMS addresses the challenges of manual asset tracking, such as lost equipment,
wasted resources, and compliance risks. By implementing this system, organizations can
enhance their IT governance, improve security, and achieve long-term cost savings. This
project demonstrates the successful application of software engineering principles to
solve real-world problems in IT asset management.

2
 IT Asset Management System

Introduction:
This project aims to develop an IT Asset Management System (ITAMS) to efficiently track,
monitor, and manage all IT resources within an organization. The ITAMS will boost
efficiency, cut costs, and improve IT governance.
The primary objective of the ITAMS is to create a centralized database that records
detailed information on all IT assets, including hardware such as computers, servers, and
networking equipment, as well as software licenses and service agreements. By
maintaining an up-to-date inventory, organizations can ensure optimal utilization of their
IT resources, minimize redundancies, and make informed decisions regarding asset
procurement and retirement.
One of the key features of the ITAMS will be its ability to automate routine tasks such as
asset tracking, maintenance scheduling, and compliance reporting. This will significantly
reduce the manual effort required by IT staff, allowing them to focus on more strategic
initiatives. Additionally, the system will provide real-time insights into asset performance
and health, enabling proactive maintenance and reducing downtime.
The ITAMS will also enhance cost management by providing visibility into the total cost of
ownership for each asset. By analysing historical data and identifying trends,
organizations can forecast future expenses and allocate budgets more effectively.
Furthermore, improved oversight of software licenses will help prevent over-purchasing
and ensure compliance with vendor agreements, reducing the risk of costly fines and
legal issues.
In conclusion, implementing an IT Asset Management System will transform how
organizations manage their IT resources. With streamlined processes, enhanced visibility,
and better control over assets, the ITAMS will contribute to greater operational efficiency,
cost savings, and robust IT governance.

3
 IT Asset Management System

Problem Statement:
Manual tracking of IT assets is a significant challenge for organizations, as it is time-
consuming, prone to errors, and lacks real-time data on asset health and utilization. This
inefficiency leads to several critical issues that hinder productivity, increase costs, and
create compliance risks.
1. Loss or Misplaced Equipment: Without a centralized system, organizations
struggle to locate IT assets such as laptops, printers, or servers. Misplaced
equipment disrupts workflows and often results in unnecessary replacement
costs.
2. Wasted Resources: Manual tracking makes it difficult to monitor asset utilization,
leading to underutilized or outdated assets that continue to incur maintenance
and licensing costs. This waste of resources impacts the organization’s financial
health.
3. Budgeting Challenges: The absence of accurate and up-to-date data on asset
lifecycle and utilization makes it difficult to plan for hardware and software
upgrades. This often leads to unexpected expenses, straining budgets and
disrupting financial planning.
4. Compliance Risks: Manual systems fail to provide the visibility needed to ensure
compliance with software licensing agreements and security protocols. Non-
compliance can result in legal penalties, security vulnerabilities, and reputational
damage.
5. Lack of Real-Time Insights: Without real-time data, organizations cannot
proactively address issues such as equipment failures or security breaches.
Delayed responses exacerbate operational inefficiencies and increase risks.
6. Scalability Issues: As organizations grow, the number of IT assets increases,
making manual tracking even more cumbersome and error prone. This lack of
scalability hinders organizational growth and efficiency.
These challenges highlight the urgent need for a centralized, automated solution to
streamline IT asset management. The proposed IT Asset Management System
(ITAMS) addresses these issues by providing real-time visibility into asset health and
utilization, automating routine tasks, and ensuring compliance with licensing and
security protocols. By implementing the ITAMS, organizations can reduce costs, improve
efficiency, and enhance overall IT governance.

4
 IT Asset Management System

Project Objectives:
The primary objective of this project is to develop a centralized IT Asset Management
System (ITAMS) that addresses the inefficiencies of manual tracking and provides a
robust solution for managing IT resources. The ITAMS will streamline the tracking,
monitoring, and management of all IT assets, ensuring improved efficiency, reduced
costs, and enhanced IT governance. The specific objectives of the system are as follows:
Create a Comprehensive Inventory of All IT Assets:
The ITAMS will maintain a detailed and centralized inventory of all IT assets, including
hardware (e.g., laptops, desktops, servers), software licenses, and peripherals. This
inventory will provide a single source of truth for asset information, such as model
names, serial numbers, purchase dates, and assigned users.
Track Asset Lifecycle from Acquisition to Disposal:
The system will track the entire lifecycle of IT assets, from procurement and deployment
to maintenance and eventual disposal. This will enable organizations to make informed
decisions about asset upgrades, replacements, and retirements.
Automate Routine Tasks:
The ITAMS will automate time-consuming tasks such as asset tracking, license renewals,
and maintenance scheduling. Automation will reduce manual effort, minimize errors, and
ensure timely actions, such as renewing software licenses or scheduling equipment
maintenance.
Generate Reports on Asset Utilization, Performance, and Upcoming Renewals:
The system will provide customizable reports on asset utilization, performance metrics,
and upcoming renewals. These reports will help organizations optimize resource
allocation, plan budgets, and avoid unexpected expenses.
Enhance IT Security Through Improved Asset Visibility and Control:
By providing real-time visibility into IT assets, the ITAMS will enhance security by ensuring
compliance with licensing agreements and identifying vulnerabilities. Improved control
over assets will reduce the risk of unauthorized access or misuse.
In summary, the ITAMS aims to transform IT asset management by centralizing data,
automating processes, and providing actionable insights. This will enable organizations
to operate more efficiently, reduce costs, and maintain a strong IT governance
framework.

5
 IT Asset Management System

Target Users:
The IT Asset Management System (ITAMS) is designed to cater to a diverse group of users
within an organization, each with specific roles and responsibilities related to IT asset
management. The primary target users include:
1. IT Department Personnel (IT Administrators and Support Staff):
IT administrators and support staff are the primary users of the ITAMS. They are
responsible for managing the day-to-day operations of IT assets, including
procurement, deployment, maintenance, and disposal. The system will provide
them with tools to track asset locations, monitor health and utilization, schedule
maintenance, and ensure compliance with licensing and security protocols. By
automating routine tasks, the ITAMS will reduce their workload and minimize
errors, allowing them to focus on strategic initiatives.
2. Department Managers Responsible for IT Assets:
Department managers oversee the allocation and utilization of IT assets within
their teams. The ITAMS will enable them to view asset assignments, monitor usage
patterns, and identify underutilized or outdated resources. This visibility will help
managers optimize resource allocation, plan for upgrades, and ensure their teams
have the necessary tools to perform effectively.
3. Executives Requiring Insights into IT Resource Allocation:
Executives, such as CIOs and CFOs, need high-level insights into IT resource
allocation, costs, and performance to make informed decisions. The ITAMS will
provide customizable reports and dashboards that highlight key metrics, such as
asset utilization, lifecycle status, and upcoming renewals. These insights will
support strategic planning, budgeting, and ensuring alignment between IT
investments and organizational goals.
In summary, the ITAMS is designed to meet the needs of IT administrators, department
managers, and executives by providing tools and insights tailored to their roles. By
addressing the unique requirements of each user group, the system will enhance
efficiency, improve decision-making, and support the organization’s overall IT governance
framework.

6
 IT Asset Management System

Project Deliverables:
The IT Asset Management System (ITAMS) project will deliver a comprehensive and user-
centric solution to address the challenges of IT asset tracking and management. The key
deliverables are designed to ensure the system’s functionality, usability, and seamless
integration into the organization’s existing infrastructure. These deliverables include:
1. A Fully Functional IT Asset Management System with a User-Friendly
Interface:
The primary deliverable is a fully operational ITAMS that provides a centralized
platform for managing IT assets. The system will feature an intuitive and user-
friendly interface, enabling users to easily add, update, and track assets. Key
functionalities include asset lifecycle tracking, automated maintenance
scheduling, license renewal reminders, and real-time reporting. The interface will
be designed with simplicity and accessibility in mind, ensuring that all users, from
IT administrators to executives, can navigate the system effortlessly.
2. User Manuals and Training Materials:
To facilitate smooth adoption, the project will deliver comprehensive user
manuals and training materials. These resources will include detailed step-by-
step guides, video tutorials, and FAQs to help users understand the system’s
features and functionalities. Additionally, hands-on training sessions will be
conducted to ensure users are confident in using the system effectively.
3. Integration with Existing IT Infrastructure (if applicable):
If the organization has existing IT systems (e.g., Active Directory, helpdesk
software), the ITAMS will be integrated with these systems to ensure seamless
data flow and interoperability. This integration will enhance efficiency, reduce
duplication of efforts, and provide a unified view of IT assets across the
organization.
4. Data Migration Plan (to Populate the System with Existing Asset Data):
A detailed data migration plan will be developed to transfer existing asset data
from legacy systems or spreadsheets into the ITAMS. This plan will include steps
for data cleaning, validation, and migration to ensure accuracy and completeness.
The migration process will be carefully executed to minimize downtime and
disruption to operations.
In summary, the ITAMS project will deliver a robust, user-friendly system, supported by
comprehensive documentation, seamless integration, and a well-executed data
migration plan. These deliverables will ensure the successful implementation and
adoption of the system, enabling the organization to achieve its IT asset management
goals.

7
 IT Asset Management System

Project Benefits:
The implementation of the IT Asset Management System (ITAMS) will bring significant
benefits to the organization, transforming how IT assets are tracked, managed, and
utilized. These benefits include:
1. Improved Asset Visibility and Control:
The ITAMS will provide real-time visibility into all IT assets, including hardware,
software, and peripherals. This centralized view will enable organizations to track
asset locations, monitor usage, and ensure accountability, reducing the risk of lost
or misplaced equipment.
2. Increased Efficiency in IT Asset Management:
By automating routine tasks such as asset tracking, maintenance scheduling, and
license renewals, the ITAMS will significantly reduce manual effort and minimize
errors. This automation will free up IT staff to focus on strategic initiatives,
improving overall productivity.
3. Reduced IT Operational Costs:
The system will help identify underutilized or outdated assets, enabling
organizations to optimize resource allocation and avoid unnecessary expenses.
Additionally, timely maintenance and renewal reminders will prevent costly
downtime and penalties.
4. Enhanced IT Security Posture:
With improved visibility and control over IT assets, the ITAMS will help ensure
compliance with licensing agreements and security protocols. This will reduce the
risk of unauthorized access, data breaches, and legal penalties, enhancing the
organization’s overall security posture.
5. Improved Budgeting and Resource Allocation:
The ITAMS will provide detailed reports on asset utilization, lifecycle status, and
upcoming renewals. These insights will enable better financial planning, ensuring
that budgets are allocated effectively and unexpected expenses are minimized.
Streamlined Compliance Reporting:
The system will simplify compliance reporting by maintaining accurate records of
software licenses, security updates, and asset deployments. This will reduce the
administrative burden of audits and ensure adherence to regulatory requirements.
In summary, the ITAMS will deliver tangible benefits across the organization, from
improved asset visibility and cost savings to enhanced security and streamlined
compliance. These advantages will support the organization’s operational efficiency and
long-term success.

8
 IT Asset Management System

System Architecture
The IT Asset Management System (ITAMS) follows a 3-tier architecture, which separates
the application into three logical layers: Presentation Layer, Application Layer, and Data
Layer. This modular approach ensures scalability, maintainability, and ease of
development. Below is a detailed explanation of each layer:

1. Presentation Layer (Frontend)

• Purpose: Handles user interaction and displays information to the user through a
visually appealing and intuitive interface.
• Technologies:
o HTML/CSS: Used for structuring and styling the user interface, ensuring a clean
and organized layout.
o JavaScript: Adds interactivity and dynamic behaviour, such as form validation and
real-time updates.
o Thymeleaf: Enables server-side rendering of dynamic content, integrating data
seamlessly into HTML templates.
o JSP: Creates dynamic web pages by embedding Java code directly into HTML for
server-side processing.

• Key Components:
o User Interface (UI): Includes forms for adding/updating assets, tables for
displaying asset lists, and filters for searching.
o Navigation: A consistent navigation bar across all pages ensures easy access to
features and improves user experience.
o Responsive Design: Ensures the system is accessible and functional on various
devices, including desktops, tablets, and smartphones.

2. Application Layer (Backend)

• Purpose: Handles business logic, processes user requests, and interacts with the
database to ensure seamless system functionality.
• Technologies:
o Spring Boot: Simplifies backend development with auto-configuration and
embedded server support for scalable applications.
o Java Servlets: Manages HTTP requests and responses, acting as the backbone
for web application functionality.
o Spring MVC: Facilitates the flow of data between the frontend and backend,
ensuring smooth communication and processing.

9
 IT Asset Management System

• Key Components:
o Controllers: Handle user requests, process inputs, and return appropriate
responses (e.g., AssetController manages asset-related operations like adding or
viewing assets).
o Services: Contain business logic (e.g., AssetService handles operations like
adding, updating, and deleting assets, ensuring proper data flow).
o Repositories: Interact with the database to perform CRUD operations
(e.g., AssetRepository queries the Assets table for data retrieval and updates).
o Validation: Ensures data integrity by validating user inputs (e.g., checking for
duplicate serial numbers or invalid dates before saving).

3. Data Layer (Database)

• Purpose: Stores and manages all data related to IT assets, maintenance logs, and
usage logs for efficient retrieval and updates.
• Technologies:
o MySQL: A relational database management system (RDBMS) for storing
structured data in tables with defined relationships.
o JDBC/Spring Data JPA: Connects the application to the database and performs
CRUD operations for seamless data management.
• Key Components:
o Tables:
▪ Assets: Stores asset details (e.g., AssetID, ModelName, Status).
▪ Maintenance_Log : Tracks maintenance activities
(e.g., LogID, AssetID, MaintenanceDate).
▪ UsageLog: Records usage data (e.g., LogID, AssetID, HoursUsed).
o Relationships: Foreign keys enforce relationships between tables, ensuring data
integrity (e.g., AssetID in Maintenance_Log references Assets for valid asset
entries).
o Triggers: Automate tasks like generating custom AssetIDs
(e.g., before_insert_assets trigger creates unique IDs based on asset type and
existing records).

Interaction Between Layers

1. User Interaction: The user interacts with the Presentation Layer by submitting
forms or clicking buttons (e.g., adding an asset through the "Add Asset" form).
2. Request Handling: The Application Layer processes the request, validates inputs
(e.g., checks for duplicate serial numbers), and performs business logic (e.g.,
saving the asset).
3. Data Access: The Application Layer interacts with the Data Layer to retrieve or
update data (e.g., saving a new asset to the Assets table).

10
 IT Asset Management System

4. Response Generation: The Application Layer sends a response back to the

Presentation Layer, which updates the UI (e.g., displays a success message or
shows the updated asset list).

System Architecture Diagram

Below is a simplified representation of the architecture:

Presentation Application Layer Data Layer

Layer (Frontend) (Backend) (Database)
- HTML/CSS/JS - Controllers - MySQL
- Thymeleaf/JSP - Services - Tables
- Repositories - Triggers

Key Features of the Architecture

1. Modularity: Each layer has a distinct responsibility, making the system easier to
develop, test, and maintain.
2. Scalability: The 3-tier architecture allows for horizontal scaling (e.g., adding more
servers to handle increased load).
3. Security: Separation of layers ensures that sensitive data is handled securely in
the backend and database.
4. Flexibility: The use of modern technologies (e.g., Spring Boot, MySQL) ensures the
system can adapt to future requirements.

11
 IT Asset Management System

Tools/Platforms & Hardware/Software Requirement

Specification

A. Hardware Requirements:
Server Configuration (minimum):
• Intel® Xenon™ 2.0 GHz Processors with 256KB cache.
• 256 MB RAM.
• 80 GB Hard Disk Drive.
• 3.5” – 1.44 MB Diskette Drive.
• 52X CD-ROM Drive.
• Intel® Pro 10/100+ LAN Card.
• Printer.
The server should have a proper backup and recovery facility.

Client Configuration (minimum): -

• Intel® Pentium® 3 1.3 GHz processor with 256 KB Cache.
• 128 MB RAM.
• Intel® Pro 10/100+ LAN Card.
• Connection to the LAN.
The clients should have a good rate of data transfer with the server for quick performance.

B. Software Requirements: -
Front-End Tools:
HTML: This is the foundation for building the structure and layout of the web interface. It's
a great choice for a simple ITAMS as it's widely supported and easy to learn.
CSS: CSS allows you to style the HTML pages, defining the visual appearance of the
ITAMS. With CSS, you can control elements like fonts, colours, layout, and
responsiveness (ensuring the interface adapts to different screen sizes).
JavaScript (Optional): While not essential for a very basic ITAMS, JavaScript can add
interactivity to the web interface. Consider using a small JavaScript library like jQuery to
simplify tasks like DOM manipulation and event handling. This can enhance the user
experience by making the interface more dynamic.

12
 IT Asset Management System

Back-End Tools:
JSP: JSP provides server-side scripting capabilities for the ITAMS. You can use JSP to
handle user interactions (e.g., form submissions for adding or editing assets), interact
with the database to retrieve or update data and generate dynamic HTML content based
on user actions.
MySQL: A popular and free open-source relational database management system
(RDBMS), MySQL is a good choice for storing the IT asset information. It's easy to set up
and manage, making it suitable for simpler projects.

Benefits of this Approach:

Simpler to learn and implement: HTML, CSS, JSP, and MySQL are all well-established
technologies with plenty of learning resources available. This makes it easier for
developers with a basic understanding of web development to build a functional ITAMS.
Cost-effective: All these tools are either free and open-source or have free community
editions, making it an economical solution for a simple project.
Suitable for smaller ITAMS: This approach is well-suited for managing a smaller number
of assets and basic functionalities.

Limitations:
Limited User Interface Capabilities: Building a highly interactive and visually appealing
interface with just HTML, CSS, and basic JavaScript can be challenging.
Scalability Concerns: For many assets and complex functionalities, this approach might
not be very scalable.
Security Considerations: Careful attention needs to be paid to security measures when
handling user input and data storage in JSP development.

13
 IT Asset Management System

Project Planning & Scheduling

This PERT chart outlines the main tasks and dependencies for developing the simple IT
Asset Management System (ITAMS) using HTML, CSS, JSP, and MySQL.

Tasks:
• T1: Define Database Schema (1 week, Optimistic: 0.5 weeks, Pessimistic: 1.5
weeks)
• T2: Design User Interface (UI) Mock-ups (2 weeks, Optimistic: 1 week, Pessimistic:
3 weeks)
• T3: Develop HTML Templates (2 weeks, Optimistic: 1 week, Pessimistic: 3 weeks)
• T4: Develop CSS Styles (1 week, Optimistic: 0.5 weeks, Pessimistic: 1.5 weeks)
• T5: Develop JSP for Add Asset Functionality (2 weeks, Optimistic: 1 week,
Pessimistic: 3 weeks)
• T6: Develop JSP for View Asset List Functionality (2 weeks, Optimistic: 1 week,
Pessimistic: 3 weeks)
• T7: Develop JSP for Edit Asset Functionality (Optional: 2 weeks, Optimistic: 1
week, Pessimistic: 3 weeks) *This task is optional and can be added later.
• T8: Develop JSP for Login Functionality (Optional: 1 week, Optimistic: 0.5 weeks,
Pessimistic: 1.5 weeks) *This task is optional and can be added for user access
control.
• T9: Set up and Configure MySQL Database (1 week, Optimistic: 0.5 weeks,
Pessimistic: 1.5 weeks)
• T10: Integrate JSP with MySQL Database (2 weeks, Optimistic: 1 week, Pessimistic:
3 weeks)
• T11: Unit Testing (1 week, Optimistic: 0.5 weeks, Pessimistic: 1.5 weeks)
• T12: User Acceptance Testing (UAT) (1 week, Optimistic: 0.5 weeks, Pessimistic:
1.5 weeks)
• T13: Deploy ITAMS (0.5 weeks, Optimistic: 0.25 weeks, Pessimistic: 1 week)

Dependencies:
• T2 (Design UI Mock-ups) can start after T1 (Define Database Schema) is
completed.
• T3 (Develop HTML Templates) and T4 (Develop CSS Styles) can be done
concurrently after T2 (Design UI Mock-ups) is finished.
• T5 (Develop JSP for Add Asset Functionality) and T6 (Develop JSP for View Asset
List Functionality) can be done concurrently after T3 (Develop HTML Templates)
and T4 (Develop CSS Styles) are completed.
• T7 (Develop JSP for Edit Asset Functionality) is optional and can be added later. It
depends on T5 (Develop JSP for Add Asset Functionality).
• T8 (Develop JSP for Login Functionality) is optional and can be added later. It can
be done concurrently with T9 (Set up and Configure MySQL Database).

14
 IT Asset Management System

• T10 (Integrate JSP with MySQL Database) depends on T5 (Develop JSP for Add
Asset Functionality) or T6 (Develop JSP for View Asset List Functionality)
(whichever is completed first), T7 (Develop JSP for Edit Asset Functionality) (if
included), T8 (Develop JSP for Login Functionality) (if included), and T9 (Set up and
Configure MySQL Database).
• T11 (Unit Testing) can start after T10 (Integrate JSP with MySQL Database) is
completed.
• T12 (UAT) can begin after T11 (Unit Testing) is finished.
• T13 (Deploy ITAMS) is the final task and can be done after T12 (UAT) is successful.

Critical Path:
The critical path is the longest chain of dependent tasks that determines the overall
project duration. In this case, the critical path likely involves:
• T1 (Define Database Schema)
• T2 (Design UI Mockups)
• T3 (Develop HTML Templates)
• T4 (Develop CSS Styles)
• T5 (Develop JSP for Add Asset Functionality) or T6 (Develop JSP for View Asset List
Functionality) (whichever takes longer)
• T9 (Set up and Configure MySQL Database)
• T10 (Integrate JSP with MySQL Database)
• T11 (Unit Testing)
• T12 (UAT)
• T13 (Deploy ITAMS)

Estimated Project Duration:

Considering the most likely durations for each task, the estimated project duration can be
around 13-15 weeks. This is a rough estimate, and the actual duration can vary depending
on various factors.

15
 IT Asset Management System

GANTT Chart:

16
IT Asset Management System

17
 IT Asset Management System

Scope of the Solution

This project aims to develop a web-based IT Asset Management System (ITAMS) to
streamline asset tracking and management within a small to medium-sized organization.
The core functionalities will focus on:

Asset Management:
• Hardware Asset Tracking: The system will primarily focus on managing hardware
assets like laptops, desktops, peripherals, and monitors. You can consider
expanding to include software assets in the future.
• Asset Inventory: The system will maintain a comprehensive inventory of all IT
assets, including details like model names, serial numbers, purchase dates,
assigned users, and status (e.g., active, in repair, decommissioned).
• Adding New Assets: IT personnel can add new assets to the system by providing
necessary details.
• Editing Existing Assets: Users can modify existing asset information as needed.
(Optional: Implement access controls to restrict editing based on user roles)
• Viewing Asset List: IT personnel and department managers can view a list of all
assets with search functionalities to filter based on various criteria (e.g., model
type, assigned user).
• Basic Asset Reporting (Optional): The system can generate a basic report
summarizing the number of assets by type (laptops, desktops, etc.).

Technical Scope:
• Front-End: Developed using HTML, CSS, and potentially basic JavaScript for
improved interactivity.
• Back-End: Implemented using JSP for server-side scripting and interaction with
the database.
• Database: MySQL will be used to store all IT asset information.
• Security: Focus on basic security measures like user authentication (optional)
and proper data validation to prevent unauthorized access and malicious input.
• Scalability: The initial system will be designed to handle a moderate number of
assets. Future enhancements can address scalability needs as the asset inventory
grows.

Scope Exclusions:
• Software Asset Management: This initial version will not manage software
licenses or track software installations on assets.
• Advanced Reporting: Detailed reports with granular asset information are not
included in the initial scope.
• Mobile Access: The system will be accessible through web browsers on desktop
and laptop computers. Developing a mobile application is excluded from the initial
scope.

18
 IT Asset Management System

• Advanced Security Features: While basic security measures are considered,

functionalities like user authorization for different access levels are optional and
can be added later.
• Integration with other IT Systems: Integration with other existing IT systems (e.g.,
Active Directory) is not included in the initial scope.

Analysis (Development Lifecycle)

Here's a breakdown of the development lifecycle for the Simple IT Asset Management
System (ITAMS), covering the key phases:

1. Pre-Analysis Studies (Feasibility Study):

• Business Need Identification: This initial phase involves understanding the
business need for ITAMS. What problems are you trying to solve? How will this
system improve asset management? Who are the stakeholders involved?
• Feasibility Analysis: Evaluate the feasibility of developing this system.
o Technical Feasibility: Can the IT infrastructure support the proposed
system?
o Economic Feasibility: Will the costs associated with development be
justified by the benefits?
o Operational Feasibility: Can the organization effectively implement and
manage this system?
• Project Scope Definition: Define the high-level functionalities and limitations of
the ITAMS. What core features will it offer? What will be excluded initially?

2. System Analysis:
• Requirements Gathering: This phase involves gathering detailed requirements
from stakeholders (IT personnel, department managers).
o What functionalities are most important for asset management?
o What data needs to be tracked for each asset?
o What reports are needed?
o User interface preferences and accessibility considerations.
• Data Flow Analysis: Define how data will flow through the system. What user
actions will trigger data updates and how will the system respond?
• Entity-Relationship (ER) Diagramming: Visually represent the real-world entities
(e.g., Asset, User) and their relationships in the system (e.g., one Asset can be
assigned to one User).

3. System Design:
• System Architecture Design: Define the overall architecture of the ITAMS,
including front-end, back-end, and database components.

19
 IT Asset Management System

• User Interface (UI) Design: Design the user interface mock-ups outlining the
layout and functionalities of the web interface for adding, editing, viewing, and
searching for asset information.
• Database Design: Design the database schema to efficiently store all IT asset
data (e.g., tables, attributes, relationships).
• Technology Selection: Choose the specific technologies to be used for front-end
development (HTML, CSS, JavaScript), back-end development (JSP), and the
database (MySQL).

4. Project Coding:
• Development of System Components: Developers will code the front-end web
interface using HTML, CSS, and potentially JavaScript. Back-end functionalities for
interacting with the database and handling user requests will be implemented
using JSP.
• Database Setup and Configuration: The MySQL database will be configured
according to the designed schema.
• Unit Testing: Individual code modules will be tested to ensure they function as
expected.

5. Project Testing:
• Integration Testing: All system components (front-end, back-end, and database)
will be integrated and tested to ensure seamless functionality.
• System Testing: The complete system will be tested using various test cases to
verify it meets the defined requirements.
• User Acceptance Testing (UAT): End-users (IT personnel, department managers)
will test the system to ensure it meets their needs and expectations.

6. Implementation & Documentation:

• Deployment: The ITAMS will be deployed to a production environment and made
accessible to authorized users.
• User Training: Training sessions will be conducted for users on how to effectively
utilize the ITAMS functionalities.
• System Documentation: User manuals, technical documentation, and system
administration guides will be prepared for reference and future maintenance.

7. Maintenance & Enhancement (Optional):

• After successful deployment, the system will be monitored and maintained to
address any bugs or issues.
• Based on user feedback and evolving needs, new functionalities and
enhancements can be planned and implemented to improve the ITAMS over time.

20
IT Asset Management System

DFD Level 0

21
IT Asset Management System

DFD Level 1

22
IT Asset Management System

DFD Level 2

23
 IT Asset Management System

Entity Relationship Diagram (ERD):

24
 IT Asset Management System

Database Design for Simple IT Asset Management

System
This design outlines the database structure for the Simple IT Asset Management System,
using MySQL as the database management system.

Tables:
1. Assets: This table stores all essential information about the IT assets.
Column Primary Foreign
Data Type Description
Name Key Key
Unique identifier for each
AssetID INT (primary key) YES
asset
Name or model number of
ModelName VARCHAR(255)
the asset
Unique serial number of the
SerialNumber VARCHAR(255)
asset
Date the asset was
PurchaseDate DATE
purchased
Name of the employee to
AssignedTo VARCHAR(255) whom the asset is assigned
(Optional)
ENUM('Active',’Inactive’
Status 'In-Repair', Current status of the asset
'Decommissioned')
ENUM('Laptop',
Category or type of the asset
Type 'Desktop', 'Monitor',
(Optional)
'Other') (Optional)

Notes:
• Primary Key: The AssetID column is the primary key for the Assets table, ensuring
each asset has a unique identifier.
• Foreign Key: This design currently does not include foreign keys. You can consider
adding a foreign key relationship to a Users table if you implement user login and
access control functionalities.
• Data Types: Choose appropriate data types for each column based on the kind of
data being stored (e.g., INT for numbers, VARCHAR for text).
• Optional Columns: The AssignedTo and Type columns are optional and can be
included based on the specific needs.

25
 IT Asset Management System

2. Usage Log Table (usagelog): The usagelog table records the usage history of IT
assets. It helps track how often an asset is used, the duration of its usage, and its
reliability over time.
Column
Data Type Description Primary Key
Name
logid INT (primary key) Unique log entry ID YES
assetid VARCHAR(10) Reference to the assets table
usagedate DATE Date when the asset was used
hoursused INT Number of hours the asset was used.
reliabilityscore DECIMAL(5,2) Score based on asset performance.

Notes:
Indexes & Relationships:
• Primary Key: logid (Ensures each log entry is unique).
• Foreign Key: assetid (Links each usage log to a specific asset in the assets table).
• One-to-Many Relationship: An asset can have multiple usage records over time.
Additional Considerations:
• Add a userid field to track which employee or department used the asset.
• Include a location field to monitor where the asset was used.
• Implement automatic calculation of reliabilityscore based on past maintenance
and usage trends.
This design provides a starting point for the IT Asset Management System database. You
can customize it further based on the specific needs and data requirements.

26
 IT Asset Management System

3.Maintenance Log Table (Maintenance_Log )

The maintenance_log table records maintenance activities performed on IT assets,

helping track repair history, servicing dates, and types of maintenance. This ensures
better asset management and longevity.

Column Name Data Type Description Primary Key

Unique identifier for each maintenance
LogID INT (primary key) YES
log entry.
assetid VARCHAR(10) Reference to the assets table
Date when the maintenance was
MaintenanceDate DATE
performed.
Type of maintenance performed (e.g.,
MaintenanceType VARCHAR(255) Hardware Repair, Software Update,
Cleaning, Inspection).
Additional remarks or details about the
Notes TEXT
maintenance.

Notes:
• Primary Key: LogID (Ensures uniqueness of each maintenance record).
• Foreign Key: AssetID (Links each maintenance log to a specific asset in the assets
table).
• One-to-Many Relationship:
o One asset can have multiple maintenance records over time.
o Each maintenance record is linked to a single asset.
Use Cases:
1. Track Maintenance History: Maintain a log of all repairs and servicing done on
assets.
2. Schedule Preventive Maintenance: Use past maintenance records to predict
and schedule future servicing.
3. Assess Asset Health: Analyse maintenance frequency to determine if an asset
should be replaced or upgraded.
4. Improve Cost Management: Monitor how often assets require maintenance to
optimize IT spending.
Potential Enhancements:
• Add a TechnicianID field to track who performed the maintenance.
• Include a Cost field to record the expense of each maintenance task.
• Implement automated alerts for scheduled maintenance based on past records.

27
 IT Asset Management System

Database Schema Overview

The database ITAMS consists of three main tables:
1. Assets: Stores information about IT assets (e.g., laptops, desktops).
2. Maintenance_Log : Tracks maintenance activities for assets.
3. UsageLog: Records usage data for assets.

Triggers
Trigger: before_insert_assets
• Purpose: Automatically generates a custom AssetID for each new asset based on
its type.
• Logic:
o Determines a prefix (LT, DT, PT, or OT) based on the asset type
(Laptop, Desktop, Printer, Other).
o Finds the maximum numeric part of existing AssetIDs for the same type and
increments it by 1.
o Formats the AssetID as PREFIX + 4-digit number (e.g., LT0001, DT0002).
• Example:
o If the last Laptop asset has AssetID = LT0003, the next Laptop asset will
get AssetID = LT0004.

How It Works:
1. Prefix Assignment:
IF NEW.Type = 'Laptop' THEN
SET prefix = 'LT';
ELSEIF NEW.Type = 'Desktop' THEN
SET prefix = 'DT';
ELSEIF NEW.Type = 'Printer' THEN
SET prefix = 'PT';
ELSE
SET prefix = 'OT';
END IF;

2. Next ID Calculation:
SELECT IFNULL(MAX(CAST(SUBSTRING(AssetID, 3) AS UNSIGNED)), 0) + 1 INTO
nextID
FROM Assets
WHERE AssetID LIKE CONCAT(prefix, '%');

3. Formatting:
SET NEW.AssetID = CONCAT(prefix, LPAD(nextID, 4, '0'));

28
 IT Asset Management System

Usage:
• The trigger ensures that every new asset gets a unique, type
specific AssetID without manual input.

Indexes
Indexes are used to speed up data retrieval operations. In the schema:

Primary Key Indexes:

• Assets Table: AssetID is the primary key, so it is automatically indexed.
• Maintenance_Log Table: LogID is the primary key and is indexed.
• UsageLog Table: LogID is the primary key and is indexed.

Foreign Key Indexes:

• Maintenance_Log Table: AssetID is a foreign key referencing Assets(AssetID).
This creates an index on AssetID to optimize join operations.
• UsageLog Table: AssetID is a foreign key referencing Assets(AssetID). This also
creates an index on AssetID.

How Indexes Help:

• Faster Queries: Indexes allow the database to quickly locate rows without
scanning the entire table.
• Efficient Joins: Foreign key indexes optimize queries involving joins
between Assets, Maintenance_Log , and UsageLog.

Summary of Triggers and Indexes

Component Details
Trigger before_insert_assets: Generates custom AssetID based on asset
type.
Primary Key Index Automatically created for AssetID, LogID (in Maintenance_Log and
UsageLog).
Foreign Key Index Automatically created for AssetID in Maintenance_Log and
UsageLog.
Additional Indexes Optional indexes on Type or Status for faster filtering.

29
 IT Asset Management System

Complete System Structure for the IT Asset

Management System
Directory Structure:
The directory structure for the IT Asset Management System (ITAMS) project is well-
organized and follows standard conventions for a Spring Boot application. Below is a
detailed explanation of the structure:

1. Root Directory (ITAMS)

• pom.xml: Maven configuration file defining project dependencies, plugins, and
build settings.
• README.md: Project documentation providing an overview, setup instructions,
and usage guidelines.
• HELP.md: Additional help or documentation for the project.
• mvnw and mvnw.cmd: Maven wrapper scripts for building the project without
requiring Maven to be installed globally.

ITAMS/
├── pom.xml # Maven configuration file
├── README.md # Project documentation
├── HELP.md # Additional help/documentation
├── mvnw # Maven wrapper script (Unix)
├── mvnw.cmd # Maven wrapper script (Windows)

2. Source Code (src/main)

Java Source (src/main/java)
• com.itams.itams: Base package for the application.
o controller: Contains Spring Boot controllers (e.g., AssetController.java) to
handle HTTP requests.
o entity: Contains JPA entity classes (e.g., Asset.java, Maintenance_Log
.java) representing database tables.
o repository: Contains repository interfaces (e.g., AssetRepository.java) for
database operations using Spring Data JPA.

src/main/java/
└── com/itams/itams/
├── controller/ # Spring Boot controllers (e.g., AssetController.java)
├── entity/ # JPA entity classes (e.g., Asset.java, Maintenance_Log .java)
└── repository/ # Repository interfaces (e.g., AssetRepository.java)

30
 IT Asset Management System

Resources (src/main/resources)
• application.properties: Configuration file for Spring Boot settings (e.g., database
connection, server port).

src/main/resources/
└── application.properties # Spring Boot configuration file
Web Application (src/main/webapp)
• WEB-INF: Contains web application configuration files (e.g., web.xml for servlet
mappings).
o jsp: Contains JSP files for the frontend:
▪ add_asset.jsp: Form for adding new assets.
▪ index.jsp: Homepage with navigation links.
▪ maintenance_logs.jsp: Page for viewing and filtering maintenance
logs.
▪ update_asset.jsp: Page for updating asset details.
▪ usage_logs.jsp: Page for viewing and adding usage logs.
▪ view_assets.jsp: Page for displaying a list of assets.

src/main/webapp/
└── WEB-INF/
└── jsp/ # JSP files for the frontend
├── add_asset.jsp # Form for adding new assets
├── index.jsp # Homepage with navigation links
├── maintenance_logs.jsp # Page for viewing/filtering maintenance logs
├── update_asset.jsp # Page for updating asset details
├── usage_logs.jsp # Page for viewing/adding usage logs
└── view_assets.jsp # Page for displaying a list of assets

3. Test Code (src/test)

• src/test/java: Contains unit and integration tests for the application.
o com.itams.itams: Test classes for controllers, services, and repositories.

src/test/java/
└── com/itams/itams/ # Unit and integration test classes

4. Build Output (target)

• generated-sources: Contains source code generated during the build process
(e.g., annotations).
• generated-test-sources: Contains test source code generated during the build
process.
• maven-status: Contains metadata about the Maven build process.

31
 IT Asset Management System

target/
├── generated-sources/ # Source code generated during the build
├── generated-test-sources/ # Test source code generated during the build
└── maven-status/ # Metadata about the Maven build process

5. Dependencies
• Maven Dependencies: Contains all libraries and dependencies defined
in pom.xml.
• JRE System Library: Contains Java runtime libraries required for the project.

Maven Dependencies/ # Libraries and dependencies defined in pom.xml

JRE System Library/ # Java runtime libraries

Key Features of the Structure

1. Separation of Concerns:
o Frontend: JSP files in src/main/webapp/WEB-INF/jsp.
o Backend: Java classes in src/main/java/com/itams/itams.
o Configuration: application.properties and web.xml.
2. Modularity:
o Controllers, entities, and repositories are organized into separate packages
for clarity and maintainability.
3. Testability:
o Dedicated src/test directory for unit and integration tests.
4. Build Automation:
o Maven (pom.xml) handles dependency management and build processes.

Database:
• MySQL database stores all IT asset information.
• The Assets table stores core asset data (model name, serial number, purchase
date, assigned user, status, type). (Optional: A User table stores user information
for login and access control)
• The database schema is designed to efficiently store and retrieve asset
information.

Security Considerations:
• Implement basic security measures to protect the system from unauthorized
access and data breaches.
• Validate user input to prevent malicious code injection.
• Use secure password hashing techniques if a “user” table is included.

Deployment:
• The IT Asset Management System will be deployed to a web server accessible by
authorized users through a web browser.

32
 IT Asset Management System

Additional Considerations:
• Scalability: The initial system is designed for a moderate number of assets.
Consider future enhancements for scalability as the asset inventory grows.
• Error Handling: Implement proper error handling mechanisms to gracefully
handle unexpected situations and provide informative messages to users.
• Logging: Maintain logs of user activity and system events for troubleshooting and
audit purposes.

Overall System Structure:

1. User interacts with the web interface: The user accesses the IT Asset
Management System through a web browser.
2. Web browser sends the request to the web server: The user interacts with the
web interface elements (buttons, forms) which trigger the web browser to send a
request to the web server.
3. Web server processes request and interacts with JSP: The web server receives
the request and forwards it to the JSP script on the server side.
4. JSP script interacts with the database: The JSP script processes the request and
interacts with the MySQL database using JDBC (Java Database Connectivity) to
retrieve or update asset information.
5. JSP script generates HTML response: Based on the interaction with the
database, the JSP script generates a dynamic HTML response to be sent back to
the user's web browser.
6. Web server sends the response to web browser: The web server receives the
generated HTML response from the JSP script and sends it back to the user's web
browser.
7. Web browser updates user interface: The user's web browser receives the HTML
response and updates the web page content, accordingly, reflecting the results of
the user's interaction.

This comprehensive structure provides a clear understanding of how the different

components work together to deliver a functional IT Asset Management System.
Remember, this is a simplified system, and you can gradually add functionalities and
enhance its capabilities based on evolving needs.

33
 IT Asset Management System

Source Code
1. Home page (Index.jsp)
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>IT Asset Management System</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<header>
<h1>IT Asset Management System</h1>
<nav>
<ul>
<li><a href="/">Home</a></li>
<li><a href="add">Add Asset</a></li>
<li><a href="view">View Assets</a></li>
<li><a href="update">Update Asset</a></li>
<li><a href="main">Maintenance Logs</a></li>
<li><a href="use">Usage Logs</a></li>
</ul>
</nav>
</header>

<main>
<section>
<h2>Welcome</h2>
<p>This system helps you manage IT assets, track maintenance, and monitor
usage.</p>
</section>
</main>

<footer>
<p>&copy; <%= java.time.Year.now() %> IT Asset Management System. All rights
reserved.</p>
</footer>
</body>
</html>

34
 IT Asset Management System

2. Add Asset Page(add_asset.jsp)

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Add Asset</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<header>
<h1>IT Asset Management System</h1>
<nav>
<ul>
<li><a href="/">Home</a></li>
<li><a href="add">Add Asset</a></li>
<li><a href="view">View Assets</a></li>
<li><a href="update">Update Asset</a></li>
<li><a href="main">Maintenance Logs</a></li>
<li><a href="use">Usage Logs</a></li>
</ul>
</nav>
</header>

<main>
<section>
<h2>Add a New Asset</h2>
<form action="addAssetServlet" method="post">
<label for="modelName">Model Name:</label>
<input type="text" id="modelName" name="modelName" required><br>

<label for="serialNumber">Serial Number:</label>

<input type="text" id="serialNumber" name="serialNumber" required><br>

<label for="purchaseDate">Purchase Date:</label>

<input type="date" id="purchaseDate" name="purchaseDate" required><br>

<label for="assignedTo">Assigned To (User ID):</label>

<input type="number" id="assignedTo" name="assignedTo" required><br>

<label for="status">Status:</label>
<select id="status" name="status">
<option value="Active">Active</option>
<option value="In Repair">In Repair</option>

35
 IT Asset Management System

<option value="Decommissioned">Decommissioned</option>
</select><br>

<label for="type">Type:</label>
<select id="type" name="type">
<option value="Laptop">Laptop</option>
<option value="Desktop">Desktop</option>
<option value="Printer">Printer</option>
<option value="Other">Other</option>
</select><br>

<button type="submit">Add Asset</button>

</form>
</section>
</main>

<footer>
<p>&copy; <%= java.time.Year.now() %> IT Asset Management System. All rights
reserved.</p>
</footer>
</body>
</html>

3. View Asset Page(view_asset.jsp)

<%@page import="com.itams.itams.entity.Asset"%>
<%@ page import="java.util.List, java.util.Map" %>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>View Assets</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<header>
<h1>IT Asset Management System</h1>
<nav>
<ul>
<li><a href="/">Home</a></li>
<li><a href="add">Add Asset</a></li>
<li><a href="view">View Assets</a></li>
<li><a href="update">Update Asset</a></li>
<li><a href="main">Maintenance Logs</a></li>

36
 IT Asset Management System

<li><a href="use">Usage Logs</a></li>

</ul>
</nav>
</header>

<main>
<section>
<h2>Asset Inventory</h2>
<table>
<thead>
<tr>
<th>Asset ID</th>
<th>Model Name</th>
<th>Serial Number</th>
<th>Purchase Date</th>
<th>Assigned To</th>
<th>Status</th>
<th>Type</th>
</tr>
</thead>
<tbody>
<%-- Example of fetching and displaying assets from the database --%>
<%
// Simulated database result set
List<Asset> assets = (List<Asset>) request.getAttribute("assets");
if (assets != null && !assets.isEmpty()) {
for (Asset asset : assets) {
%>
<tr>
<td><%= asset.getAssetId() %></td>
<td><%= asset.getModelName() %></td>
<td><%= asset.getSerialNumber() %></td>
<td><%= asset.getPurchaseDate() %></td>
<td><%= asset.getAssignedTo() %></td>
<td><%= asset.getStatus() %></td>
<td><%= asset.getType() %></td>
</tr>
<%
}
} else {
%>
<tr>
<td colspan="7">No assets found.</td>
</tr>
<% } %>
</tbody>
</table>

37
 IT Asset Management System

</section>
</main>
<footer>
<p>&copy; <%= java.time.Year.now() %> IT Asset Management System. All rights
reserved.</p>
</footer>
</body>
</html>

4. Maintenance Logs Page(maintenance_logs.jsp)

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<%@ page import="java.util.List, java.util.Map" %>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Maintenance Logs</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<header>
<h1>IT Asset Management System</h1>
<nav>
<ul>
<li><a href="/">Home</a></li>
<li><a href="add">Add Asset</a></li>
<li><a href="view">View Assets</a></li>
<li><a href="update">Update Asset</a></li>
<li><a href="main">Maintenance Logs</a></li>
<li><a href="use">Usage Logs</a></li>
</ul>
</nav>
</header>

<main>
<section>
<h2>Maintenance Logs</h2>

<form action="filterMaintenanceLogsServlet" method="get">

<h3>Filter Maintenance Logs</h3>
<label for="assetID">Asset ID:</label>
<input type="text" id="assetID" name="assetID"><br>

38
 IT Asset Management System

<label for="serialNumber">Serial Number:</label>

<input type="text" id="serialNumber" name="serialNumber"><br>

<label for="startDate">Start Date:</label>

<input type="date" id="startDate" name="startDate"><br>

<label for="endDate">End Date:</label>

<input type="date" id="endDate" name="endDate"><br>

<button type="submit">Filter Logs</button>

</form>
<h3>Existing Maintenance Logs</h3>
<table>
<thead>
<tr>
<th>Log ID</th>
<th>Asset ID</th>
<th>Serial Number</th>
<th>Maintenance Date</th>
<th>Maintenance Type</th>
<th>Notes</th>
</tr>
</thead>
<tbody>
<%-- Fetch and display maintenance logs --%>
<%
List<Map<String, String>> logs = (List<Map<String, String>>)
request.getAttribute("maintenanceLogs");
if (logs != null && !logs.isEmpty()) {
for (Map<String, String> log : logs) {
%>
<tr>
<td><%= log.get("LogID") %></td>
<td><%= log.get("AssetID") %></td>
<td><%= log.get("SerialNumber") %></td>
<td><%= log.get("MaintenanceDate") %></td>
<td><%= log.get("MaintenanceType") %></td>
<td><%= log.get("Notes") %></td>
</tr>
<%
}
} else {
%>
<tr>
<td colspan="6">No maintenance logs found.</td>
</tr>

39
 IT Asset Management System

<% } %>
</tbody>
</table>
</section>
</main>
<footer>
<p>&copy; <%= java.time.Year.now() %> IT Asset Management System. All rights
reserved.</p>
</footer>
</body>
</html>

5. Usage Logs Page (usage_logs.jsp)

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<%@ page import="java.util.List, java.util.Map" %>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Usage Logs</title>
<link rel="stylesheet" href="styles.css">
</head>
<body>
<header>
<h1>IT Asset Management System</h1>
<nav>
<ul>
<li><a href="/">Home</a></li>
<li><a href="add">Add Asset</a></li>
<li><a href="view">View Assets</a></li>
<li><a href="update">Update Asset</a></li>
<li><a href="main">Maintenance Logs</a></li>
<li><a href="use">Usage Logs</a></li>
</ul>
</nav>
</header>

<main>
<section>
<h2>Usage Logs</h2>

<form action="addUsageLogServlet" method="post">

<h3>Add New Usage Log</h3>
<label for="assetID">Asset ID:</label>

40
 IT Asset Management System

<input type="number" id="assetID" name="assetID" required><br>

<label for="date">Date:</label>
<input type="date" id="date" name="date" required><br>

<label for="hoursUsed">Hours Used:</label>

<input type="number" id="hoursUsed" name="hoursUsed" required><br>

<button type="submit">Add Usage Log</button>

</form>

<form action="addMaintenanceLogServlet" method="post">

<h3>Add New Maintenance Log</h3>
<label for="assetID">Asset ID:</label>
<input type="number" id="assetID" name="assetID" required><br>

<label for="maintenanceDate">Maintenance Date:</label>

<input type="date" id="maintenanceDate" name="maintenanceDate"
required><br>

<label for="maintenanceType">Maintenance Type:</label>

<input type="text" id="maintenanceType" name="maintenanceType"
required><br>

<label for="notes">Notes:</label>
<textarea id="notes" name="notes"></textarea><br>

<button type="submit">Add Maintenance Log</button>

</form>

<h3>Existing Usage Logs</h3>

<table>
<thead>
<tr>
<th>Log ID</th>
<th>Asset ID</th>
<th>Date</th>
<th>Hours Used</th>
<th>Reliability Score</th>
</tr>
</thead>
<tbody>
<%-- Example of fetching and displaying usage logs from the database --%>
<%
List<Map<String, String>> usageLogs = (List<Map<String, String>>)
request.getAttribute("usageLogs");
if (usageLogs != null && !usageLogs.isEmpty()) {

41
 IT Asset Management System

for (Map<String, String> log : usageLogs) {

%>
<tr>
<td><%= log.get("LogID") %></td>
<td><%= log.get("AssetID") %></td>
<td><%= log.get("Date") %></td>
<td><%= log.get("HoursUsed") %></td>
<td><%= log.get("ReliabilityScore") %></td>
</tr>
<%
}
} else {
%>
<tr>
<td colspan="5">No usage logs found.</td>
</tr>
<% } %>
</tbody>
</table>
</section>
</main>

<footer>
<p>&copy; <%= java.time.Year.now() %> IT Asset Management System. All rights
reserved.</p>
</footer>
</body>
</html>

6. Update Asset Page(update_asset.jsp)

<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<%@ page import="java.util.List, java.util.Map" %>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Update Asset Status</title>
<script>
function validateSearch() {
var assetId = document.getElementById("assetId").value;
var serialNumber = document.getElementById("serialNumber").value;
if (assetId.trim() === "" && serialNumber.trim() === "") {
alert("Please enter either Asset ID or Serial Number to search.");
return false;
}

42
 IT Asset Management System

return true;
}
</script>
</head>
<body>
<header>
<h1>IT Asset Management System</h1>
<nav>
<ul>
<li><a href="/">Home</a></li>
<li><a href="add">Add Asset</a></li>
<li><a href="view">View Assets</a></li>
<li><a href="update">Update Asset</a></li>
<li><a href="main">Maintenance Logs</a></li>
<li><a href="use">Usage Logs</a></li>
</ul>
</nav>
</header>
<h2>Search Asset</h2>
<form action="${pageContext.request.contextPath}/assets/search" method="get"
onsubmit="return validateSearch()">
<p>
<label>Search by Asset ID:</label>
<input type="text" name="assetId" id="assetId" />
<button type="submit">Search</button>
</p>
<p>
<label>Search by Serial Number:</label>
<input type="text" name="serialNumber" id="serialNumber" />
<button type="submit">Search</button>
</p>
</form>
<c:if test="${not empty asset}">
<h2>Update Asset</h2>
<form action="${pageContext.request.contextPath}/assets/update" method="post">
<input type="hidden" name="id" value="${asset.id}" />
<p>
<label>Asset Name:</label>
<input type="text" value="${asset.name}" disabled />
</p>
<p>
<label>Current Status:</label>
<input type="text" value="${asset.status}" disabled />
</p>
<p>
<label>New Status:</label>
<select name="status" id="status" required>

43
 IT Asset Management System

<option value="Active">Active</option>
<option value="Inactive">Inactive</option>
<option value="Decommissioned">Decommissioned</option>
<option value="In Repair">In Repair</option>
</select>
</p>
<p>
<label>Current Assigned User:</label>
<input type="text" value="${asset.assignedTo}" disabled />
</p>
<p>
<label>New Assigned User:</label>
<input type="text" name="assignedTo" required />
</p>
<button type="submit">Update</button>
</form>
</c:if>
</body>
</html>

7. Maven Configuration File (pom.xml)

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>3.4.2</version>
<relativePath /> <!-- lookup parent from repository -->
</parent>
<groupId>com.itams</groupId>
<artifactId>itams</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>IT Asset Management System</name>
<description>IT Asset Management System</description>
<url />
<licenses>
<license />
</licenses>
<developers>
<developer />
</developers>

44
 IT Asset Management System

<scm>
<connection />
<developerConnection />
<tag />
<url />
</scm>
<properties>
<java.version>21</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/jakarta.servlet.jsp.jstl/jakarta.servlet.jsp.jstl-api
-->
<dependency>
<groupId>jakarta.servlet.jsp.jstl</groupId>
<artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
</dependency>
<dependency>
<groupId>com.mysql</groupId>
<artifactId>mysql-connector-j</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>

45
 IT Asset Management System

</plugin>
</plugins>
</build>
</project>

8. Spring Boot Configuration File (application.properties)

spring.application.name=IT Asset Management System
spring.mvc.view.prefix: /WEB-INF/jsp/
spring.mvc.view.suffix: .jsp
spring.datasource.url = jdbc:mysql://localhost:3306/itams
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.show-sql:true
spring.jpa.hibernate.ddl-auto=none

9. Java Class Files

• ItAssetManagementSystemApplication.java
package com.itams.itams;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class ItAssetManagementSystemApplication {
public static void main(String[] args) {
SpringApplication.run(ItAssetManagementSystemApplication.class, args);
}
}

• HomeController.java
package com.itams.itams.controller;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.servlet.ModelAndView;
import com.itams.itams.entity.Asset;
import com.itams.itams.repository.AssetRepository;
@Controller
public class HomeController {
@Autowired AssetRepository assetRepository;
@GetMapping("/")
public String showTodos() {
return "index";

46
 IT Asset Management System

}
@GetMapping("/add")
public String addAsset() {
return "add_asset";
}
@GetMapping("/update")
public String updateAsset() {
return "update_asset";
}
@GetMapping("/view")
public ModelAndView viewAssets() {
ModelAndView modelAndView = new ModelAndView("view_assets");
List<Asset> assets = assetRepository.findAll();
System.out.println(assets);
modelAndView.addObject("assets",assets);
return modelAndView;
}
@GetMapping("/main")
public String maintenanceLogs() {
return "maintenance_logs";
}
@GetMapping("/use")
public String usageLogs() {
return "usage_logs";
}
}

• Entity Files
o Asset.java

package com.itams.itams.controller;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.servlet.ModelAndView;
import com.itams.itams.entity.Asset;
import com.itams.itams.repository.AssetRepository;
@Controller
public class HomeController {
@Autowired AssetRepository assetRepository;
@GetMapping("/")
public String showTodos() {
return "index";

47
 IT Asset Management System

}
@GetMapping("/add")
public String addAsset() {
return "add_asset";
}
@GetMapping("/update")
public String updateAsset() {
return "update_asset";
}
@GetMapping("/view")
public ModelAndView viewAssets() {
ModelAndView modelAndView = new ModelAndView("view_assets");
List<Asset> assets = assetRepository.findAll();
System.out.println(assets);
modelAndView.addObject("assets",assets);
return modelAndView;
}
@GetMapping("/main")
public String maintenanceLogs() {
return "maintenance_logs";
}
@GetMapping("/use")
public String usageLogs() {
return "usage_logs";
}
}

o MaintenanceLog.java

package com.itams.itams.entity;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
// Annotations
@Entity
public class MaintenanceLog {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long logId;
private String assetID;
private String maintenanceDate;
private String maintenanceType;

48
 IT Asset Management System

private String assignedTo;

private String notes;
public Long getLogId() {
return logId;
}
public void setLogId(Long logId) {
this.logId = logId;
}
public String getAssetID() {
return assetID;
}
public void setAssetID(String assetID) {
this.assetID = assetID;
}
public String getMaintenanceDate() {
return maintenanceDate;
}
public void setMaintenanceDate(String maintenanceDate) {
this.maintenanceDate = maintenanceDate;
}
public String getMaintenanceType() {
return maintenanceType;
}
public void setMaintenanceType(String maintenanceType) {
this.maintenanceType = maintenanceType;
}
public String getAssignedTo() {
return assignedTo;
}
public void setAssignedTo(String assignedTo) {
this.assignedTo = assignedTo;
}
public String getNotes() {
return notes;
}
public void setNotes(String notes) {
this.notes = notes;
}
}
o UsageLog.java

package com.itams.itams.entity;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

49
 IT Asset Management System

// Annotations
@Entity
public class UsageLog {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long logID;
private String assetID;
private String date;
private String hoursUsed;
private String reliabilityScore;
public Long getLogID() {
return logID;
}
public void setLogID(Long logID) {
this.logID = logID;
}
public String getAssetID() {
return assetID;
}
public void setAssetID(String assetID) {
this.assetID = assetID;
}
public String getDate() {
return date;
}
public void setDate(String date) {
this.date = date;
}
public String getHoursUsed() {
return hoursUsed;
}
public void setHoursUsed(String hoursUsed) {
this.hoursUsed = hoursUsed;
}
public String getReliabilityScore() {
return reliabilityScore;
}
public void setReliabilityScore(String reliabilityScore) {
this.reliabilityScore = reliabilityScore;
}
}

50
 IT Asset Management System

Implementation Methodology
1. Planning and Requirement Gathering:
• Define project scope, goals, and deliverables.
• Gather requirements from stakeholders (IT personnel, department managers).
o What functionalities are most important for asset management?
o What data needs to be tracked for each asset?
o What reports are needed?
o User interface preferences and accessibility considerations.
• Create a list of features to be implemented in the initial version and a roadmap for
future enhancements.
• Develop a high-level project plan with timelines and resource allocation.

2. Design and Development:

• Design the system architecture, including front-end, back-end, and database
components.
• Create detailed user interface (UI) mock-ups for adding, editing, viewing, and
searching for asset information.
• Design the database schema to efficiently store all IT asset data (e.g., tables,
attributes, relationships).
• Choose the specific technologies for development (HTML, CSS, JavaScript for
front-end; JSP for back-end; MySQL for database).
• Develop the system components following best practices for coding and security.
• Conduct unit testing of individual code modules to ensure they function as
expected.

3. System Integration and Testing:

• Integrate all system components (front-end, back-end, and database) to ensure
seamless functionality.
• Conduct comprehensive system testing using various test cases to verify the
system meets the defined requirements.
• Perform user acceptance testing (UAT) with end-users to gather feedback and
ensure the system meets their needs.

4. Deployment and Training:

• Deploy the IT Asset Management System to a production environment accessible
by authorized users.
• Conduct training sessions for users on how to effectively utilize the system
functionalities for adding, editing, and managing IT assets.
• Prepare user manuals and system documentation for reference and future
maintenance.

51
 IT Asset Management System

5. Maintenance and Support:

• Monitor the system after deployment to address any bugs or issues.
• Implement a version control system to track changes and facilitate rollbacks if
necessary.
• Based on user feedback and evolving needs, plan and implement new functionalities and
enhancements to improve the IT Asset Management System over time.

Agile Methodology Considerations:

• You can consider adopting an Agile development methodology for a more iterative
approach.
• This involves breaking down the development process into smaller sprints, allowing for
continuous feedback and adjustments throughout the project lifecycle.

Tools and Techniques:

• Utilize project management tools (e.g., Trello, Asana) to manage tasks, track progress, and
collaborate with team members.
• Use version control systems (e.g., Git) to track code changes and enable collaboration
among developers.
• Leverage code review practices to ensure code quality and adherence to best practices.

Communication and Collaboration:

• Maintain clear communication channels between developers, stakeholders, and end-
users throughout the project lifecycle.
• Conduct regular meetings to discuss progress, address issues, and gather feedback.

52
 IT Asset Management System

Testing
Testing is a critical phase in the development lifecycle of the IT Asset Management
System (ITAMS). It ensures that the system meets functional and non-functional
requirements, performs reliably, and is secure. This section outlines the testing
methodology, strategies, and tools used to validate the ITAMS.
The testing process is aligned with the Agile Methodology, ensuring continuous testing
throughout the development lifecycle. This approach allows for early detection of
defects, faster feedback loops, and improved collaboration between developers and
testers.

Why Testing is Important:

Functional Correctness: Ensures that all features operate as intended.

• This involves testing each feature to confirm its proper functioning according to the
requirements. For example, a login feature should allow users to sign in with valid
credentials and deny access with incorrect ones.
Reliability: Verifies that the system performs consistently across various conditions.

• Reliability tests check how the system behaves under different scenarios, such as
peak usage times or adverse conditions. For instance, an e-commerce site should
handle multiple simultaneous transactions without errors.
Security: Identifies and mitigates potential vulnerabilities.

• Security testing looks for weaknesses that could be exploited by malicious actors.
This includes penetration testing, vulnerability scans, and ensuring data
encryption. For example, protecting user information from unauthorized access.
Usability: Ensures that the system is user-friendly.

• Usability focuses on the ease with which users can interact with the system. This
includes intuitive design, clear instructions, and helpful feedback. A good example
is a shopping cart on a retail website that's easy to navigate and understand.
Performance: Validates that the system can manage the expected workloads.

• Performance testing measures the system's responsiveness, stability, and

scalability under load. This might include stress tests to see how the system
handles high traffic levels, ensuring it remains fast and functional during heavy use.
Testing is conducted at multiple levels, including unit, integration, system, and
acceptance testing, to achieve these objectives

53
 IT Asset Management System

Testing Objectives
The primary objectives of testing the ITAMS are:
1. Functional Correctness:
• Ensure all features function correctly, such as adding assets, updating status,
managing user permissions, generating reports, and integrating with other
systems, to guarantee a seamless and efficient user experience.
o Example: Verify that an asset added through the "Add Asset" form appears in the
"View Assets" list.

2. Reliability:
• Ensure the system operates consistently under different conditions. This includes
varying temperatures, humidity levels, and power supplies, as well as changes in
user loads and network stability, to maintain reliable performance.
o Example: Ensure the system handles concurrent user requests without crashing.

3. Security:
• Identify and address vulnerabilities such as SQL injection, unauthorized access,
and other security flaws by conducting thorough penetration testing, code reviews,
and implementing robust authentication and authorization mechanisms.
o Example: Test for SQL injection by entering malicious input in the "Serial
Number" field.

4. Usability:
• Ensure the system is user-friendly, intuitive, and meets users' needs by providing
clear instructions, responsive support, and efficient performance, enhancing
overall user satisfaction and experience.
o Example: Gather feedback from users on the ease of navigating the system.

5. Performance:
• Ensure the system supports expected workloads, such as accommodating
multiple users simultaneously and handling large datasets efficiently, to maintain
optimal performance and meet user demands without compromising stability or
speed.
o Example: Simulate 100 users accessing the system simultaneously using JMeter.
Testing is conducted at multiple levels, including unit, integration, system, and
acceptance testing, to achieve these objectives.

54
 IT Asset Management System

Testing Levels
Testing is performed at four levels:

1. Unit Testing:
• Evaluates individual components, such as methods or classes, separately. This
helps ensure each part functions correctly before integrating into a larger system.
o Tools: JUnit 5, Mockito.
o Example: Testing the AssetService.saveAsset() method to ensure it
correctly saves an asset to the database.

2. Integration Testing:
• Tests interactions between various components such as controllers, services,
and repositories, ensuring they function together cohesively and correctly.
o Tools: Spring Boot Test, Testcontainers.
o Example: Testing the interaction
between AssetController and AssetService to ensure data flows correctly.

3. System Testing:
• Assesses the complete system through end-to-end testing by evaluating its
performance, functionality, and integration from start to finish.
o Tools: Selenium, Postman.
o Example: Testing the workflow of adding an asset and viewing it in the list.

4. Acceptance Testing:
• Ensures that the system aligns with the specified business requirements,
providing functionality and performance to meet organizational goals and
objectives.
o Tools: Cucumber, Manual Testing.
o Example: Ensuring the system meets user expectations for asset
management.

55
 IT Asset Management System

Testing Types
The ITAMS is subjected to the following types of testing:
1. Functional Testing:

• Ensures that all functionalities of the system or application operate as intended,

performing thorough testing and validation processes to identify and resolve any
issues, thereby guaranteeing a smooth and efficient user experience.
o Examples:
▪ Create, read, update, and delete operations for managing asset data.
▪ Managing the asset list involves filtering, sorting, and organizing essential
data.
2. Non-Functional Testing:

• Performance Testing: Assesses system responsiveness under load, evaluating

how well a system performs under stress conditions. For example, tools like
JMeter simulate concurrent users to measure response times and stability.
• Security Testing: Identifies vulnerabilities (e.g., using tools like OWASP ZAP) to
ensure software is protected against threats by exposing weaknesses that could
be exploited by malicious entities.
• Usability Testing: Collects feedback on the user interface and overall user
experience. It involves observing users as they interact with a product to identify
areas for improvement and ensure ease of use.
3. Regression Testing:

• Ensures that new changes maintain existing functionality by thoroughly testing all
updated features and verifying compatibility with previous versions, thus
preventing disruptions and preserving the integrity of the system.
• Implemented using JUnit and Selenium, this approach allows for automated
testing of web applications, ensuring functionality and reliability by simulating
user interactions and validating expected outcomes through comprehensive test
cases.

56
 IT Asset Management System

Test Automation Strategy

To enhance efficiency and accuracy, a comprehensive test automation strategy has been
implemented: integrating automated testing tools, defining clear objectives, and ensuring
continuous monitoring.
1. What to Automate:
• Repeated tests, such as submitting forms or making API calls, are conducted to
ensure system functionality, accuracy, and reliability.
• Regression tests are conducted to ensure that new changes do not disrupt existing
features, verifying the stability and functionality of the software.
2. Tools:
• JUnit and Mockito: Utilized for comprehensive unit testing and integration testing,
ensuring code reliability, correctness, and functionality in software applications.
• Selenium: A powerful tool for UI automation, enabling automated testing of web
applications across different browsers and platforms efficiently.
• Postman: Utilized for API automation, it allows users to create, test, and manage
APIs efficiently, ensuring seamless integration and functionality.
3. Continuous Integration (CI):
• Automated tests in CI/CD pipeline (GitHub Actions/Jenkins): Automated tests
are seamlessly incorporated into the CI/CD pipeline, enabling continuous testing
and faster feedback during development.
• Tests run on every commit: Every code commits triggers automated tests,
ensuring immediate detection of issues and maintaining high code quality
throughout development.
Example Test Cases
Below are example test cases for the ITAMS:
1. Add Asset:
o Precondition: No assets in the database.
o Steps:
1. Navigate to the "Add Asset" page.
2. Fill in the form with valid data.
3. Click "Add Asset".
o Expected Result: Asset is added to the database and displayed in the "View Assets"
page.
2. Update Asset Status:
o Precondition: An asset exists in the database.
o Steps:
1. Navigate to the "Update Asset" page.
2. Search for the asset by ID or serial number.
3. Update the status to "In Repair".
4. Click "Update".
o Expected Result: Asset status is updated in the database and reflected in the UI.

57
 IT Asset Management System

Tools and Technologies

The following tools and technologies are used for testing the ITAMS:
1. JUnit 5: A modern, feature-rich framework for writing and running unit tests in
Java, ensuring individual components function correctly and meet expected
behaviour.
2. Mockito: A powerful mocking framework used to simulate dependencies in unit
tests, enabling isolated testing of components without relying on external
systems.
3. Spring Boot Test: A testing framework designed for Spring applications, facilitating
integration testing of components like controllers, services, and repositories for
seamless functionality.
4. Selenium: A widely used tool for automated UI testing, allowing validation of web
application functionality across multiple browsers and platforms.
5. Postman: A versatile platform for API testing, enabling developers to validate
endpoints, test data flow, and ensure proper integration between systems.
6. JMeter: A performance testing tool that simulates user loads to measure system
responsiveness, scalability, and stability under high traffic conditions.
7. OWASP ZAP: A security testing tool that identifies vulnerabilities like SQL
injection, XSS, and CSRF, helping to strengthen the system’s security posture.
8. Cucumber: A behaviour-driven development (BDD) tool that allows tests to be
written in plain language, ensuring alignment with business requirements and user
expectations.

Test Plan
1.Scope:
The testing scope includes functional testing of all features (e.g., asset management,
logs) and non-functional testing (e.g., performance, security) to ensure system
reliability and compliance.
2. Approach:
Testing begins with unit tests, followed by integration and system tests, and
concludes with acceptance testing involving end-users to validate functionality and
usability.
3. Schedule:
o Week 1-2: Unit and integration testing to validate individual components and their
interactions.
o Week 3-4: System and acceptance testing to ensure end-to-end functionality and
user satisfaction.
o Week 5: Performance and security testing to assess system scalability and
vulnerability.

58
 IT Asset Management System

Challenges and Solutions

1. Challenge: Ensuring Test Coverage for All Features:
Ensuring every feature is tested can be difficult due to complex workflows and
dependencies.
Solution: Use code coverage tools like JaCoCo to identify untested code, ensuring
comprehensive testing and minimizing gaps in functionality validation.
2. Challenge: Managing Test Data:
Maintaining consistent and realistic test data is challenging, especially when
testing with real databases.
Solution: Leverage Testcontainers to create isolated test environments with real
databases, ensuring accurate and consistent test data for reliable results.
3. Challenge: Automating UI Tests:
Automating UI tests is complex due to frequent changes in the user interface and
the need for maintainable test scripts.
Solution: Implement Selenium with the Page Object Model (POM) to create
maintainable and reusable UI tests, improving efficiency and reducing
maintenance efforts.
Conclusion
Testing is an integral part of the ITAMS development process. By following a structured
testing methodology, the system is validated for functionality, reliability, security, and
performance. The use of modern tools and automation ensures efficient and accurate
testing, resulting in a high-quality product that meets user expectations.
Future enhancements include expanding test coverage, integrating more advanced
security testing, and adopting continuous testing practices in the CI/CD pipeline.

59
IT Asset Management System

Screenshots

60
 IT Asset Management System

Home Page:

61
 IT Asset Management System

Adding New Asset:

62
 IT Asset Management System

List of Asset in Database

63
 IT Asset Management System

Asset Modification:

64
 IT Asset Management System

Maintenance Logs:

65
 IT Asset Management System

Usage Log:

66
 IT Asset Management System

Future Enhancements
The IT Asset Management System (ITAMS) can be further enhanced to meet evolving
organizational needs and improve functionality. Below are some potential future
enhancements:

1. Advanced Asset Management

• Software Asset Management: Enhance the system to track software licenses,

installations, and compliance with licensing agreements. Automate alerts for
renewals, prevent unauthorized installations, and generate reports on software
usage for better cost management.
• Warranty Tracking: Integrate a feature to monitor warranty periods of IT assets,
providing automated alerts before expiration. This ensures timely renewals or
replacements, reducing downtime and preventing unexpected repair costs.
• Maintenance Management: Develop an advanced system for scheduling and
tracking maintenance activities. Implement automated reminders, generate
detailed maintenance reports, and ensure timely servicing to extend asset
lifespan and improve operational efficiency.

2. User Management and Access Control

• Role-Based Access Control (RBAC): Implement a structured access system

where users are assigned specific roles (e.g., Admin, IT Staff, Manager), each with
predefined permissions. This enhances security, prevents unauthorized changes,
and ensures data integrity.
• Active Directory Integration: Seamlessly integrate with Active Directory to enable
centralized authentication and user management. This allows for streamlined
access control, automatic user provisioning, and improved security by enforcing
domain-wide policies and credentials.

3. Reporting and Analytics

• Customizable Reports: Enable users to generate tailored reports based on asset

type, status, location, or other criteria. Provide filtering options, exportable
formats (PDF, Excel), and scheduled report generation for data-driven decision-
making.
• Data Visualization: Integrate advanced visualization tools like Tableau or Power
BI to create interactive dashboards. Use charts, graphs, and heatmaps to analyze
trends, optimize asset usage, and enhance decision-making through real-time
insights.

67
 IT Asset Management System

4. Scalability and Integration

• Cloud Deployment: Transition the system to cloud platforms like AWS or Azure to
enhance scalability, reliability, and accessibility. This enables seamless
performance scaling, automatic updates, and remote access while reducing
infrastructure costs.
• Integration with ITSM Tools: Integrate with IT Service Management (ITSM) tools
like ServiceNow or Jira to streamline IT operations. This ensures seamless
ticketing, asset tracking, and incident management within a unified platform,
improving workflow efficiency.

5. Mobile Accessibility

• Mobile App: Develop a dedicated mobile application enabling users to access,

update, and manage IT assets remotely. Features include barcode scanning, real-
time notifications, and on-the-go reporting for improved efficiency.
• Responsive Web Design: Optimize the web interface for mobile devices using
responsive design principles. Ensure seamless navigation, intuitive UI, and full
functionality across different screen sizes to enhance user experience and
accessibility.

6. Security Enhancements

• Two-Factor Authentication (2FA): Implement 2FA to enhance login security by

requiring an additional verification step, such as a one-time password (OTP) via
email or SMS, reducing the risk of unauthorized access.
• Regular Security Audits: Conduct periodic security audits to assess system
vulnerabilities, ensure compliance with security policies, and mitigate potential
threats. Implement automated scanning tools and manual reviews to strengthen
overall data protection.

7. Automation and Workflows

• Automated Notifications: Set up automated alerts for critical events such as

upcoming maintenance, software license renewals, and warranty expirations.
This ensures timely actions, reducing downtime and preventing unexpected
disruptions.
• Workflow Automation: Implement automated workflows for key processes like
asset approval, procurement, and decommissioning. Streamline approvals, track
progress, and reduce manual effort, improving efficiency and operational
consistency.

68
 IT Asset Management System

8. Inventory Management Features

• Consumable Supplies Tracking: Implement a system to track consumable IT

supplies such as printer cartridges, toners, and cables. Monitor stock levels, set
reorder alerts, and generate usage reports to prevent shortages.
• Barcode/QR Code Integration: Integrate barcode or QR code scanning for quick
and accurate asset identification. Enable users to scan codes using mobile
devices to update inventory, track movement, and streamline asset management.

9. User Interface Enhancements

• Improved UX/UI: Continuously enhance the interface by simplifying navigation,

optimizing layouts, and improving responsiveness. Implement user-friendly
design principles to ensure a seamless experience for both technical and non-
technical users.
• Dark Mode: Introduce a dark mode option to reduce eye strain and enhance
usability in low-light environments. Allow users to switch between light and dark
themes for a personalized experience.

10. Artificial Intelligence (AI) and Machine Learning (ML)

• Predictive Maintenance: Leverage AI/ML algorithms to analyse historical data

and detect patterns that indicate potential equipment failures. Schedule
proactive maintenance to prevent downtime and extend asset lifespan.
• Asset Utilization Optimization: Use AI-driven analytics to study usage trends,
identify underutilized assets, and recommend optimal allocation strategies. This
helps maximize resource efficiency and reduce unnecessary procurement costs.

Summary

These future enhancements will significantly enhance the IT Asset Management

System (ITAMS) by making it more robust, scalable, and adaptable to the organization's
growing needs. As the system evolves, it will not only improve operational efficiency but
also ensure seamless user experiences and secure management of IT assets across the
organization. By implementing automation, advanced analytics, and AI-driven
capabilities, the ITAMS will be better positioned to support the organization’s long-term
goals and adapt to changing technological landscapes.

69
 IT Asset Management System

Conclusion
The IT Asset Management System (ITAMS) project successfully addresses
the challenges of manual IT asset tracking by providing a centralized, automated, and
user-friendly solution. By leveraging modern technologies such as Spring Boot, MySQL,
and Thymeleaf, the system streamlines asset management processes, improves
efficiency, and enhances IT governance.
Key achievements of the project include:
• Improved Asset Visibility: Real-time tracking of IT assets from acquisition to
disposal.
• Cost Reduction: Elimination of wasted resources through better asset utilization
and timely maintenance.
• Enhanced Security: Compliance with licensing agreements and reduced risks of
unauthorized access.
• Scalability: A modular architecture that supports future growth and integration
with other systems.
The ITAMS not only simplifies IT asset management but also empowers
organizations to make data-driven decisions, optimize resource allocation, and maintain
a strong security posture. As a result, it serves as a valuable tool for improving operational
efficiency and supporting long-term organizational success.
Looking ahead, the system can be further enhanced with features like software
asset management, mobile accessibility, and advanced analytics, ensuring it remains
relevant and effective in a rapidly evolving technological landscape.
In conclusion, the ITAMS project demonstrates the successful application of
software engineering principles to solve real-world problems, delivering a robust and
scalable solution that meets the needs of modern organizations.

70
 IT Asset Management System

Appendices
Appendix A: SQL Scripts
• Database Creation Script:

CREATE DATABASE itams;

USE itams;
CREATE TABLE Assets (
AssetID VARCHAR(10) PRIMARY KEY,
ModelName VARCHAR(255),
SerialNumber VARCHAR(255),
PurchaseDate DATE,
AssignedTo VARCHAR(255),
Status ENUM('Active', 'In Repair', 'Decommissioned', 'Inactive'),
Type ENUM('Laptop', 'Desktop', 'Printer', 'Other')
);
CREATE TABLE MaintenanceLog (
LogID INT PRIMARY KEY AUTO_INCREMENT,
AssetID VARCHAR(10) NOT NULL,
MaintenanceDate DATE NOT NULL,
MaintenanceType VARCHAR(255) NOT NULL,
Notes TEXT,
FOREIGN KEY (AssetID) REFERENCES Assets(AssetID)
);
CREATE TABLE UsageLog (
LogID INT PRIMARY KEY AUTO_INCREMENT,
AssetID VARCHAR(10) NOT NULL,
UsageDate DATE NOT NULL,
HoursUsed INT NOT NULL,
ReliabilityScore DECIMAL(5, 2),
FOREIGN KEY (AssetID) REFERENCES Assets(AssetID)
);

• Trigger Script:
DELIMITER //
CREATE TRIGGER before_insert_assets
BEFORE INSERT ON Assets
FOR EACH ROW
BEGIN
DECLARE nextID INT;
DECLARE prefix VARCHAR(2);
IF NEW.Type = 'Laptop' THEN

71
 IT Asset Management System

SET prefix = 'LT';

ELSEIF NEW.Type = 'Desktop' THEN
SET prefix = 'DT';
ELSEIF NEW.Type = 'Printer' THEN
SET prefix = 'PT';
ELSE
SET prefix = 'OT';
END IF;
SELECT IFNULL(MAX(CAST(SUBSTRING(AssetID, 3) AS UNSIGNED)), 0) + 1 INTO nextID
FROM Assets
WHERE AssetID LIKE CONCAT(prefix, '%');

SET NEW.AssetID = CONCAT(prefix, LPAD(nextID, 4, '0'));

END;
//
DELIMITER ;

Appendix B: Sample Test Cases

• Unit Test Example:
@Test
public void testSaveAsset() {
AssetDTO assetDTO = new AssetDTO("Laptop", "SN12345", "2023-10-01", "Active");
Asset asset = new Asset("Laptop", "SN12345", LocalDate.parse("2023-10-01"), "Active");
when(assetRepository.save(any(Asset.class))).thenReturn(asset);
assetService.saveAsset(assetDTO);
verify(assetRepository, times(1)).save(any(Asset.class));
}
• Integration Test Example:

@SpringBootTest
@AutoConfigureMockMvc
public class AssetControllerIntegrationTest {
@Autowired
private MockMvc mockMvc;
@MockBean
private AssetService assetService;
@Test
public void testViewAssets() throws Exception {
when(assetService.getAllAssets()).thenReturn(List.of(new Asset("Laptop", "SN12345",
LocalDate.now(), "Active")));

mockMvc.perform(get("/assets/view"))

72
 IT Asset Management System

.andExpect(status().isOk())
.andExpect(view().name("view_assets"))
.andExpect(model().attributeExists("assets"));
}
}

Appendix C: References
• Spring Boot Documentation: https://spring.io/projects/spring-boot
• MySQL Documentation: https://dev.mysql.com/doc/
• Thymeleaf Documentation: https://www.thymeleaf.org/documentation.html
• JUnit 5 Documentation: https://junit.org/junit5/docs/current/user-guide/

Appendix D: Glossary
• AssetID: A unique identifier for each IT asset, generated based on asset type.
• CRUD: Create, Read, Update, Delete – basic database operations.
• JSP: JavaServer Pages, used for creating dynamic web content.
• Thymeleaf: A server-side Java template engine for web applications.
• Spring Boot: A framework for building stand-alone, production-grade Spring-
based applications.

Appendix F: User Manual

• Adding an Asset:
1. Navigate to the "Add Asset" page.
2. Fill in the form with asset details (e.g., model name, serial number).
3. Click "Submit" to save the asset.
• Viewing Assets:
1. Go to the "View Assets" page.
2. Use the search bar to filter assets by type, status, or assigned user.
• Updating Asset Status:
1. Navigate to the "Update Asset" page.
2. Search for the asset by ID or serial number.
3. Update the status and click "Save".

73
 IT Asset Management System

Acknowledgments
I would like to express my sincere gratitude to everyone who supported and
contributed to the successful completion of the IT Asset Management System (ITAMS)
project.
First and foremost, I extend my heartfelt thanks to Mr. Abdul Wadhood
Rehman, my advisor and guide, for his invaluable guidance, insightful feedback, and
unwavering support throughout the project. His expertise and encouragement were
instrumental in shaping the direction and success of this endeavour.
I am deeply grateful to Indira Gandhi National Open University (IGNOU) for
approving this project proposal and providing the opportunity to work on this meaningful
initiative. The university's support and resources have been crucial in bringing this project
to life.
As the sole developer of this project, I would like to acknowledge my own
efforts, dedication, and perseverance in overcoming challenges and delivering a robust
and functional system.
Lastly, I extend my heartfelt thanks to my family and friends for their constant
encouragement, patience, and support throughout this journey. This project would not
have been possible without the collective support and contributions of everyone
mentioned above. Thank you all for being a part of this achievement.

74
 IT Asset Management System

Glossary
A

• Asset: A piece of IT equipment or software (e.g., laptop, desktop, printer) managed by the
ITAMS.
• AssetID: A unique identifier for each IT asset, generated based on asset type
(e.g., LT0001 for a laptop).
B

• Backend: The server-side part of the application that handles business logic, database
interactions, and request processing.
C

• CRUD: Create, Read, Update, Delete – the four basic operations performed on data in a
database.
• Controller: A component in the backend that handles user requests and returns
appropriate responses (e.g., AssetController).
D

• Database: A structured collection of data stored electronically, used to manage assets,

maintenance logs, and usage logs.
F

• Frontend: The client-side part of the application that handles user interaction and
displays information (e.g., JSP/Thymeleaf pages).
• Foreign Key: A column in a database table that links to the primary key of another table,
enforcing relationships between tables.
J

• JSP (JavaServer Pages): A technology used to create dynamic web pages by embedding
Java code in HTML.
• JDBC (Java Database Connectivity): A Java API used to connect and execute queries with
databases.
M

• MaintenanceLog: A record of maintenance activities performed on an asset, stored in

the MaintenanceLog table.
R

• Repository: A component in the backend that interacts with the database to perform
CRUD operations (e.g., AssetRepository).
S

• Service: A component in the backend that contains business logic (e.g., AssetService for
managing asset operations).
• Spring Boot: A framework for building stand-alone, production-grade Spring-based
applications.

75
 IT Asset Management System

• Thymeleaf: A server-side Java template engine used for rendering dynamic web pages.
• Trigger: A database object that automatically executes a set of actions when a specific
event occurs (e.g., generating AssetID).
U

• UsageLog: A record of usage data for an asset, stored in the UsageLog table.

76
IT Asset Management System

The End

77