CHAPTER I

INTRODUCTION

This section gives a detailed description of the organization for which the system is
developed along with the overview of the application and the problems associated with goals and
the scope of the proposed system. It also specifies the system environment used in the
development of the proposed system and gives a brief introduction about the various
technologies used in the development of the system.

1.1. PROBLEM DEFINITION

1.1.1. OBJECTIVE
The LeadStore CRM web application is designed to revolutionize lead management,
bolster customer relationships, and optimize sales processes for businesses. By centralizing
information, tracking interactions, and tailoring experiences, LeadStore enhances customer
relationships through comprehensive contact management, communication history storage, and
targeted communications. It streamlines lead management by providing tools for lead capture,
organization, and nurturing, facilitating segmentation, tracking, and follow-up to enhance
conversion rates. Through insights and visualization of the sales pipeline, LeadStore enables
businesses to forecast outcomes and automate sales processes, ultimately boosting efficiency.
Moreover, LeadStore prioritizes user experience, offering a user-friendly interface, intuitive
navigation, and customizable dashboards for seamless operation across devices. By spotlighting
products and mission through customizable branding, content publishing, and social media
integration, LeadStore aims to amplify brand awareness.

1.1.2 SCOPE

LeadStore is designed to flexibly adapt to your evolving business needs, offering

customizable options for tailored CRM use. Our platform prioritizes a positive user experience,
boasting intuitive navigation and fast performance to ensure seamless operation across various
devices. With customizable dashboards, you can tailor the interface to your specific

1
preferences, enhancing usability. Streamlining the process of capturing and organizing leads,
LeadStore incorporates advanced features for lead segmentation, tracking, and follow-up,
empowering you to boost conversion rates effectively.

1.1.3 USERS AND LIMITATIONS

Users of LeadStore

Admins:

Role: Responsible for managing the entire system, including user management (add, edit,
delete users), lead management, contact management, report generation, and billing
operations.

Capabilities: Full access to all features and data, system settings, and administrative tools.

Sales Representatives:

Role: Primarily use the system for adding, updating, and tracking leads and contacts.

Capabilities: Access to lead and contact management, and limited reporting functions specific
to their activities.

Billing Staff:

Role: Uses the system to manage billing processes, including generating bills based on
services or products purchased and managing financial records.

Capabilities: Access to billing features and related reports.

2
1.2 SYSTEM ENVIRONMENT

The hardware and software system environment details are as follows.

1.3.1 HARDWARE CONFIGURATION

The following are the minimum hardware requirements that are essential for this project:

● RAM: 8 GB RAM
● Storage: 50 GB
● Processor: Corei5

1.3.2 SOFTWARE CONFIGURATION:

The following are the minimum software requirements that are essential for this
application:

● Operating System: Windows10+

● Front-end: HTML 5, CSS 3, Typescript 1.8.5, Angular (Framework)
● Back-end: Java, Spring Boot (Framework), MySQL DataBase.
● Editor: Visual studio code.

3
 CHAPTER II
SYSTEM ANALYSIS

System analysis is the overall analysis of the system before implementation and for arriving
at a precise solution. Careful analysis of a system before implementation prevents post
implementation problems that might arise due to bad analysis of the problem statement. Thus, the
necessity for systems analysis is justified. The analysis is the first crucial step, a detailed study of
the various operations performed by a system and their relationships within and outside of the
system. Analysis is defining the boundaries of the system that will be followed by design and
implementation.

2.1 SYSTEM DESCRIPTION

2.1.1 EXISTING SYSTEM:

The existing CRM systems in the industry often combine extensive functionalities such
as sales tracking, marketing automation, and customer interaction management. Despite their
robust capabilities, these systems can be complex and require substantial investments in cost
and technical training. This complexity mainly stems from their multifaceted integration and
advanced feature sets, which can be daunting for smaller businesses without dedicated IT
support. This situation underscores the necessity for CRM solutions that are more streamlined,
affordable, and easier to use, catering specifically to the needs of smaller enterprises that
prioritize simplicity and cost-efficiency.

4
DRAWBACKS:

● Limited Accessibility: Users are restricted from accessing the CRM platform directly,
which may inconvenience those who prefer remote or flexible access.

● Insufficient Product Descriptions: Product descriptions within the CRM may lack detail or
relevancy, hindering users' ability to make informed decisions.

● Cumbersome Processes: Navigating through the CRM website may consume excessive
time and energy, particularly for users unfamiliar with its interface or features.

● Inadequate Data Protection: Older CRM websites may lack robust security measures,
leaving sensitive customer data vulnerable to breaches or unauthorized access.

2.1.2 PROPOSED SYSTEM

The proposed Lead Management System represents a comprehensive solution aimed at

enhancing the efficiency and effectiveness of lead management processes within organizations.
By integrating user-friendly interfaces with robust functionalities, this system streamlines the
management of leads from acquisition to conversion. Key features include the ability to add,
edit, and delete leads, as well as generate insightful reports for informed decision-making. With
role-based access controls, administrators, sales representatives, and billing staff can seamlessly
collaborate within the system, each fulfilling their respective responsibilities. Through
automation and customization capabilities, the proposed system empowers organizations to
optimize their lead management workflows, ultimately driving higher conversion rates and
improved business outcomes.

5
ADVANTAGES:

➢ User-friendly:
The system will feature a clean, intuitive interface that minimizes complexity and maximizes
usability. The design will focus on ease of navigation, with common tasks streamlined and more
accessible. Customizable dashboards will allow users to tailor their workspace to fit their
specific needs, improving efficiency and satisfaction.

