A

PROJECT REPORT

ON

“CONTACT MANAGEMENT
SYSTEM ”
IN
THE PARTIAL FULFILMENT OF REQUIREMENTS FOR
THE AWARD OF DEGREE OF

MASTER OF COMPUTER APPLICATIONS

(2024-2026)

Under the supervision of :- Submitted By :-

Dr. Gopal Singh MANSI RANA
(Associate. Professor) MCA 2nd SEM
Roll No:24126

DEPARTMENT OF COMPUTER SCIENCE& APPLICATIONS

Maharshi Dayanand University, Rohtak – 124001
 Telephone: +91-1262- 393203, 393202 (O)
E-Mail :- [email protected]

DEPARTMENT OF COMPUTER SCIENCE & APPLICATIONS

MAHARSHI DAYANAND UNIVERSITY ROHTAK
(www.mdurohtak.ac.in)
(NAAC Accredited ‘A+’ Grade Haryana State University)

DR. PREETI GULIA No. MDU/DCS/25/

Head of Department Date:

CERTIFICATE - cum – DECLARATION

I, MANSI, hereby declare that the work presented in the Project Report titled
“CONTACT MANAGEMENT SYSTEM ” and submitted as Industry Internship/
Project-I as part of MCA 2nd Semester to Department of Computer Science&
Applications, M.D. University, Rohtak is an authentic record of my work carried out
during the 2nd semester (Jan- June, 2025) under the supervision of Dr. GOPAL
SINGH, Associate Professor, Department of Computer Science & Applications.

Further, I also undertake that the matter embodied in this Project Report is my own
work and has not been submitted by me or by any other candidate for the award of any
other degree anywhere else.

MANSI RANA
Roll No. 24126

MCA 2nd semester

Countersigned by Internal Supervisor

Name: DR. GOPAL SINGH
Designation: ASSOCIATE PROFESSOR

Forwarded by: Dr. Preeti Gulia

(Head of Department)
 ACKNOWLEDGEMENT

Acknowledgement is not mere formality but a genuine opportunity to

thank all those people without that active support in this project would not
be able to be possible.

I am thankful to my guide “DR. GOPAL SINGH, DCSA,MDU, ROHTAK”

for his valuable time, exemplary guidance, monitoring and constant
encouragement throughout the course of this thesis. The blessing, help and
guidance given by his time to time shall carry me a long way in the journey
of life on which I am about to embark.

I also take this opportunity to express a deep sense of gratitude to All

faculty members of Department of Computer Science & Applications,
M.D.U, Rohtak for their cordial support, valuable information and
guidance, which helped me in completing this task through various stages.

Finally, I am thankful to the almighty God who has given me the power,
good sense and confidence to complete my project successfully. I also thank
my parents and friends who were a constant source of encouragement.
Their moral was indispensable.

Signature of the student

MANSI RANA
MCA 2nd Semester
Roll No. 24126
Maharshi Dayanand University, Rohtak
 ABSTRACT

The Contact Management System is a desktop-based application developed using Python as the front-
end programming language and SQLite as the back-end database. This project is designed to simplify
and automate the process of storing, retrieving, and managing personal or professional contact
information.

The system allows users to add, view, update, delete, and search contacts ef ciently. Each contact
record includes essential elds such as name, phone number, email address, and physical address. The
application features a user-friendly interface that enables easy interaction, SQLite, being a lightweight
and server less database engine, is integrated to provide fast and reliable data storage with no
con guration required, making the application portable and suitable for small-scale or personal use.

The main objectives of the project are:

• To maintain an organised contact list.

• To perform CRUD (Create, Read, Update, Delete) operations on stored contacts.

• To ensure data persistence using an embedded database (SQLite).

• To provide a simple and intuitive user interface.

This project demonstrates the practical use of Python for application development and highlights the
effectiveness of SQLite in managing structured data. It is ideal for students and beginners looking to
understand the integration of Python with database systems.
fi
fi
fi
 Table of Contents

Certificate - cum – Declaration ----------------------------------------------2

Acknowledgement --------------------------------------------------------------3

Abstract --------------------------------------------------------------------------4

Chapter-1 Introduction to Project ----------------------------------------6-8

1. Purpose 7
2. Objectives 7
3. Scope of the Web Application 8

Chapter-2 System Design& Analysis -------------------------------------9-11

1. System Design & Analysis 10-11

Chapter-3 Tools, Technologies Used & Requirements Analysis – 12-18

1. Tools & Technologies Used 13-16
2. Requirement Analysis 17-18

Chapter-4 Coding -----------------------------------------------------------19-51

1. Coding Section 20-50

Chapter-5 Testing ------------------------------------------------------------52-54

1. Testing 52
2. Types of Testing 53-54

Chapter-6 Implementation & Screenshots ------------------------------55-62

1. Implementation 56
2. Screenshots 57-62

Chapter-7 Conclusion & Future Scope ----------------------------------63-64

1. Conclusion 64
2. Future Scope 64
3. References 65
 CHAPTER - 1
INTRODUCTION TO
PROJECT

Page 6
 1. PURPOSE
The primary purpose of developing the Contact Management System is to provide an ef cient, organized,
and user-friendly platform to store and manage contact information digitally. Traditional methods of
maintaining contacts manually or in spreadsheets are prone to errors, data loss, and are time-consuming. This
project aims to overcome such limitations by automating the process through a lightweight desktop
application.

Key purposes of the project include:

1. Ef cient Contact Storage:

To allow users to securely store detailed contact information including name, phone number, email,
and address.

2. Quick Access and Retrieval:

To enable users to easily search and retrieve contact details using search functionality based on
various elds.

3. Data Management:
To support basic database operations like add, update, delete, and view contact records in a
structured format.

4. Data Persistence:
To use SQLite, a lightweight, embedded database, for storing data locally and ensuring persistence
even after the application is closed.

5. User-Friendly Interface:
To provide a simple and interactive GUI ( or similar modules) for smooth user interaction, even for
non-technical users.

2. OBJECTIVES
The main objectives of the Contact Management System project are to design and implement a desktop-
based application that simpli es the process of managing contact information ef ciently and securely. This
project focuses on achieving the following goals:

1. To Develop a User-Friendly Application:

Create a simple and interactive graphical user interface (GUI) using Python libraries (like Tkinter)
that allows users to easily manage contact records.

2. To Implement CRUD Operations:

Enable users to Create, Read, Update, and Delete contact information with real-time changes
re ected in the database.

3. To Ensure Data Storage and Persistence:

Use SQLite as a lightweight and reliable embedded database to store contact data permanently
without requiring external database setup.