➢ Fast information flow:

By leveraging modern technologies such as in-memory data processing and real-time data
updates, the CRM system will ensure that information flows quickly across different parts of
the organization. This acceleration in data flow allows for more timely decisions and responses
to customer inquiries and market changes, enhancing overall business agility.

➢ Assurance of data consistency:

The system will incorporate robust data management practices, including centralized data
storage, to ensure all information is consistent and up to date across the platform. Automatic
synchronization features will eliminate discrepancies between different data sources, and
built-in validation rules will prevent data entry errors, maintaining high data quality and
reliability.

➢ Robust Data Security:

The proposed system will incorporate advanced security protocols, including data encryption,
secure access controls, and regular security audits, to protect sensitive customer information
from unauthorized access and data breaches. This will ensure compliance with privacy
regulations and enhance trust among users.

6
2.2 USE CASE MODEL

A UML use case diagram is the primary form of system/software requirements for a
new software program underdeveloped. Use cases specify the expected behavior. It is an effective
technique for communicating system behavior in the user's terms by specifying all externally
visible system behavior.

Figure 2.2 Use Case Model Design of LeadStore

7
2.2.1 MODULE DESCRIPTION

A module refers to a self-contained unit of code that performs a specific set of related
functions or tasks. A module is typically designed to be reusable and can be integrated with other
modules to build a larger system or application.

Modules of the project

● Home Page

● Sign Up

● Sign In

● Profile

● Lead Management

● Contact Management

● Reporting

● Billing

● Admin Panel

● Log out

1. Home Page
Features:
● Overview of LeadStore CRM functionalities.
● Quick access to different modules like Lead Management, Contact Management, etc.
● Dashboard displaying key metrics and alerts.

8
2. Sign Up
Features:
● User registration for new administrators and sales team members.
● Collect essential information (name, email, role, etc.).
● Email verification and account activation process.

3. Sign In
Features:
● Secure login portal for existing users.
● Multi-factor authentication for enhanced security.

4. Profile
Features:
● Manage user profiles with options to edit personal and professional details.
● Change passwords and manage other security settings.
● Configure notification preferences.

5. Lead Management
Features:
● Add, edit, and delete leads.
● Organize and categorize leads into different stages.
● Search and filter leads based on various criteria.

6. Contact Management
Features:
● Add, update, or remove contact information.
● Group contacts into categories (e.g., customer, supplier, partner).
● Track interaction history.

9
7. Reporting
Features:
● Customizable reports on sales, leads, performance, etc.
● Export data for external use.

8. Billing
Features:
● Invoice generation for transactions.
● Export billing data for financial analysis and external audits.

9. Admin Panel
Features:
● Comprehensive administration controls for managing all aspects of the CRM.

● User management, role assignments, and permissions govern user access and actions within
a system. Administrators control user accounts, assign roles, and manage permissions to
maintain security and data integrity. This ensures that users have appropriate access to
system features and data based on their roles and responsibilities.

10. Log Out

Features:
● Secure sign-out procedure for users.
● Clear session data to prevent unauthorized access.

10
2.3 SOFTWARE REQUIREMENTS SPECIFICATION

2.3.1 FUNCTIONAL REQUIREMENTS

● User registration and login: Users should be able to create accounts and log in to the

platform with their credentials.

● Admin Authentication and Management: The platform should provide a secure login

system for admins, with capabilities to manage user accounts and roles. Admins should be

able to activate, deactivate, or delete user accounts and assign different levels of access.

● Lead Management: Admins should be able to add, edit, delete, and categorize leads. The

system should allow the filtering and searching of leads based on various criteria to

streamline lead handling. Features should include tracking lead sources and interaction

history.

● Contact Management: This module should allow admins to manage contacts effectively.

Features include adding new contacts, updating existing contact information, categorizing

contacts into groups, and documenting interaction history.

● Sales Pipeline Tracking: The CRM should provide tools to track the progress of leads

through different sales pipeline stages from prospecting to closure. This module should

include visual representations of the pipeline and the ability to update the status of leads

as they move through stages.

● Reporting and Analytics: The platform should offer comprehensive reporting tools that

generate customizable reports on sales performance, lead conversion rates, and customer

engagement. Analytics should provide insights into business trends and help in strategic

11
 decision-making.

● Billing Integration: Billing functionality is seamlessly integrated into the CRM system.

Admins can generate bills for completed transactions or services rendered. Billing history

and records are maintained for reference and auditing purposes.

2.3.2 NON-FUNCTIONAL REQUIREMENTS USABILITY

● Performance: The platform should deliver consistent and responsive performance under

normal operating conditions. Response times for user interactions, such as loading pages,

retrieving data, and processing transactions, should be optimized to minimize latency.

Performance metrics should be monitored and regularly evaluated to identify bottlenecks

and optimize system efficiency.

● Reliability: The platform should demonstrate high reliability and availability, with

minimal downtime or service disruptions. Fault tolerance mechanisms, such as

redundancy and failover systems, should be in place to ensure continuous operation in the

event of hardware or software failures.

● Security: The platform must adhere to industry-standard security protocols and best

practices to safeguard user data. User authentication and authorization mechanisms should

be robust to prevent unauthorized access to the system. User data must be securely stored

and protected against unauthorized access, tampering, or data breaches.

● Usability: The user interface (UI) should be intuitive and user-friendly, with clear

labeling, consistent design elements, and easy-to-understand instructions.

12
 ● Scalability: The platform should be designed with scalability in mind to accommodate

potential growth in user traffic and data volume. Scalability should extend to both

horizontal scaling (adding more servers or resources) and vertical scaling (upgrading

existing infrastructure).

● Interoperability: The platform should support interoperability with other systems and

services, allowing seamless integration with third-party applications, APIs, and data

sources. Standard data exchange formats and protocols should be used to facilitate data

interchange and communication between different system.

2.4 TEST PLAN

A test plan documents the strategy that will be used to verify and ensure that a product or
system meets its design specifications and other requirements. A plan typically contains a detailed
understanding of the eventual workflow.

TESTING FACTORS

Test factors or issues means that a testing issue applies to software to achieve quality.
All the functional features specified in the requirement analysis are to be tested.

The testing factors are,

● System reliability
● System usability
● Data Scalability

2.4.1 TEST SCOPE

Every functionality of the proposed application is considered as important and need to be

tested for the good working of the application. So, all the functionalities will come under the

13
inscope of the system. The scope of testing the application is to make the developers understand
the bugs, errors that are occurring in the application. It is also to solve the problems that may occur
during the usage, or at least identify the errors and give a detailed recommendation of best
practices to the users to minimize the error while operating the application.

Below are the types of testing that will be supported

1. Manual Testing (Regression & Data Validation)

2. API Testing

The below platforms, browsers, and devices are considered in scope of testing

1. Windows/Google Chrome (Desktop), iOS/Safari (Secondary).

2.5 TESTING FUNCTIONS

Test functions or issue means that a testing issue to apply on software to achieve quality.
All the functional features specified in the requirement analysis are to be tested.

The testing functionalities are:

● Authorization
● Data integrity
● System reliability
● System security
● Simplicity
● Response time of the system
● Overall efficiency

2.5.1 TEST FACTORS

● Authorization: Whether the user is valid or not to correct the application. Ensures the user
credentials are correct for accessing the environment.

14
● Access Control: Authorized to access specific services. Separates generic and specific access
control to avoid data breaches.

● Correctness: Meet user requirements in terms of inputs and outputs.

● Ease of Use: User friendly screens.

● Reliability: Recover from abnormal situations. During unexpected issues the server should
remain un-manipulated.

● Performance: Each process must be executed within the time limit specified and could be
optimized based on the time taken.

● Maintainable: Long time serviceable to customers. Ex: Adding rules as per user demand.

2.5.2 TESTING TECHNIQUE

REQUIREMENTS TESTING

Modules and the integrated system were tested to ensure it meets all the requirements.

INTEGRATION TESTING

Integration testing as the name implies the individual units are integrated into one whole
module and tested for its data flow and the functionality of the application. For this website, each
functionality created is tested with all the pages as an integration testing.

15
SYSTEM TESTING

System testing ensures that the entire integrated software system meets requirements. It tests
a configuration to ensure known and predictable results. System testing is based on process
descriptions and flow, emphasizing pre-driven process links and integration points.

PERFORMANCE TESTING

Performance Testing is a type of testing to ensure software applications will perform well
under their expected workload. Features and Functionality supported by a software system is not
the only concern. A software application's performance like its response time, reliability, resource
usage and scalability do matter. The goal of Performance Testing is not to find bugs but to
eliminate performance bottlenecks.

FUNCTIONAL TESTING

Functional testing verifies that each function of the software application operates in
conformance with the requirement specification. It involves checking of User Interface, security,
client/ server applications, and functionality of the application under test. LeadStore underwent
functional testing and tested every functionality including report generation, etc.

RECOVERY TESTING

Recovery Testing is defined as a software testing type that is performed to determine

whether operations can be continued after a disaster or after the integrity of the system has been
lost.

16
 CHAPTER III

SYSTEM DESIGN

System design is the process of defining the elements of a system such as the
architecture, modules, and components, the different interfaces of those components, and the
data that goes through that system. It is meant to satisfy the specific needs and requirements of a
business or organization through the engineering of a coherent and well-running system. System
design implies a systematic approach to the design of a system.

3.1 ARCHITECTURAL DESIGN

Architectural design is the process of defining a collection of the structure of data,

hardware and software components, and their interfaces to establish the framework for the
development of a computer-based system. It focuses on the decomposition of a system into
different components and their interactions to satisfy functionality and performance requirements
as well as non-functional requirements of the system. The software that is built for
computer-based systems can exhibit one of the many architectural styles or patterns. An
architectural pattern is a general, reusable solution to a commonly occurring problem in software
architecture within a given context.

17
Figure 3.1 Architectural Diagram

18
3.2 CLASS DIAGRAM

Structural design is the methodical investigation of the stability, strength and rigidity of
structures. The basic objective in structural analysis and design is to produce a structure capable
of resisting all applied loads without failure during its intended life.

Figure 3.2 Class Diagram of LeadStore

19
3.3 BEHAVIOURAL DESIGN

Behavioural models show the dynamic behavior of the system as its executes. They show
what happens or what’s supposed to happen when a system occurs with an error.

3.3.1 ACTIVITY DIAGRAM

An Activity diagram is a graphical representation of an executed set of procedural system

activities and is considered a state chart diagram variation. Activity Diagrams is used to illustrate
the flow of control in a system and refer to the steps involved in the execution of a use case.
Sequential processing and concurrent processing of activities is designed using activity
diagrams. It captures the dynamic behavior of the system. Activity diagrams describe parallel
and conditional activities, use cases and system functions at a detailed level. This diagram
depicts the graphical representations of workflows of stepwise activities and actions for
generating reports, classification/regression, handling feature selection, and data import.