4. To Provide Search and Filter Options:

Implement features to search contacts based on various criteria such as name, phone number, or email
for quick access.
Page 7
fl
fi
fi
fi
fi
fi
 2. NEED FOR THE APPLICATION
In today’s digital world, managing contact information manually through paper records or spreadsheets is
inef cient, error-prone, and dif cult to maintain as data grows. The Contact Management System is
developed to overcome these limitations by providing a simple, automated, and organized solution.

The need for this application arises due to the following reasons:

1. Avoiding Manual Effort and Errors:

Manual methods of storing contact details often lead to data redundancy, loss, or mismanagement. An
automated system reduces human error and ensures data accuracy.

2. Centralised and Organised Storage:

The application stores all contact information in a centralised SQLite database, making it easy to
retrieve, update, or delete any contact quickly.

3. SCOPE OF THE WEBSITE

The Contact Management System is designed to serve as a lightweight, ef cient, and user-friendly
application for managing contact details. Its scope includes the functionalities it offers, the users it targets,
and the technologies it uses. The project focuses on small-scale to medium-scale usage and is ideal for
personal, educational, and professional purposes.

Functional Scope:

1. Contact Information Management:

◦ Add, edit, delete, and view contact records.

◦ Store details like name, phone number, email, and address.

2. Search and Filter Capabilities:

◦ Search contacts based on name, number, or email.

◦ Quickly retrieve speci c records from the database.

3. Persistent Data Storage:

◦ Use SQLite to store all contact data reliably and permanently.

4. Graphical User Interface (GUI):

◦ A simple, interactive interface developed using Tkinter (or similar Python GUI libraries).

5. Data Validation:

◦ Basic input validation to ensure correct and complete data entry (e.g., phone number format,
non-empty elds).

Page 8
fi
fi
fi
fi
fi
 Technological Scope:

• Front-end: Python (with GUI support using Tkinter or PyQt)

• Back-end: SQLite (for embedded database support)

• Platform: Cross-platform (Windows/Linux/Mac – with Python installed)

User Scope:

• Individual users who need to manage personal or professional contacts.

• Small businesses, freelancers, or organisations needing a simple contact management tool.

• Students and beginners learning Python, GUI, and database integration.

🔶 Why Build a Contact Management System?

🔹 1. Simplicity Meets Power

Python’s syntax is clean, readable, and concise. This makes it highly productive for building systems quickly
without excessive boilerplate code. When combined with SQL, which is the standard language for querying
relational databases, you get a powerful yet simple foundation for managing structured data like contacts.

A contact management system, at its core, deals with structured data — names, phone numbers, emails —
and SQL is exceptionally good at organising, searching, updating, and protecting that data. Python handles
the user interaction and logic ow, while SQL takes care of the heavy-lifting with the data.

🔹 2. Lightweight Yet Scalable

Using SQLite, which is a server less, le-based database engine supported natively by Python, offers a
lightweight backend that requires no setup. This makes the system:

• Portable across devices

• Easy to deploy

• Capable of working of ine

Despite being lightweight, SQLite can handle thousands of contacts ef ciently, and the Python layer can be
modi ed to switch to a more powerful database like PostgreSQL or MySQL if scalability becomes an issue.

Page 9
fi
fl
fl
fi
fi
🔹 3. Strong Ecosystem and Integration

Python’s ecosystem provides excellent libraries for:

• GUI (Tkinter, PyQt)

• Web (Flask, Django)

• File I/O (CSV, Excel)

• Data validation (Cerberus,)

So, the base system can easily evolve into a desktop app, web app, or even integrate with third-party services
like Google Contacts or for messaging. The SQL layer remains compatible across all of these extensions.

🔹 4. Clear Separation of Logic and Data

With Python handling the logic (how data is manipulated) and SQL managing the data (how data is stored
and queried), there's a natural separation of concerns. This leads to cleaner architecture, easier debugging,
and better maintainability. Developers can:

• Change the UI without touching the database

• Modify database structure without rewriting the entire logic

🔹 5. Excellent for Rapid Prototyping

Python allows fast prototyping. In a matter of hours, you can go from an idea to a working prototype with
full CRUD (Create, Read, Update, Delete) functionality. Since SQL doesn’t require additional frameworks,
setting up tables and data operations is instant. This speed of development is a major advantage in startups,
internal tools, or client demos.

🔹 6. Readily Testable and Automatable

Python has robust support for unit testing (unittest, pytest), and SQL queries are easy to verify with
predictable outputs. This makes the system testable at both the logic and database level. You can:

• Run automatic backups

• Set up batch imports/exports

• Automate integrity checks

Such features are often vital in production systems that manage contact data.

Page 10
🔹 7. Security and Data Integrity

With SQL, you can enforce data integrity at the database level using constraints (e.g., unique emails or phone
numbers). Python can add additional layers of input validation and error handling. Together, they offer multi-
layered control over data correctness, which is essential in systems handling personal contact information.

🔹 8. Cost and Accessibility

Both Python and SQLite are free, open-source, and require minimal system resources. This makes the system
cost-effective and accessible to:

• Freelancers

• Small businesses

• Developers in low-resource environments

No licenses, no servers — just code and a database le.

🔹 9. Community and Support

Python and SQL have massive communities and extensive documentation. If you hit a bug, need a new
feature, or want to integrate a library, chances are someone has already solved it or published a library for it.
This reduces development friction and increases con dence in building and maintaining such systems.

Page 11
fi
fi
CHAPTER -2
SYSTEM
DESIGN
&
ANALYSIS

Page 12
 SYSTEM DESIGN AND ANALYSIS FOR CONTACT
MANAGEMENT
The System Design and Analysis phase is crucial for understanding how the Contact Management System
will function, what components are involved, and how data ows through the system. It focuses on both the
logical and physical aspects of the application.

1. System Analysis
1.1 Problem De nition:

Managing contact information manually can be tedious, error-prone, and inef cient. Users often face
dif culty in searching, updating, or organising contact details. A digital solution is needed to address these
problems effectively.

1.2 Feasibility Study:

• Technical Feasibility: The system uses Python and SQLite, both of which are open-source and easy
to use. It is technically feasible for small-scale use.

• Operational Feasibility: End-users can easily interact with the system due to its simple GUI,
reducing training or learning effort.

• Economic Feasibility: The project requires minimal resources — no need for paid software or a
server setup, making it cost-effective.

2. System Design
2.1 Architectural Design:

The system follows a modular structure consisting of:

• Presentation Layer (GUI): Developed using Python's Tkinter or similar library.

• Application Layer (Logic): Contains the logic to process user input and interface with the database.