Figure 3.3.1 Activity Diagram of LeadStore

20
3.3.2 SEQUENCE DIAGRAM

A sequence diagram simply depicts interaction between objects in a sequential order i.e.
the order in which these interactions take place. We can also use the terms event diagrams or
event scenarios to refer to a sequence diagram. Sequence diagrams describe how and in what
order the objects in a system function.

Figure 3.3.2 Sequence Diagram of LeadStore

21
3.4 TABLE DESIGN

A table is a collection of rows, where each row holds a data record. Each table row
consists of key and data fields, which are defined when a table is created. In addition, a table has a
specified storage, can support a defined maximum read and write throughout, and has a maximum
size.

3.4.1 ADMIN

The Admin table stores information about system administrators, including their
username, password, email, and creation date. Administrators have special privileges to manage
users and oversee system settings.

Table 3.4.1 Admin

FIELD NAME DATA TYPE DESCRIPTION

AdminID INT Unique identifier for each admin
Username VARCHAR Username of the admin
Password VARCHAR Password of the admin

Email VARCHAR Email address of the admin

CreationDate DATE Date when the admin account

was created

Constraints: - PK_AdminID: PRIMARY KEY (AdminID)

22
3.4.2 SALES REPRESENTATIVE

"Sales Representative" empowers users to manage leads, contacts, and sales

opportunities efficiently, facilitating streamlined sales processes and enhanced customer
relationship management.
Table 3.4.2 Sales Representative

FIELD NAME DATA TYPE DESCRIPTION

SalesRepID INT Unique identifier for each sales

representative
Username VARCHAR Username of the sales
representative
Password VARCHAR Password of the sales
representative
Email VARCHAR Email address of the sales
representative
CreationDate DATE Date when the sales
representative account was
created

Constraints: - PK_SalesRepID: PRIMARY KEY (SalesRepID)

3.4.3 BILLING STAFF

"Billing Staff" facilitates efficient creation and logging of invoices, detailing financial
transactions and payment statuses. This functionality supports accurate financial tracking and
ensures smooth billing processes within the organization.

Table 3.4.3 Billing Staff

FIELD NAME DATA TYPE DESCRIPTION

BillingStaffID INT Unique identifier for each billing
staff
Username VARCHAR Username of the billing staff
Password VARCHAR Password of the billing staff
Email VARCHAR Email address of the billing staff

23
 CreationDate DATE Date when the billing staff
account was created

Constraints: - PK_BillingStaffID: PRIMARY KEY (BillingStaffID)

3.4.4 LEAD

"Lead" allows users to input essential details of potential business opportunities into the
system, facilitating efficient lead tracking and management within the organization.

Table 3.4.4 Add Lead

NAME DATA TYPE DESCRIPTION

LeadID INT Unique identifier for each lead
Lead Name VARCHAR Name of the lead
Contact Info VARCHAR Contact information of the lead
Status VARCHAR Status of the lead (e.g., active,
inactive)
Source VARCHAR Source of the lead (e.g., website,
referral)
CreationDate DATE Date of the last contact with the
lead

Constraints: - PK_LeadID: PRIMARY KEY (LeadID)

3.4.5 CONTACT

"Contact" enables users to swiftly input new contact details, fostering efficient
communication and relationship-building efforts within the organization.

Table 3.4.5 Lead

NAME DATA TYPE DESCRIPTION
ContactID INT Unique identifier for each
contact
LeadID INT Foreign key referencing the lead
associated with the contact
First Name VARCHAR First Name of the contact

24
 Last Name VARCHAR First Name of the contact
Email VARCHAR Email address of the contact
Phone VARCHAR Phone number of the contact

Constraints:
- PK_ContactID: PRIMARY KEY (ContactID)
- FK_LeadID_Contact: FOREIGN KEY (LeadID) REFERENCES Lead(LeadID)

3.4.6 REPORT

"Report" allows users to swiftly generate and record key insights or summaries regarding
sales, marketing, or other relevant activities. This feature aids in informed decision-making and
facilitates effective communication within the organization.

Table 3.4.5 Lead

NAME DATA TYPE DESCRIPTION
ReportID INT Unique identifier for each report
LeadID INT Foreign key referencing the lead
associated with the report
ReportName VARCHAR(50) Name of the report
ReportDate DATE Date when the report was
generated
ReportContent TEXT Content or Detail of the report

Constraints:
- PK_ReportID: PRIMARY KEY (ReportID)
- FK_LeadID_Report: FOREIGN KEY (LeadID) REFERENCES Lead(LeadID)

3.4.7 BILLING

"Billing" permits users to efficiently create and log invoices, detailing financial
transactions and payment statuses. This functionality supports accurate financial tracking and
ensures smooth billing processes within the organization.

25
 Table 3.4.7 Billing
NAME DATA TYPE DESCRIPTION
BillingID INT Unique identifier for each invoice
LeadID INT Foreign key referencing the lead
associated with the billing
ContactID INT Foreign key referencing the
contact associated with the
billing
BillingDate DATE Date when the billing was
generated

Constraints:
- PK_BillingID: PRIMARY KEY (BillingID)
- FK_LeadID_Billing: FOREIGN KEY (LeadID) REFERENCES Lead(LeadID)
- FK_ContactID_Billing: FOREIGN KEY (ContactID) REFERENCES Contact(ContactID)

26
3.5 USER INTERFACE DESIGN

User Interface (UI) Design focuses on anticipating what users might need to do and
ensuring that the interface has elements that are easy to access, understand, and use to facilitate
those actions. UI brings together concepts from interaction design, visual design, and
information architecture. UI Design is the discipline of designing software interfaces for devices,
ideally with a focus on maximizing efficiency, responsiveness and aesthetics to foster a good
user experience. It is typically employed for products or services that require interaction for the
user to get what they need from the experience. The interface should allow a user to perform any
required tasks to complete the function of the product or service. It is a point of interaction
between the user and the hardware and/or software they are using.

Screen 3.5.1 Admin Authentication Page

27
 Screen 3.5.2 Contact

Screen 3.5.3 Lead Management

28
 Screeen 3.5.4 Lead Mangement

Screen 3.5.5 Contect Management

29
Screen 3.5.6 Update lead and Contact Details

30
3.6 DEPLOYMENT DESIGN

A deployment diagram illustrates the physical deployment of software components

across different nodes in a system architecture. It depicts how software artifacts are deployed on
hardware nodes such as servers, devices, or containers, along with the communication pathways
between these components. Deployment diagrams provide a high-level overview of the system's
physical architecture, including the distribution of software components, databases, and external
services, aiding in understanding system deployment strategies and infrastructure requirements.

Figure 3.6 Deployment design of LeadStore

31
3.7 NAVIGATION DESIGN
Navigation design encompasses the layout and structure of interactive elements within a
user interface to enable smooth and intuitive movement through an application or website. It
focuses on organizing menus, links, and buttons in a user-friendly manner to facilitate easy access
to content and features, ultimately enhancing user experience and usability.

Figure 3.7 Navigation design of LeadSt

32
3.8 CODE DESIGN

SIGN UP

import { HttpClient } from '@angular/common/http';

import { Router } from '@angular/router';
import { Injectable } from '@angular/core';

@Injectable({
providedIn: 'root'
})
export class AuthService {
private isLoading: boolean = false;
private returnUrl: string = '/dashboard';
constructor(private http: HttpClient, private router: Router) { }

// Function to login users

loginUser(params: any): void {
this.isLoading = true; // Begin loading

this.http
.get<any>('https://api.leadstore.com/auth/login', { params })
.subscribe({
next: (response) => {
if (response.code == 200 && response.result.status == 'success') {
// Assuming token or similar authentication method
localStorage.setItem('token', response.result.token);
this.isLoading = false;
alert('Login successful!');
this.router.navigateByUrl(this.returnUrl); // Navigate to dashboard after login

33
 } else if (response.code == 200) {
this.isLoading = false;
alert(`Login failed: ${response.result.msg}`);
} else {
this.isLoading = false;
alert('Please check input fields!');
}
},
error: (err) => {
this.isLoading = false;
console.error('Error:', err);
alert('An error occurred during login.');
}
});
}
}

SIGN IN

import { HttpClient } from '@angular/common/http';

import { Router } from '@angular/router';
import { Injectable } from '@angular/core';

@Injectable({
providedIn: 'root'
})
export class AuthService {

private isLoading: boolean = false;

private returnUrl: string = '/dashboard';

34
constructor(private http: HttpClient, private router: Router) { }

// Function to sign in users

signInUser(username: string, password: string): void {
this.isLoading = true; // Begin loading

// Prepare login data

const loginData = {
username: username,
password: password
};

this.http
.post<any>('https://api.leadstore.com/auth/login', loginData)
.subscribe({
next: (response) => {
if (response.code == 200 && response.result.status == 'success') {
// Assuming token or similar authentication method
localStorage.setItem('userToken', response.result.token);
this.isLoading = false;
alert('Sign-in successful!');
this.router.navigateByUrl(this.returnUrl); // Navigate to dashboard after sign-in
} else {
this.isLoading = false;
alert(`Sign-in failed: ${response.result.message}`);
}
},
error: (err) => {
this.isLoading = false;

35
 console.error('Error:', err);
alert('An error occurred during sign-in.');
}
});
}
}

PROFILE

import { Component, OnInit } from '@angular/core';

import { HttpClient } from '@angular/common/http';

@Component({
selector: 'app-profile',
templateUrl: './profile.component.html',
styleUrls: ['./profile.component.css']
})
export class ProfileComponent implements OnInit {
user: any; // Variable to store user data
isLoading: boolean = false; // Variable to track loading state

constructor(private http: HttpClient) { }

ngOnInit(): void {
this.isLoading = true; // Start loading

// Fetch user data from API endpoint

this.http.get<any>('https://api.example.com/user/profile')
.subscribe({
next: (response) => {

36
 this.user = response.data; // Assuming user data is in 'data' property
this.isLoading = false; // Stop loading
},
error: (err) => {
console.error('Error:', err);
this.isLoading = false; // Stop loading even if there's an error
}
});
}
}

LEAD MANAGEMENT

// lead.service.ts

import { Injectable } from '@angular/core';

import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable({
providedIn: 'root'
})
export class LeadService {
private apiUrl = 'https://api.example.com/leads';

constructor(private http: HttpClient) { }

getLeads(): Observable<any[]> {
return this.http.get<any[]>(this.apiUrl);
}

37
 addLead(lead: any): Observable<any> {
return this.http.post<any>(this.apiUrl, lead);
}

updateLead(leadId: number, lead: any): Observable<any> {

return this.http.put<any>(`${this.apiUrl}/${leadId}`, lead);
}

deleteLead(leadId: number): Observable<any> {

return this.http.delete<any>(`${this.apiUrl}/${leadId}`);
}
// Add other methods as needed (e.g., categorizeLead)
}
// lead-management.component.ts
import { Component, OnInit } from '@angular/core';
import { LeadService } from './lead.service';