• Data Layer (SQLite): Stores contact data in tables.

Architecture Flow:

User → GUI → Application Logic (Python) → SQLite Database

Page 13
fi
fi
fl
fi
 2.2 Functional Components:

• Add Contact Module: Adds a new contact to the database.

• View Contact Module: Displays all contacts in a structured format.

• Update Contact Module: Modi es an existing contact.

• Delete Contact Module: Removes a contact from the database.

• Search Module: Finds contacts based on user input.

2.3 User Interface Design:

• Simple form-based interface with:

◦ Input elds: Name, Phone, Email, Address

◦ Buttons: Add, Update, Delete, Search, View All

◦ Message boxes for success/error alerts

2.4 Validation & Error Handling:

• Phone numbers must be digits only.

• Email format is checked for validity.

• Required elds cannot be left blank.

• Appropriate error messages are shown for invalid inputs.

Page 14
fi
fi
fi
 CHAPTER -3
TOOLS,
TECHNOLOGIES
USED
&
REQUIREMENTS
ANALYSIS
Page 15
 1. TOOLS AND TECHNOLOGIES USED

Contact Management System Using Python and SQLite

This project is built using a combination of open-source tools, technologies, and libraries that provide an
ef cient and cost-effective way to create a standalone desktop application for contact management.

1. Programming Language: Python

• Purpose: Used to develop the entire application including logic, database interaction, and GUI.

• Why Python?

◦ Easy to read and write.

◦ Strong support for database and GUI development.

◦ Rich standard libraries for various functionalities.

2. Database: SQLite

• Purpose: Used as the back-end database to store contact information persistently.

• Why SQLite?

◦ Lightweight and server less.

◦ Does not require separate installation or setup.

◦ Data is stored in a local .db le.

◦ Perfect for small and medium applications with minimal resource usage.

3. GUI Library: Tkinter

• Purpose: Used to create the Graphical User Interface (GUI) of the application.

• Why Tkinter?

◦ Built-in with Python – no need to install external libraries.

◦ Simple and effective for creating form-based desktop applications.

◦ Supports widgets like buttons, labels, entry elds, and tables.

Page 16
fi
fi
fi
4. IDE/Text Editor (Any of the following):

• PyCharm / VS Code / Sublime Text / IDLE

• Purpose: Used for writing, testing, and debugging the Python code.

• Why?

◦ Syntax highlighting.

◦ Code suggestions and debugging support.

◦ Integration with Python and virtual environments.

5. SQLite Browser (Optional but Helpful)

• Tool Name: DB Browser for SQLite

• Purpose: To visually inspect and manage the SQLite database (tables, rows, queries).

• Why Use It?

◦ GUI for database browsing.

◦ Helps debug and verify table structure and data outside the application.

6. Operating System:

• Compatible With: Windows, Linux, macOS

• Why? Python and SQLite are cross-platform technologies. The project can run on any OS where
Python is installed.

7. Supporting Python Libraries (Optional):

• sqlite3: Built-in library to connect and interact with the SQLite database.

• tkinter .message box: For displaying alerts and noti cations.

• re (Regular Expressions): Used for validating email formats and phone numbers (if needed).

Page 17
fi
 1. REQUIREMENT ANALYSIS
For the successful development of any project, it is very necessary to study about all the
requirements of the project. These requirements maybe related to resource, hardware, software,
functionalities etc.

1.1. USER REQUIREMENTS

❖ A high-speed (2g or later) Internet Connection is needed as aninterface between

the service provider and User.
❖ A Smartphone device, Desktop, Tablet, etc.

1.2. HARDWARE REQUIREMENTS

❖ No Specific Hardware requirement.
❖ Need a Browser to surf project URL.
❖ Internet Connection: 512 Kbps or more high-speed internet connection.

SOFTWARE REQUIREMENTS
❖ Support All Device like, android, desktop, etc.
❖ Updated Browser is Preferred.

1.3. FUNCTIONAL REQUIREMENTS

❖ Allow users to explore the feed.
❖ Allow users to do the listed actions.
❖ Allow users to access the classes anytime according to their need.

1.4. PERFORMANCE REQUIREMENTS

❖ The performance mainly depends on the speed of the internet connection.
❖ The performance of Animations might depend on processor and ram size as
well.

1.5. SAFETY REQUIREMENTS

❖ Data loss may occur due to the interruption of Internet connection. So, the
user should ensure uninterrupted internet connection.

Page 18
CHAPTER -4
CODING

Page 19
SYNTAX CODE OF PYTHON IN
CONTACT MANAGEMENT SYSTEM