@Component({
selector: 'app-lead-management',
templateUrl: './lead-management.component.html',
styleUrls: ['./lead-management.component.css']
})
export class LeadManagementComponent implements OnInit {
leads: any[];
constructor(private leadService: LeadService) { }
ngOnInit(): void {
this.loadLeads();
}
loadLeads(): void {

38
 this.leadService.getLeads().subscribe(leads => {
this.leads = leads;
});
}

//Add lead
addLead(lead: any): void {
this.leadService.addLead(lead).subscribe(() => {
this.loadLeads(); // Refresh the list after addition
});
}
//Delete Lead
updateLead(leadId: number, lead: any): void {
this.leadService.updateLead(leadId, lead).subscribe(() => {
this.loadLeads(); // Refresh the list after update
});
}
//Update lead
deleteLead(leadId: number): void {
this.leadService.deleteLead(leadId).subscribe(() => {
this.loadLeads(); // Refresh the list after deletion
});
}
}

39
CONTACT MANAGEMENT

// contact.service.ts

import { Injectable } from '@angular/core';

import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable({
providedIn: 'root'
})
export class ContactService {
private apiUrl = 'https://api.example.com/contacts';

constructor(private http: HttpClient) { }

getContacts(): Observable<any[]> {
return this.http.get<any[]>(this.apiUrl);
}

addContact(contact: any): Observable<any> {

return this.http.post<any>(this.apiUrl, contact);
}

updateContact(contactId: number, contact: any): Observable<any> {

return this.http.put<any>(`${this.apiUrl}/${contactId}`, contact);
}

deleteContact(contactId: number): Observable<any> {

return this.http.delete<any>(`${this.apiUrl}/${contactId}`);

40
 }

// Add other methods as needed (e.g., categorizeContact)

}
// contact-management.component.ts

import { Component, OnInit } from '@angular/core';

import { ContactService } from './contact.service';

@Component({
selector: 'app-contact-management',
templateUrl: './contact-management.component.html',
styleUrls: ['./contact-management.component.css']
})
export class ContactManagementComponent implements OnInit {
contacts: any[];

constructor(private contactService: ContactService) { }

ngOnInit(): void {
this.loadContacts();
}

loadContacts(): void {
this.contactService.getContacts().subscribe(contacts => {
this.contacts = contacts;
});
}

addContact(contact: any): void {

41
 this.contactService.addContact(contact).subscribe(() => {
this.loadContacts(); // Refresh the list after addition
});
}

updateContact(contactId: number, contact: any): void {

this.contactService.updateContact(contactId, contact).subscribe(() => {
this.loadContacts(); // Refresh the list after update
});
}

deleteContact(contactId: number): void {

this.contactService.deleteContact(contactId).subscribe(() => {
this.loadContacts(); // Refresh the list after deletion
});
}
}
<!-- contact-management.component.html -->

<div *ngFor="let contact of contacts">

<!-- Display contact information -->
<button (click)="updateContact(contact.id, contact)">Edit</button>
<button (click)="deleteContact(contact.id)">Delete</button>
</div>

REPORTING

// report.service.ts

42
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable({
providedIn: 'root'
})
export class ReportService {
private apiUrl = 'https://api.example.com/reports';

constructor(private http: HttpClient) { }

getReports(): Observable<any[]> {
return this.http.get<any[]>(this.apiUrl);
}

// Add other methods as needed (e.g., getReportById, generateReport, etc.)

}
// report.component.ts

import { Component, OnInit } from '@angular/core';

import { ReportService } from './report.service';

@Component({
selector: 'app-report',
templateUrl: './report.component.html',
styleUrls: ['./report.component.css']
})
export class ReportComponent implements OnInit {
reports: any[];

43
 constructor(private reportService: ReportService) { }

ngOnInit(): void {
this.loadReports();
}

loadReports(): void {
this.reportService.getReports().subscribe(reports => {
this.reports = reports;
});
}
}
// app-routing.module.ts

import { NgModule } from '@angular/core';

import { Routes, RouterModule } from '@angular/router';
import { ReportComponent } from './report/report.component';

const routes: Routes = [

{ path: 'reports', component: ReportComponent },
// Add other routes as needed
];

@NgModule({
imports: [RouterModule.forRoot(routes)],
exports: [RouterModule]
})
export class AppRoutingModule { }

44
BILLING

// billing.service.ts
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
@Injectable({
providedIn: 'root'
})
export class BillingService {
private apiUrl = 'https://api.example.com/billing';
constructor(private http: HttpClient) { }
generateInvoice(leadId: number): Observable<any> {
return this.http.post<any>(`${this.apiUrl}/invoices`, { leadId });
}
// Add other methods as needed (e.g., getInvoices, makePayment, etc.)
}
// invoice-generation.component.ts
import { Component } from '@angular/core';
import { BillingService } from './billing.service';
@Component({
selector: 'app-invoice-generation',
templateUrl: './invoice-generation.component.html',
styleUrls: ['./invoice-generation.component.css']
})
export class InvoiceGenerationComponent {
isLoading: boolean = false;
constructor(private billingService: BillingService) { }
generateInvoice(leadId: number): void {
this.isLoading = true;

45
 this.billingService.generateInvoice(leadId).subscribe(() => {
this.isLoading = false;
// Handle success or show notification
}, () => {
this.isLoading = false;
// Handle error or show error message
});
}
}
// billing-history.component.ts
import { Component, OnInit } from '@angular/core';
import { BillingService } from './billing.service';
@Component({
selector: 'app-billing-history',
templateUrl: './billing-history.component.html',
styleUrls: ['./billing-history.component.css']
})
export class BillingHistoryComponent implements OnInit {
invoices: any[];
constructor(private billingService: BillingService) {
ngOnInit(): void {
this.loadInvoices();
}
loadInvoices(): void {
this.billingService.getInvoices().subscribe(invoices => {
this.invoices = invoices;
});
}
}

46
ADMIN PANEL

// user-management.component.ts
import { Component, OnInit } from '@angular/core';
import { UserService } from './user.service';
@Component({
selector: 'app-user-management',
templateUrl: './user-management.component.html',
styleUrls: ['./user-management.component.css']
})
export class UserManagementComponent implements OnInit {
users: any[];
constructor(private userService: UserService) { }
ngOnInit(): void {
this.loadUsers();
}
loadUsers(): void {
this.userService.getUsers().subscribe(users => {
this.users = users;
});
}
deleteUser(userId: number): void {
this.userService.deleteUser(userId).subscribe(() => {
this.loadUsers(); // Refresh the list after deletion
});
}
}
// user.service.ts

47
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Observable } from 'rxjs';
@Injectable({
providedIn: 'root'
})
export class UserService {
private apiUrl = 'https://api.example.com/users';
constructor(private http: HttpClient) { }
getUsers(): Observable<any[]> {
return this.http.get<any[]>(this.apiUrl);
}
// Add other methods as needed (e.g., addUser, editUser, etc.)
}

LOGOUT

// auth.service.ts

import { Injectable } from '@angular/core';

import { Router } from '@angular/router';

@Injectable({
providedIn: 'root'
})
export class AuthService {
constructor(private router: Router) { }
logout(): void {
// Clear user authentication tokens or session data
// For example:

48
 localStorage.removeItem('token');
// Redirect to the login page
this.router.navigateByUrl('/login');
}
}
// navigation.component.ts

import { Component } from '@angular/core';

import { AuthService } from './auth.service';
@Component({
selector: 'app-navigation',
templateUrl: './navigation.component.html',
styleUrls: ['./navigation.component.css']
})
export class NavigationComponent {
constructor(private authService: AuthService) { }

logout(): void {
this.authService.logout();
}
}
// app.module.ts
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
import { NavigationComponent } from './navigation/navigation.component';
import { AuthService } from './auth.service';
@NgModule({
declarations: [

49
 AppComponent,
NavigationComponent
],
imports: [
BrowserModule,
AppRoutingModule
],
providers: [AuthService],
bootstrap: [AppComponent]
})
export class AppModule { }

50
 CHAPTER IV

SYSTEM TESTING

In a software development project, errors can be injected at any stage during the
development. Testing performs a very critical role for quality and for ensuring the reliability of
software. During testing, the program to be tested is executed with a set of test cases, and the
output of the program for the test cases is evaluated to determine if the program is performing as
it is expected to. The main objective of testing is to uncover errors from the system. For the
uncovering process users must give proper input data to the system. So, users should be more
conscious of giving input data. It is important to give correct inputs to efficient testing. Testing is
a process of executing a program with the intent of finding an error.

Testing is a crucial element of software quality assurance and presents ultimate review of
specification, design and coding. System Testing is an important phase. Testing represents an
interesting anomaly for the software. Thus, a series of testing are performed for the proposed
system before the system is ready for user acceptance testing. A good test case is one that has a
high probability of finding an undiscovered error. A successful test is one that uncovers an
undiscovered error.

4.1 TEST CASES AND TEST REPORTS

S. TEST DESCRIPTION EXPECTED RESULT ACTUAL PASS/

No
RESULT FAIL

Verify whether users User is successfully logged in Pass Pass

1. can register with valid with valid credentials
credentials.

51
 Verify whether users Correct error messages are Pass Pass
can log in with correct displayed for invalid login
2. username and attempts
password.

Verify whether proper Passwords are securely Pass Pass

3. error messages display encrypted, and security
for invalid login measures are in place
attempts.

Verify whether Dashboard correctly displays Pass Pass

4. password encryption all relevant user information
and security measures
are implemented.

Verify whether the New leads are added Pass Pass

5. dashboard displays successfully with all fields
relevant information correctly filled
correctly.

6. Verify whether new Lead information is accurately Pass Pass

leads can be added with updated in the system
all required fields filled.

7. Verify whether editing Leads can be categorized and Pass Pass

and updating lead filtered according to set criteria
information functions
correctly.

8. Verify whether lead Contact information is Pass Pass

categorization and accurately updated in the
filtering functionality is system
operational.

52
 9. Verify whether editing Contacts are successfully Pass Pass
and updating contact organized into specified
information functions groups/lists
properly.

Verify whether User interface allows for easy Pass Pass

categorizing and navigation and use
10. organizing contacts into
groups or lists works as
expected.

Verify whether Integrations with third-party Pass Pass

integration with services operate as expected
11. third-party tools or
services (e.g., email
marketing platforms,
CRM integrations)
functions correctly.

Verify whether the Accessibility features meet the Pass Pass

application functions needs of users with disabilities
12. correctly on different
web browsers (e.g.,
Chrome, Firefox,
Safari).

Verify whether the user User interface allows for easy Pass Pass
interface is intuitive navigation and use
13. and easy to use.

53
 CHAPTER V

SYSTEM IMPLEMENTATION

Implementation is the process of converting a new or a revised system design into an