import sqlite3
# Function to connect to SQLite database and create table
if not exists
def initialise_database():
conn = sqlite3.connect('contacts.db')
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS contacts (
id INTEGER PRIMARY KEY ACTOIN
INCREMENT,
name TEXT NOT NULL,
phone TEXT NOT NULL,
email TEXT
)
''')
conn.commit()
conn.close()

# Function to add a new contact

def add_contact(name, phone, email): Page 20
 conn = sqlite3.connect('contacts.db')
cursor = conn.cursor()
cursor.execute("INSERT INTO contacts (name, phone,
email) VALUES (?, ?, ?)", (name, phone, email))
conn.commit()
conn.close()

# Function to display all contacts

def view_contacts():
conn = sqlite3.connect('contacts.db')
cursor = conn.cursor()
cursor.execute("SELECT * FROM contacts")
rows = cursor.fetch all()
conn.close()
return rows

# Function to search for a contact by name

def search_contact(name):
conn = sqlite3.connect('contacts.db')
cursor = conn.cursor()
cursor.execute("SELECT * FROM contacts WHERE
name LIKE ?", ('%' + name + '%',))
results = cursor.fetchall()
conn.close()
Page 21
 return results

# Function to delete a contact by ID

def delete_contact(contact_id):
conn = sqlite3.connect('contacts.db')
cursor = conn.cursor()
cursor.execute("DELETE FROM contacts WHERE id
= ?", (contact_id,))
conn.commit()
conn.close()

# User interface
def menu():
initialise_ database()
while True:
print("\n--- Contact Management System ---")
print("1. Add Contact")
print("2. View Contacts")
print("3. Search Contact")
print("4. Delete Contact")
print("5. Exit")
choice = input("Enter your choice: ")

if choice == '1':
Page 22
 name = input("Enter name: ")
phone = input("Enter phone number: ")
email = input("Enter email: ")
add_contact(name, phone, email)
print("Contact added successfully!")

elif choice == '2':

contacts = view_contacts()
for contact in contacts:
print(contact)

elif choice == '3':

search_name = input("Enter name to search: ")
results = search_contact(search_name)
for contact in results:
print(contact)

elif choice == '4':

contact_id = int(input("Enter contact ID to delete:
"))

delete_contact(contact_id)
print("Contact deleted successfully!")
Page 23
 elif choice == '5':
print("Exiting program.")
break

else:
print("Invalid choice. Please try again.")

# Run the program

menu()

Page 24
SYNTAX CODE OF IN SQLITE DATABASE

CONTACT MANAGEMENT SYSTEM

-- Create table (if not exists)

CREATE TABLE IF NOT EXISTS contacts (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
phone TEXT NOT NULL,
email TEXT
);

-- Insert a contact
INSERT INTO contacts (name, phone, email) VALUES (?, ?, ?);

-- View all contacts

SELECT * FROM contacts;

-- Search for a contact by name (using LIKE for partial match)

SELECT * FROM contacts WHERE name LIKE ?;

-- Delete a contact by ID
DELETE FROM contacts WHERE id = ?;

Page 25
INDEX.PY
from tkinter import *
import sqlite3
import tkinter.ttk as ttk
import tkinter.messagebox as tkMessageBox

root = Tk()
root.title("Contact List")
width = 700
height = 400
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
x = int((screen_width / 2) - (width / 2))
y = int((screen_height / 2) - (height / 2))

# Set the geometry with integer values

root.geometry(f"{width}x{height}+{x}+{y}")

root.resizable(0, 0)
root.config(bg="#6666ff")

#============================VARIABLES=================
==================
FIRSTNAME = StringVar()
LASTNAME = StringVar()
GENDER = StringVar()
AGE = StringVar()
ADDRESS = StringVar()
CONTACT = StringVar()

Page 26
#============================METHODS==================
===================

def Database():
conn = sqlite3.connect("pythontut.db")
cursor = conn.cursor()
cursor.execute("CREATE TABLE IF NOT EXISTS `member` (mem_id
INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, firstname
TEXT, lastname TEXT, gender TEXT, age TEXT, address TEXT, contact
TEXT)")
cursor.execute("SELECT * FROM `member` ORDER BY `lastname`
ASC")
fetch = cursor.fetchall()
for data in fetch:
tree.insert('', 'end', values=(data))
cursor.close()
conn.close()

def SubmitData():
if FIRSTNAME.get() == "" or LASTNAME.get() == "" or GENDER.get()
== "" or AGE.get() == "" or ADDRESS.get() == "" or CONTACT.get() == "":
result = tkMessageBox.showwarning('', 'Please Complete The
Required Field', icon="warning")
else:
tree.delete(*tree.get_children())
conn = sqlite3.connect("pythontut.db")
cursor = conn.cursor()
cursor.execute("INSERT INTO `member` (firstname, lastname,
gender, age, address, contact) VALUES(?, ?, ?, ?, ?, ?)",
(str(FIRSTNAME.get()), str(LASTNAME.get()), str(GENDER.get()),
int(AGE.get()), str(ADDRESS.get()), str(CONTACT.get())))
conn.commit()
cursor.execute("SELECT * FROM `member` ORDER BY `lastname`
ASC")
fetch = cursor.fetchall()
for data in fetch:
tree.insert('', 'end', values=(data))
cursor.close()
conn.close()
FIRSTNAME.set("")
Page 27
 LASTNAME.set("")
GENDER.set("")
AGE.set("")
ADDRESS.set("")
CONTACT.set("")

def UpdateData():
if GENDER.get() == "":
result = tkMessageBox.showwarning('', 'Please Complete The
Required Field', icon="warning")
else:
tree.delete(*tree.get_children())
conn = sqlite3.connect("pythontut.db")
cursor = conn.cursor()
cursor.execute("UPDATE `member` SET `firstname` = ?, `lastname`
= ?, `gender` =?, `age` = ?, `address` = ?, `contact` = ? WHERE
`mem_id` = ?", (str(FIRSTNAME.get()), str(LASTNAME.get()),
str(GENDER.get()), str(AGE.get()), str(ADDRESS.get()),
str(CONTACT.get()), int(mem_id)))
conn.commit()
cursor.execute("SELECT * FROM `member` ORDER BY `lastname`
ASC")
fetch = cursor.fetchall()
for data in fetch:
tree.insert('', 'end', values=(data))
cursor.close()
conn.close()
FIRSTNAME.set("")
LASTNAME.set("")
GENDER.set("")
AGE.set("")
ADDRESS.set("")
CONTACT.set("")

def OnSelected(event):
global mem_id, UpdateWindow
curItem = tree.focus()
contents =(tree.item(curItem))
selecteditem = contents['values']
Page 28
 mem_id = selecteditem[0]
FIRSTNAME.set("")
LASTNAME.set("")
GENDER.set("")
AGE.set("")
ADDRESS.set("")
CONTACT.set("")
FIRSTNAME.set(selecteditem[1])
LASTNAME.set(selecteditem[2])
AGE.set(selecteditem[4])
ADDRESS.set(selecteditem[5])
CONTACT.set(selecteditem[6])
UpdateWindow = Toplevel()
UpdateWindow.title("Contact List")
width = 400
height = 300
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
x = ((screen_width/2) + 450) - (width/2)
y = ((screen_height/2) + 20) - (height/2)
UpdateWindow.resizable(0, 0)
UpdateWindow.geometry("%dx%d+%d+%d" % (width, height, x, y))
if 'NewWindow' in globals():
NewWindow.destroy()

#===================FRAMES=============================
=
FormTitle = Frame(UpdateWindow)
FormTitle.pack(side=TOP)
ContactForm = Frame(UpdateWindow)
ContactForm.pack(side=TOP, pady=10)
RadioGroup = Frame(ContactForm)
Male = Radiobutton(RadioGroup, text="Male", variable=GENDER,
value="Male", font=('arial', 14)).pack(side=LEFT)
Female = Radiobutton(RadioGroup, text="Female", variable=GENDER,
value="Female", font=('arial', 14)).pack(side=LEFT)

#===================LABELS=============================
Page 29
=
lbl_title = Label(FormTitle, text="Updating Contacts", font=('arial', 16),
bg="orange", width = 300)
lbl_title.pack(fill=X)
lbl_firstname = Label(ContactForm, text="Firstname", font=('arial', 14),
bd=5)
lbl_firstname.grid(row=0, sticky=W)
lbl_lastname = Label(ContactForm, text="Lastname", font=('arial', 14),
bd=5)
lbl_lastname.grid(row=1, sticky=W)
lbl_gender = Label(ContactForm, text="Gender", font=('arial', 14),
bd=5)
lbl_gender.grid(row=2, sticky=W)
lbl_age = Label(ContactForm, text="Age", font=('arial', 14), bd=5)
lbl_age.grid(row=3, sticky=W)
lbl_address = Label(ContactForm, text="Address", font=('arial', 14),
bd=5)
lbl_address.grid(row=4, sticky=W)
lbl_contact = Label(ContactForm, text="Contact", font=('arial', 14),
bd=5)
lbl_contact.grid(row=5, sticky=W)

#===================ENTRY==============================
=
firstname = Entry(ContactForm, textvariable=FIRSTNAME, font=('arial',
14))
firstname.grid(row=0, column=1)
lastname = Entry(ContactForm, textvariable=LASTNAME, font=('arial',
14))
lastname.grid(row=1, column=1)
RadioGroup.grid(row=2, column=1)
age = Entry(ContactForm, textvariable=AGE, font=('arial', 14))
age.grid(row=3, column=1)
address = Entry(ContactForm, textvariable=ADDRESS, font=('arial',
14))
address.grid(row=4, column=1)
contact = Entry(ContactForm, textvariable=CONTACT, font=('arial',
14))
contact.grid(row=5, column=1)
Page 30
#==================BUTTONS=============================
=
btn_updatecon = Button(ContactForm, text="Update", width=50,
command=UpdateData)
btn_updatecon.grid(row=6, columnspan=2, pady=10)

#fn1353p
def DeleteData():
if not tree.selection():
result = tkMessageBox.showwarning('', 'Please Select Something
First!', icon="warning")
else:
result = tkMessageBox.askquestion('', 'Are you sure you want to
delete this record?', icon="warning")
if result == 'yes':
curItem = tree.focus()
contents =(tree.item(curItem))
selecteditem = contents['values']
tree.delete(curItem)
conn = sqlite3.connect("pythontut.db")
cursor = conn.cursor()
cursor.execute("DELETE FROM `member` WHERE `mem_id` =
%d" % selecteditem[0])
conn.commit()
cursor.close()
conn.close()

def AddNewWindow():
global NewWindow
FIRSTNAME.set("")
LASTNAME.set("")
GENDER.set("")
AGE.set("")
ADDRESS.set("")
CONTACT.set("")
NewWindow = Toplevel()
Page 31
 NewWindow.title("Contact List")
width = 400
height = 300
screen_width = root.winfo_screenwidth()
screen_height = root.winfo_screenheight()
x = ((screen_width/2) - 455) - (width/2)
y = ((screen_height/2) + 20) - (height/2)
NewWindow.resizable(0, 0)
NewWindow.geometry("%dx%d+%d+%d" % (width, height, x, y))
if 'UpdateWindow' in globals():
UpdateWindow.destroy()

#===================FRAMES=============================
=
FormTitle = Frame(NewWindow)
FormTitle.pack(side=TOP)
ContactForm = Frame(NewWindow)
ContactForm.pack(side=TOP, pady=10)
RadioGroup = Frame(ContactForm)
Male = Radiobutton(RadioGroup, text="Male", variable=GENDER,
value="Male", font=('arial', 14)).pack(side=LEFT)
Female = Radiobutton(RadioGroup, text="Female", variable=GENDER,
value="Female", font=('arial', 14)).pack(side=LEFT)

#===================LABELS=============================
=
lbl_title = Label(FormTitle, text="Adding New Contacts", font=('arial',
16), bg="#66ff66", width = 300)
lbl_title.pack(fill=X)
lbl_firstname = Label(ContactForm, text="Firstname", font=('arial', 14),
bd=5)
lbl_firstname.grid(row=0, sticky=W)
lbl_lastname = Label(ContactForm, text="Lastname", font=('arial', 14),
bd=5)
lbl_lastname.grid(row=1, sticky=W)
lbl_gender = Label(ContactForm, text="Gender", font=('arial', 14),
bd=5)
lbl_gender.grid(row=2, sticky=W)
Page 32
 lbl_age = Label(ContactForm, text="Age", font=('arial', 14), bd=5)
lbl_age.grid(row=3, sticky=W)
lbl_address = Label(ContactForm, text="Address", font=('arial', 14),
bd=5)
lbl_address.grid(row=4, sticky=W)
lbl_contact = Label(ContactForm, text="Contact", font=('arial', 14),
bd=5)
lbl_contact.grid(row=5, sticky=W)

#===================ENTRY==============================
=
firstname = Entry(ContactForm, textvariable=FIRSTNAME, font=('arial',
14))
firstname.grid(row=0, column=1)
lastname = Entry(ContactForm, textvariable=LASTNAME, font=('arial',
14))
lastname.grid(row=1, column=1)
RadioGroup.grid(row=2, column=1)
age = Entry(ContactForm, textvariable=AGE, font=('arial', 14))
age.grid(row=3, column=1)
address = Entry(ContactForm, textvariable=ADDRESS, font=('arial',
14))
address.grid(row=4, column=1)
contact = Entry(ContactForm, textvariable=CONTACT, font=('arial',
14))
contact.grid(row=5, column=1)

#==================BUTTONS=============================
=
btn_addcon = Button(ContactForm, text="Save", width=50,
command=SubmitData)
btn_addcon.grid(row=6, columnspan=2, pady=10)

Page 33
#============================FRAMES====================
==================
Top = Frame(root, width=500, bd=1, relief=SOLID)
Top.pack(side=TOP)
Mid = Frame(root, width=500, bg="#6666ff")
Mid.pack(side=TOP)
MidLeft = Frame(Mid, width=100)
MidLeft.pack(side=LEFT, pady=10)
MidLeftPadding = Frame(Mid, width=370, bg="#6666ff")
MidLeftPadding.pack(side=LEFT)
MidRight = Frame(Mid, width=100)
MidRight.pack(side=RIGHT, pady=10)
TableMargin = Frame(root, width=500)
TableMargin.pack(side=TOP)
#============================LABELS====================
==================
lbl_title = Label(Top, text="Contact Management System", font=('arial',
16), width=500)
lbl_title.pack(fill=X)

#============================ENTRY=====================
==================

#============================BUTTONS===================
==================
btn_add = Button(MidLeft, text="+ ADD NEW", bg="#66ff66",
command=AddNewWindow)
btn_add.pack()
btn_delete = Button(MidRight, text="DELETE", bg="red",
command=DeleteData)
btn_delete.pack(side=RIGHT)

#============================TABLES====================
==================
scrollbarx = Scrollbar(TableMargin, orient=HORIZONTAL)
scrollbary = Scrollbar(TableMargin, orient=VERTICAL)
tree = ttk.Treeview(TableMargin, columns=("MemberID", "Firstname",
"Lastname", "Gender", "Age", "Address", "Contact"), height=400,
selectmode="extended", yscrollcommand=scrollbary.set,
xscrollcommand=scrollbarx.set)
Page 34
scrollbary.config(command=tree.yview)
scrollbary.pack(side=RIGHT, fill=Y)
scrollbarx.config(command=tree.xview)
scrollbarx.pack(side=BOTTOM, fill=X)
tree.heading('MemberID', text="MemberID", anchor=W)
tree.heading('Firstname', text="Firstname", anchor=W)
tree.heading('Lastname', text="Lastname", anchor=W)
tree.heading('Gender', text="Gender", anchor=W)
tree.heading('Age', text="Age", anchor=W)
tree.heading('Address', text="Address", anchor=W)
tree.heading('Contact', text="Contact", anchor=W)
tree.column('#0', stretch=NO, minwidth=0, width=0)
tree.column('#1', stretch=NO, minwidth=0, width=0)
tree.column('#2', stretch=NO, minwidth=0, width=80)
tree.column('#3', stretch=NO, minwidth=0, width=120)
tree.column('#4', stretch=NO, minwidth=0, width=90)
tree.column('#5', stretch=NO, minwidth=0, width=80)
tree.column('#6', stretch=NO, minwidth=0, width=120)
tree.column('#7', stretch=NO, minwidth=0, width=120)
tree.pack()
tree.bind('<Double-Button-1>', OnSelected)

#============================INITIALIZATION==============
================
if __name__ == '__main__':
Database()
root.mainloop()

Page 35
SQLITE DATABASE
CODE
import sqlite3
from context lib import context manager
import re
import logging
from typing import List, Optional, Tuple, Dict, Any

# ========== Logging Configuration ==========

logging.basicConfig(
filename='contact_management.log',
level=logging.DEBUG,
format='%(asctime)s [%(levelname)s] %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
)

# ========== Constants ==========

DATABASE_NAME = 'contacts.db'

# Contact field constraints

PHONE_REGEX = re.compile(r'^\+?[\d\s\-]{7,15}$') # Simplified phone
validation
EMAIL_REGEX = re.compile(r'^[\w\.-]+@[\w\.-]+\.\w+$')

# Pagination default
DEFAULT_PAGE_SIZE = 10

# ========== Exception Classes ==========

class ValidationError(Exception):
pass
Page 36
class DatabaseError(Exception):
pass

# ========== Data Model ==========

class Contact:
def __init__(self, name: str, phone: str, email: Optional[str] = None,
address: Optional[str] = None, contact_id: Optional[int] =
None):
self.id = contact_id
self.name = name.strip()
self.phone = phone.strip()
self.email = email.strip() if email else None
self.address = address.strip() if address else None

def __repr__(self):
return f"<Contact id={self.id} name={self.name} phone={self.phone}
>"

# ========== Database Context Manager ==========

@contextmanager
def get_db_connection():
"""Context manager for SQLite connection."""
try:
conn = sqlite3.connect(DATABASE_NAME)
conn.execute("PRAGMA foreign_keys = ON")
yield conn
conn.commit()
except sqlite3.Error as e:
logging.error(f"Database error: {e}")
raise DatabaseError(e)
finally:
conn.close()

# ========== Validation Functions ==========

def validate_phone(phone: str):

if not PHONE_REGEX.match(phone):
logging.warning(f"Invalid phone number attempted: {phone}")
Page 37
 raise ValidationError("Invalid phone number format.")

def validate_email(email: Optional[str]):

if email and not EMAIL_REGEX.match(email):
logging.warning(f"Invalid email address attempted: {email}")
raise ValidationError("Invalid email format.")

def validate_name(name: str):

if not name or len(name.strip()) < 2:
logging.warning(f"Invalid name attempted: '{name}'")
raise ValidationError("Name must be at least 2 characters long.")

# ========== Data Access Object (DAO) Class ==========

class ContactDAO:
"""Data Access Object for Contacts."""

def __init__(self):
self._initialize_database()

def _initialize_database(self):
with get_db_connection() as conn:
cursor = conn.cursor()
cursor.execute("""
CREATE TABLE IF NOT EXISTS contacts (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
phone TEXT NOT NULL UNIQUE,
email TEXT,
address TEXT
)
""")
logging.info("Database and contacts table initialized.")

def add_contact(self, contact: Contact) -> int:

validate_name(contact.name)
validate_phone(contact.phone)
validate_email(contact.email)

with get_db_connection() as conn:

Page 38
 cursor = conn.cursor()
try:
cursor.execute("""
INSERT INTO contacts (name, phone, email, address)
VALUES (?, ?, ?, ?)
""", (contact.name, contact.phone, contact.email,
contact.address))
contact_id = cursor.lastrowid
logging.info(f"Added contact: {contact} with ID {contact_id}")
return contact_id
except sqlite3.IntegrityError as e:
logging.error(f"Failed to add contact due to integrity error: {e}")
raise DatabaseError(f"Contact with phone '{contact.phone}'
already exists.")

def get_contact_by_id(self, contact_id: int) -> Optional[Contact]:

with get_db_connection() as conn:
cursor = conn.cursor()
cursor.execute("SELECT id, name, phone, email, address FROM
contacts WHERE id = ?", (contact_id,))
row = cursor.fetchone()
if row:
contact = Contact(contact_id=row[0], name=row[1],
phone=row[2], email=row[3], address=row[4])
logging.info(f"Retrieved contact by ID {contact_id}: {contact}")
return contact
logging.info(f"No contact found with ID {contact_id}")
return None

def update_contact(self, contact: Contact) -> bool:

if contact.id is None:
raise ValidationError("Contact ID is required for update.")
validate_name(contact.name)
validate_phone(contact.phone)
validate_email(contact.email)

with get_db_connection() as conn:

cursor = conn.cursor()
cursor.execute("""
UPDATE contacts
Page 39
 SET name = ?, phone = ?, email = ?, address = ?
WHERE id = ?
""", (contact.name, contact.phone, contact.email, contact.address,
contact.id))
updated = cursor.rowcount > 0
if updated:
logging.info(f"Updated contact: {contact}")
else:
logging.warning(f"No contact updated, ID not found:
{contact.id}")
return updated

def delete_contact(self, contact_id: int) -> bool:

with get_db_connection() as conn:
cursor = conn.cursor()
cursor.execute("DELETE FROM contacts WHERE id = ?",
(contact_id,))
deleted = cursor.rowcount > 0
if deleted:
logging.info(f"Deleted contact with ID {contact_id}")
else:
logging.warning(f"No contact deleted, ID not found:
{contact_id}")
return deleted

def search_contacts(self, keyword: str = "", page: int = 1, page_size: int

= DEFAULT_PAGE_SIZE) -> Tuple[List[Contact], int]:
"""
Search contacts by name or phone, paginated.
Returns a tuple (contacts list, total count)
"""
offset = (page - 1) * page_size
keyword_pattern = f"%{keyword}%"

with get_db_connection() as conn:

cursor = conn.cursor()

# Total count
cursor.execute("""
SELECT COUNT(*) FROM contacts
Page 40
 WHERE name LIKE ? OR phone LIKE ?
""", (keyword_pattern, keyword_pattern))
total_count = cursor.fetchone()[0]

# Fetch page results

cursor.execute("""
SELECT id, name, phone, email, address FROM contacts
WHERE name LIKE ? OR phone LIKE ?
ORDER BY name ASC
LIMIT ? OFFSET ?
""", (keyword_pattern, keyword_pattern, page_size, offset))
rows = cursor.fetchall()

contacts = [Contact(contact_id=r[0], name=r[1], phone=r[2],

email=r[3], address=r[4]) for r in rows]

logging.info(f"Searched contacts with keyword '{keyword}', page

{page}/{(total_count // page_size) + 1}")
return contacts, total_count

def list_all_contacts(self) -> List[Contact]:

with get_db_connection() as conn:
cursor = conn.cursor()
cursor.execute("SELECT id, name, phone, email, address FROM
contacts ORDER BY name ASC")
rows = cursor.fetchall()
contacts = [Contact(contact_id=r[0], name=r[1], phone=r[2],
email=r[3], address=r[4]) for r in rows]
logging.info("Listed all contacts")
return contacts

# ========== Service Layer ==========

class ContactService:
"""
Service layer handling business logic for Contact Management.
Interacts with the DAO and performs validations or transformations.
"""

def __init__(self):
Page 41
 self.dao = ContactDAO()

def create_contact(self, name: str, phone: str, email: Optional[str],

address: Optional[str]) -> int:
contact = Contact(name=name, phone=phone, email=email,
address=address)
return self.dao.add_contact(contact)

def get_contact(self, contact_id: int) -> Optional[Contact]:

return self.dao.get_contact_by_id(contact_id)

def update_contact(self, contact_id: int, name: str, phone: str, email:

Optional[str], address: Optional[str]) -> bool:
contact = Contact(contact_id=contact_id, name=name,
phone=phone, email=email, address=address)
return self.dao.update_contact(contact)

def delete_contact(self, contact_id: int) -> bool:

return self.dao.delete_contact(contact_id)

def search_contacts(self, keyword: str = "", page: int = 1, page_size: int

= DEFAULT_PAGE_SIZE) -> Tuple[List[Contact], int]:
return self.dao.search_contacts(keyword, page, page_size)

def list_contacts(self) -> List[Contact]:

return self.dao.list_all_contacts()

# ========== Example usage and testing ==========

def _test_module():
logging.info("Starting Contact Management System backend test...")

service = ContactService()

# Clean slate - delete all contacts for testing

all_contacts = service.list_contacts()
for contact in all_contacts:
service.delete_contact(contact.id)

# Add contacts
Page 42
 try:
contact1_id = service.create_contact("Alice Wonderland",
"+1234567890", "[email protected]", "123 Maple Street")
contact2_id = service.create_contact("Bob Marley", "+1987654321",
"[email protected]", "456 Oak Avenue")
logging.info(f"Added test contacts with IDs {contact1_id},
{contact2_id}")
except ValidationError as e:
logging.error(f"Validation error during test add: {e}")

# Search contacts
contacts, total = service.search_contacts(keyword="Alice")
print(f"Search results for 'Alice': {contacts}, Total: {total}")

# Update contact
updated = service.update_contact(contact1_id, "Alice W.",
"+1234567890", "[email protected]", "789 Pine Road")
print(f"Updated contact {contact1_id}: {updated}")

# List all contacts

all_contacts = service.list_contacts()
print(f"All contacts: {all_contacts}")

# Delete contact
deleted = service.delete_contact(contact2_id)
print(f"Deleted contact {contact2_id}: {deleted}")

logging.info("Contact Management System backend test completed.")

if __name__ == "__main__":_test_module()

Page 43
CHAPTER - 5
TESTING

Page 44
1. TESTING

Testing is the process of executing a program with the aim of finding an error. To make
our software perform well, it should be error-free. If testing is done successfully, it will
remove most if not all the errors from the software.

2. TYPES OF TESTING :-
2.1. UNIT TESTING
It focuses on the smallest unit of software design. In this, we test an individual unit or
group of interrelated units. The programmer often does it by using sample input and
observing its corresponding outputs.

2.2. INTEGRATION TESTING

The objective is to take unit tested components and build a program structure that has
been dictated by design. Integration testing is testing in which a group of components is
combined to produce output.

Integration testing is of four types:

• Top-down
• Bottom-up
• Sandwich
• Big-Bang
Example

❖ Black Box testing: - It is used for validation. In this, we ignore the

internal working mechanism and focuses on what is the output?

❖ White Box testing: - It is used for verification. In this, we focus on the

internal mechanism, i.e., how the output is achieved?

Page 45
2.3. ALPHA TESTING
This is a type of validation testing. It is a type of acceptance testing which is done
before the product is released to customers. QA people typically do it

2.4. BETA TESTING

The beta test is conducted at one or more customer sites by the end-user of the
software. This version is released for a limited number of users for testing in a
real-time environment
Example: When software testing is performed for a limited number of people.

2.5. SYSTEM TESTING

In Software Testing, the software is tested such that it works fine for the different
operating systems. It is covered under the black box testing technique. In this, we
just focus on required input and output without focusing on internal working.
In this, we have security testing, recovery testing, stress testing and performance testing
Example: This includes functional as well as non-functional testing.
During the Testing phase of Flipkart Clone Website, the following techniques were
used to find and fix bugs:
• Unit Testing feature provided by Visual Code and Chrome Developer Tool was
used to test individual tags and scripts.
• Then, Integration Testing was done to find and fix bugs occurring during the
interaction of modules. In this way, proper integration was achieved.Some bugs
were found and fixed to improve the web application.

Page 46
 CHAPTER - 6
IMPLEMENTATION
&
SCREENSHOTS

Page 47
 1.IMPLEMENTATION
PROJECT STRUCTUEE
contact_manager/
├── contact_ manager .py
└── pythontut.db (auto-generated SQLite database)

The implementation of the Contact Management System is carried out in various structured phases,
following the software development life cycle (SDLC). Each phase contributes towards achieving the
objective of providing an ef cient and user-friendly system for managing personal and professional contacts.

1. Environment Setup

Before starting the actual implementation, the development environment is set up with the required tools and
technologies. For example:

• Programming Language: Java / Python / PHP

• Database: MySQL / SQLite

• IDE: Eclipse / VS Code / NetBeans

• Other Tools: XAMPP for local server (if web-based), Git for version control

2. Module-Wise Implementation

The implementation is divided into the following functional modules:

a) User Authentication Module

• Objective: To provide secure access to users.

• Implementation: Users must log in using a valid username and password. Data is checked from the
database using authentication logic.

• Security: Passwords are stored using hashing techniques for security.

b) Add New Contact

• Objective: To allow users to store new contacts.

• Implementation: A form is provided to enter contact details like Name, Phone Number, Email,
Address, etc. On submission, the data is validated and stored in the database.
Page 48
fi
 c) View Contact List

• Objective: To display all stored contacts.

• Implementation: Contacts are fetched from the database and displayed in a table format. Sorting and
search lters are applied for ease of use.

d) Edit/Update Contact

• Objective: To modify the details of an existing contact.

• Implementation: User selects a contact, edits the elds, and submits the form. The corresponding
record in the database is updated.

e) Delete Contact

• Objective: To remove a contact permanently.

• Implementation: A delete button is provided for each contact. On con rmation, the record is deleted
from the database.

f) Search Functionality

• Objective: To quickly locate a speci c contact.

• Implementation: A search bar lters contacts based on name, phone number, or email using database
queries.

3. Backend Development

• Implemented business logic for managing contacts using appropriate programming language.

• Used SQL queries to perform CRUD (Create, Read, Update, Delete) operations.

• Ensured proper exception handling for user input and database connectivity errors.

4. Frontend Development

• Developed user interface using HTML/CSS (or GUI libraries for desktop apps).

• Integrated forms for data input and used responsive design for better usability.

• JavaScript (or equivalent) used for client-side validation.

Page 49
fi
fi
fi
fi
fi
5. Database Integration

• Created tables to store user and contact information.

• Applied normalization techniques to reduce redundancy.

• Used primary and foreign keys to maintain data integrity.

6. Testing

• Unit testing was done on individual modules like Add, Delete, Search, etc.

• Integration testing ensured smooth communication between frontend, backend, and database.

• User Acceptance Testing (UAT) was performed to ensure the system met user requirements.

7. Deployment

• For a web-based system: Deployed using a local server like XAMPP/WAMP or hosted on a cloud
server.

• For a desktop application: Created an executable le and distributed it with required dependencies.

8. Documentation and User Manual

• Prepared technical documentation covering system architecture, database schema, and code structure.

• Developed a user manual with step-by-step instructions and screenshots for using the system.

Page 50
fi
 2. SCREENSHOTS

ADDING A NEW RECORD

Page 51
FRONT PAGE OF PROJECT

Caption

ABOVE FRONT PAGE DISPLAY WHEN WE OPEN A PROJECT

Page 52
• TYPING NAME

Page 53
• UPDATING A CONTACT LIST
PERSON 1

Page 54
• UPDATING A CONTACT LIST
PERSON 2

Page 55
• DELETING A CONTACT LIST

Page 56
 CHAPTER - 7
CONCLUSION
&
FUTURE SCOPE

Page 57
Conclusion
The Contact Management System has been successfully developed and implemented to
simplify the process of storing, retrieving, updating, and managing contact information. The
system provides users with an intuitive interface to perform operations like adding new
contacts, editing existing ones, deleting outdated information, and searching through saved
contacts ef ciently.

By integrating backend logic with a user-friendly frontend, the system ensures both
functionality and ease of use. The use of a structured database ensures data integrity, while
features like validation and user authentication add security and reliability.

Overall, the project achieves its goal of replacing traditional contact-keeping methods (like
physical address books or spreadsheets) with a more ef cient, digital solution that saves time,
reduces errors, and enhances productivity.

Future Scope
While the current version of the Contact Management System serves basic functionalities effectively, there
are several areas where the system can be enhanced in the future:

1. Cloud Integration

• Allow users to store and access their contacts from anywhere by hosting the system on a cloud
platform.

2. Mobile Application

• Develop an Android/iOS version of the system for easier access and portability.

3. Import/Export Functionality

• Enable users to import contacts from other sources (like Google Contacts or CSV les) and export
them for backup.

4. Group Contact Management

• Introduce features to group contacts under categories like Family, Friends, Work, etc., for better
organisation.

5. Advanced Search and Filters

• Add more powerful search tools, lters, and sorting options for handling large datasets.

Page 58
fi
fi
fi
fi
 6. Pro le Picture and File Attachments

• Allow users to upload a pro le photo for each contact and attach documents (like ID proofs or
business cards).

7. Data Encryption

• Implement end-to-end encryption for storing contact data securely, especially in online versions.

8. Reminders and Noti cations

• Add functionality to set reminders for birthdays, anniversaries, or follow-up calls.

9. Voice Input/AI Integration

• Incorporate voice commands and AI-based features for smart suggestions, duplicate contact
detection, and auto- ll.

Page 59
fi
fi
fi
fi
 REFERENCES

1. Python Programming Documentation – Of cial Python documentation was referred to for

understanding core concepts such as le handling, object-oriented programming, and exception
handling, which were used in the development of the system.

2. MySQL Reference Manual – Used for learning database operations like creating tables, performing
CRUD operations, and integrating MySQL with Python using connectors.

3. Software Engineering Principles – Concepts of modular programming, system design, testing, and
documentation were applied based on standard software engineering practices.

4. Database Management System (DBMS) Textbooks – Standard textbooks were used for
understanding relational database concepts, normalisation, and entity-relationship models.

5. Object-Oriented Programming Concepts – Principles of OOP such as inheritance, encapsulation,

and abstraction were followed during system design using Python classes and objects.

6. Tkinter GUI Library Documentation – Referred to for developing the graphical user interface in
Python, including window design, input forms, and event handling.

7. Project Development Notes and Lectures – Personal class notes and lectures provided guidance in
structuring the project and ensuring best practices were followed.

8. Python-MySQL Connector Module Documentation – Helped in integrating Python with MySQL

for data storage and retrieval operations.

9. Unit Testing Guidelines – Followed principles and techniques for writing test cases and performing
validation of system modules.

10. Academic Guidelines for Project Report Writing – Followed formatting and documentation
standards as per institution or university norms for preparing the nal project report.

Page 60
fi
fi
fi