operational one. It is the most crucial stage in achieving a new successful system and in giving
confidence to the new system for the teams that it will work efficiently and effectively. In this
phase, one can build the components either from scratch or by composition. Given the
architecture document from the design phase and requirement document from the analysis phase,
one can precisely make what has been requested.

5.1 IMPLEMENTATION PROCEDURE

The following must be followed to complete the installation

1) Installing Visual Studio 2017

Visual Studio 2017 https://my.visualstudio.com/

2) Install Node.js and npm

Node.js: Download and install from Node.js. npm is included in the installation.

Confirm installation by running node -v and npm -v in the terminal.

3) Install Angular CLI

npm install -g @angular/cli

4) Install MySQL

MySQL: Download and install MySQL from MySQL Downloads.

5) Database Setup

Create necessary schemas and tables in MySQL.

Use Spring Data JPA for database interactions.

54
Web Browser (Client Tier):

The Angular application is loaded here.

Users interact with the UI which makes HTTP requests to the Web Server.

Web Server (Web Server Tier):

Hosts the static files (HTML, CSS, JavaScript) for the Angular application.

Can be implemented using web servers like Nginx or Apache.

Acts as a reverse proxy, forwarding requests to the Application Server.

Application Server (Application Server Tier):

Hosts the Spring Boot application.

Handles business logic, processes API requests, and performs CRUD operations with the
database.

Manages user sessions, authentication, and authorization if necessary.

MySQL Database (Database Tier):

Stores all persistent data required by the application.

Typically includes tables for users, roles, data records, etc.

External APIs (Optional):

If application integrates with external services (like payment gateways, external data sources),
these connections are shown here.

55
 CHAPTER VI

CONCLUSION

The LeadStore project emerges as a transformative advancement in CRM technologies,

providing an all-encompassing solution for businesses eager to refine their lead management
and sales strategies. By merging a user-friendly interface with powerful functionalities,
LeadStore facilitates the seamless navigation of the sales pipeline from initial contact to deal
closure, ensuring maximum lead conversion. This platform not only streamlines sales and
marketing processes but also delivers crucial analytics and insights to propel strategic business
decisions. With its robust, scalable, and secure system, LeadStore is an indispensable tool for
organizations aiming to boost operational efficiency and enhance customer engagement,
positioning itself as a pivotal asset in today's competitive business environment.

Building on its robust foundation, LeadStore also prioritizes customization and

flexibility, allowing businesses to tailor the platform to their unique needs and challenges. This
adaptability ensures that companies of all sizes can optimize their workflow, manage leads more
effectively, and ultimately increase revenue. Additionally, LeadStore's integration capabilities
with existing systems and platforms mean that implementation is smooth, without disrupting
ongoing business operations. The platform's commitment to data security and compliance with
industry standards further enhances its appeal, providing peace of mind for businesses
concerned about protecting their sensitive information. In essence, LeadStore represents a
forward-thinking solution that not only meets the current demands of customer relationship
management but also anticipates future trends and challenges, making it a critical investment for
any business focused on growth and customer satisfaction.

56
6.1 FUTURE ENHANCEMENTS

Localization: Add support for multiple languages to accommodate users from different regions
or linguistic backgrounds.

Two-Factor Authentication (2FA): Offer users the option to enable 2FA for an extra layer of
security during login.

Logging and Monitoring: Set up logging and monitoring to track login attempts, errors, and
other security-related events for auditing and troubleshooting purposes.

Password Recovery: Enable users to reset their passwords via email or SMS verification in
case they forget their credentials.

57
BIBLIOGRAPHY

BOOK REFERENCE

● Fatouretchi, Max. "The Art of CRM: Proven strategies for modern customer relationship
management.", 2018

● Kostojohn, Scott; Paulen, Brian; Johnson, Mathew. "CRM Fundamentals.", 2016

● Greenberg, Paul. "CRM at the Speed of Light: Social CRM Strategies, Tools, and
Techniques for Engaging Your Customers.", McGraw-Hill Education, 2019

● Dyche, Jill. "The CRM Handbook: A Business Guide to Customer Relationship

Management." Addison-Wesley Professional, 2015.

WEB REFERENCE

● https://angular.dev/

● https://dev.mysql.com/doc/

● https://developer.mozilla.org/en-US/docs/Web/JavaScript

58
 APPENDIX

ORGANIZATION PROFILE

Established in 2015, EISystems Services has emerged as a prominent Indian technology

entity with a nationwide presence. Specializing in a wide array of cutting-edge fields, including
Cybersecurity, Machine Learning, Automobiles, the Internet of Things, Web Development,
Robotics, and social media, EISystems offers comprehensive training programs tailored for both
enterprises and the student community. EISystems India's leader in workshops & trainings at IITs,
NITs & top engineering colleges EISystems Services is a leading Indian technology identity with
operations across India.

EISystems (EISys) offers training in Cybersecurity, Machine Learning, Automobiles,

Internet of Things, Robotics and social media for enterprises and student community. Till date we
have trained approximately 50000 students and impacted around 2 lakhs students through our
various outreach initiatives since our founding.

EISystems also excels in fostering innovation through partnerships with leading academic
institutions and industry leaders, ensuring that their curriculum is at the forefront of technological
advancement. These collaborations enhance their training programs, providing participants with
hands-on experience and exposure to the latest technologies and industry practices. Furthermore,
the company actively participates in numerous tech conferences and seminars, contributing to the
technology community by sharing knowledge and insights. This proactive approach not only helps
in skill development but also establishes EISystems as a thought leader in the technology training
sector, continually pushing the envelope in education and professional growth.

59
PLAGIARISM REPORT

60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78