DELHI PUBLIC SCHOOL

AZAAD NAGAR, KANPUR

COMPUTER SCIENCE(083)
PROJECT ON
FEE MANAGEMENT
ACADMEIC SESSION: 2024-25

ROLL NO: SUBMITTED BY:

MANYA GUPTA
 CERTIFICATION

This is to certify that Manya Gupta of class XII of

Delhi Public School Azaad Nagar Kanpur, has
completed her project under my supervision. She
has taken proper care and has shown utmost
sincerity in the compilation of this project.

I, hereby certify that this project is up to my

expectation and as per the guidelines issued by
CBSE for session 2024-25

External examiner Internal examiner

______________ ______________
Principle
Ms. Shilpa Manish
_________________
 ACKNOWLEDEMENT

I take this opportunity to express my gratitude to almighty god

for keeping me in good health throughout this session.

I world like to coney my sincere thanks to my Principle Ms.

Shilpa Manish for providing me the necessary resources to
complete my project.

I place on record my sincere gratitude and appreciation to my

teacher Mr. Vishal Khanna for his kind cooperation and
guidance which enabled me to complete my project on time.

I thank each and every who helped me to complete this

project.

Date: Name and sign of Student

GROUP MEMBERS:
MANYA GUPTA
TANISHA AHUJA
SIMRATH KAUR
 INDEX
SNO: TOPIC: PAGE NO:

1. INTRODUCTION 4
OVERVIEW ON
PYTHON AND
MYSQL
2. NEED FOR THE 10
PROJECT
3. BACKGROUND OF 11
THE PORJECT
4. FUNCTION AND 12
MODULES
5. FLOW OF 14
PROJECT
6. USE OF 16
TECHNOLOGY
7. HARDWARD AND 17
SOFTWARE
REQUIREMENT
8. SOURCE CODE 18
9. LIMITATION OF 32
THE PROJECT
11. BIBLOGRAPHY 33
INTRODUCTION
INTRODUCTION ON PYTHON

Python is a widely used programming language known for its simplicity and
versatility. Created by Guido van Rossum and released in 1991, Python has
become one of the most popular programming languages globally.

Why Learn Python?

1. Easy to Read and Write: Python’s clean syntax makes it accessible for
beginners. This allows developers to focus on programming concepts without
getting bogged down by complex syntax rules.

2. Versatile: Python is applicable in many fields, including web development, data

analysis, artificial intelligence, scientific computing, and automation. Its extensive
libraries and frameworks support a wide range of applications.

3. Community Support: Python boasts a large and active community, providing a

wealth of resources, tutorials, and libraries. This support is invaluable for both
new and experienced developers seeking help or collaboration.

4. Cross-Platform: Python is compatible with various operating systems, such as

Windows, macOS, and Linux. This cross-platform functionality allows
developers to create applications that work on multiple systems without significant
changes.

5. Dynamic Typing: Python employs dynamic typing, meaning that variable types
are determined at runtime. This flexibility can speed up development but
requires careful handling to avoid runtime errors.

6. Interpreted Language: Python is an interpreted language, which means that

code is executed line by line. This feature facilitates interactive coding and
debugging, making it easier to test programs as they are developed.
Practical Applications of Python

Python is extensively used in various domains, including:

- Web Development: For building dynamic websites and applications.

- Data Science: For analyzing and visualizing data.
- Machine Learning: For developing predictive models and algorithms.
- Automation: For automating repetitive tasks through scripting.

Python is a powerful and flexible programming language suitable for both

beginners and experienced developers. Its ease of use, versatility, and strong
community support make it an excellent choice for anyone looking to start coding
or enhance their programming skills. Whether in web development, data analysis,
or automation, Python provides the necessary tools to succeed.
INTRODUCTION TO MYSQL

MySQL is a widely used relational database management system (RDBMS)

known for its reliability, performance, and ease of use. Developed by MySQL
AB and released in 1995, it has become one of the most popular databases for
web applications and is a key component of many open-source projects.

Why Use MySQL?

1. User-Friendly: MySQL offers a straightforward interface and supports standard
SQL (Structured Query Language) for managing databases. This simplicity makes
it accessible for both beginners and experienced developers, allowing users to
efficiently create and manage databases.

2. High Performance: MySQL is optimized for speed and efficiency, making it

capable of handling large volumes of data and high-traffic applications. Its
performance benefits come from its ability to efficiently process queries and
transactions.

3. Open Source: MySQL is open-source software, meaning that its source code is
freely available for modification and distribution. This openness has fostered a
large community of developers who contribute to its continuous improvement.

4. Cross-Platform Compatibility: MySQL runs on various operating systems,

including Windows, macOS, and Linux. This cross-platform capability allows
developers to deploy applications using MySQL on different environments
without issues.

5. Scalability: MySQL can handle large databases and support complex queries,
making it suitable for applications of all sizes. Its architecture allows for both
vertical and horizontal scaling, enabling it to grow with your needs.
Practical Applications of MySQL

MySQL is extensively used in various domains, including:

- Web Development: For managing data in dynamic websites and web

applications.
- Data Warehousing: For storing and retrieving large volumes of data for analysis
and reporting.
- E-commerce: For managing product inventories, customer data, and transaction
records.
- Content Management Systems (CMS): As the backend database for popular
platforms like WordPress and Joomla.

MySQL is a powerful and flexible relational database management system that is

suitable for both beginners and experienced developers. Its user-friendly
interface, high performance, and strong community support make it an excellent
choice for anyone looking to manage data effectively. Whether for web
development, data warehousing, or e-commerce applications, MySQL provides
the tools necessary to succeed in data management.
Need for a Fee Management System
1. Efficiency: Automates fee collection and reduces administrative
workload.
2. Accuracy: Ensures precise tracking of payments and outstanding
dues.
3. Reporting: Generates real-time financial reports for informed
decision-making.
4. Communication: Sends automated reminders to students and
parents about payment deadlines.
5. Security: Protects sensitive financial data with user authentication
and access controls.
6. Scalability: Adapts to changing fee structures and policies easily.
7. Integration: Works with other systems (e.g., SIS, LMS) for
comprehensive data management.
8. Convenience: Supports online payments for timely transactions.

A fee management system is essential for enhancing efficiency,

accuracy, and security in financial operations at educational institutions.
Background of Fee Management
Fee management involves the systematic collection, tracking, and
administration of fees in educational institutions.
1. Transition to Digital: Initially reliant on manual processes, fee
management has evolved with technology, reducing errors and
inefficiencies.
2. Automation: Automated systems streamline fee collection and
tracking, easing administrative burdens and ensuring accuracy.
3. Integration: Modern solutions integrate with Student Information
Systems (SIS) and Learning Management Systems (LMS),
providing a comprehensive view of financial transactions.
4. User Experience: Today’s systems enhance user experience with
online payments and automated reminders, facilitating better
communication.
5. Regulatory Compliance: These systems promote transparency
and accountability, ensuring compliance with financial
regulations.
Conclusion
The evolution of fee management systems reflects the need for
efficiency and accuracy in handling educational finances, ultimately
enhancing service delivery for students and families.
MODULES

1. MySQL Connector:
• Import Statement: import mysql.connector
• Explanation: This module allows Python to connect to MySQL databases,
enabling operations like querying, inserting, and updating fee records.
2. Datetime:
• Import Statement: import datetime
• Explanation: This module provides classes for manipulating dates and
times, which can be useful for tracking payment dates and due dates in a
fee management system.
3. Random:
• Import Statement: import random
• Explanation: This module is used to generate random numbers, which can
be useful for creating unique identifiers or simulating random data for
testing purposes.
FUNCTION

1. connect:
o Function: mysql.connector.connect()
o Purpose: Establishes a connection to the MySQL database using
specified parameters (host, user, password, database).
2. cursor:
o Function: connection.cursor()
o Purpose: Creates a cursor object that allows execution of SQL
queries and retrieval of data from the database.
3. execute:
o Function: cursor.execute(query, params)
o Purpose: Executes the SQL query passed as a string; parameters can
be provided as a tuple to safely insert data.
4. fetchall:
o Function: cursor.fetchall()
o Purpose: Retrieves all rows from the result set of the last executed
query, returning them as a list of tuples.
5. commit:
o Function: connection.commit()
o Purpose: Saves all changes made during the current transaction to
the database, necessary for any insert, update, or delete operations.
Flow of the project

1. Project Initialization:
• Define Objectives: Clarify the purpose of the fee management system,
including functionalities such as fee collection, tracking, and reporting.
• Identify Stakeholders: Gather input from students, parents, and
administrative staff to understand their needs.
2. System Design:
• Database Design:
o Schema Development: Design the database schema with tables such
as students, fees, payments, and courses.
o Relationships: Define foreign key relationships (e.g., linking students
to payments).
• User Interface Design:
o Create wireframes for admin dashboards and student portals,
outlining how users will interact with the system.
3. Technology Selection:
• Programming Language: Choose Python for backend development due to
its simplicity and robust libraries.
• Database Management System: Use MySQL for reliable data storage and
management.
• Frameworks and Libraries: Consider frameworks like Flask or Django for
building the web application and libraries like mysql.connector for
database connectivity.
4. Development:
• Backend Development:
o Set Up Database: Use MySQL to create the database and necessary
tables.
o Implement CRUD Operations: Develop functions in Python for
Create, Read, Update, and Delete operations using
mysql.connector.
5. Testing:
• Unit Testing: Test individual functions and methods in the backend.
• Integration Testing: Ensure that the front end and back end work together
seamlessly.
• User Acceptance Testing (UAT): Validate the system with actual users to
ensure it meets their needs.
6. Deployment:
• Server Setup: Configure a web server (e.g., Apache, Nginx) to host the
application.
• Database Configuration: Set up MySQL in the production environment.
• Deployment of Application: Deploy the application code to the server and
ensure it connects to the MySQL database properly.
7. Training and Documentation:
• User Manuals: Create documentation for end-users explaining how to use
the system.
• Training Sessions: Conduct sessions for administrative staff to familiarize
them with the application.
8. Maintenance and Support:
• Monitor System Performance: Regularly check for issues and optimize
database queries.
• Provide Ongoing Support: Address user queries and fix bugs as they arise.
• Gather Feedback: Collect user feedback for future enhancements and
updates.
Use of technology
1. Python:
• Purpose: Backend development.
• Benefits: Easy to learn, rapid development, and a rich ecosystem of
libraries.
2. MySQL:
• Purpose: Data storage and management.
• Benefits: Reliable, high performance, and scalable for handling large
datasets.
3. Frameworks (Flask/Django):
• Purpose: Web application development.
• Benefits: Streamlines development, offers built-in security features, and
enhances flexibility.
4. Libraries (mysql.connector):
• Purpose: Database connectivity.
• Benefits: Simplifies integration between Python and MySQL, facilitating
efficient data operations.
HARDWARE AND SOFTWARE REQUIRMENT

DEVICE SPECIFICATION
Device name DESKTOP-0G8CI89
Processor 11th Gen Intel(R) Core(TM) i3-1115G4 @ 3.00GHz 1.69 GHz
Installed RAM 8.00 GB (7.65 GB usable)
Device ID 8D103598-64E6-45EE-8122-1F475D9BCB94
Product ID 00327-35920-12538-AAOEM
System type 64-bit operating system, x64-based processor
Pen and touch Pen and touch support with 10 touch points

WINDOW SPECIFICATION
Edition Windows 11 Home Single Language
Version 23H2
Installed on 27-02-2023
OS build 22631.4317
Experience Windows Feature Experience Pack 1000.22700.1041.0
SQL CODES
DBMS: MySQL
Host: root
Password: root
Database: School

-- Create the students table

CREATE TABLE students (
student_id INT AUTO_INCREMENT PRIMARY KEY, -- Unique student
identifier
first_name VARCHAR(50) NOT NULL, -- Student's first name
last_name VARCHAR(50) NOT NULL, -- Student's last name
date_of_birth DATE, -- Student's date of birth
enrollment_date DATE, -- Date the student enrolled
email VARCHAR(100) UNIQUE -- Unique email address for the
student
);
-- Create the fees table
CREATE TABLE fees (
fee_id INT AUTO_INCREMENT PRIMARY KEY, -- Unique fee record
identifier
student_id INT, -- ID of the student
amount DECIMAL(10, 2) NOT NULL, -- Amount due for the fee
due_date DATE, -- Date by which the fee is due
status ENUM('Paid', 'Pending', 'Overdue') DEFAULT 'Pending', -- Payment
status
FOREIGN KEY (student_id) REFERENCES students(student_id) -- Link to
students table
);
OUTPUT
OUTPUT

TABLE 1:

TABLE 2:
PYTHON
CODE
import mysql.connector

# Connect to the database

def create_connection():
try:
connection = mysql.connector.connect(
host="localhost",
user="root", # Correct username
passwd="root", # Your MySQL root password
database="school"
)
print("Connected to database.")
return connection
except mysql.connector.Error as e:
print("Connection failed:", e)
return None

# Add a new student

def add_student(connection):
first_name = input("First Name: ")
last_name = input("Last Name: ")
date_of_birth = input("Date of Birth (YYYY-MM-DD): ")
email = input("Email: ")

query = "INSERT INTO students (first_name, last_name, date_of_birth,

email) VALUES (%s, %s, %s, %s)"
values = (first_name, last_name, date_of_birth, email)
cursor = connection.cursor()
 cursor.execute(query, values)
connection.commit()
print("Student added successfully.")

# View all students or filter by criteria

def view_students(connection):
cursor = connection.cursor()

print("\n--- View Students ---")

print("1. View All Students")
print("2. View Students by First Name")
print("3. View Students by Last Name")
print("4. View Students by Date of Birth")

choice = input("Select a filtering option: ")

if choice == '1':
cursor.execute("SELECT * FROM students")
results = cursor.fetchall()
elif choice == '2':
first_name = input("Enter First Name: ").strip()
cursor.execute("SELECT * FROM students WHERE first_name = %s",
(first_name,))
results = cursor.fetchall()
elif choice == '3':
last_name = input("Enter Last Name: ").strip()
cursor.execute("SELECT * FROM students WHERE last_name = %s",
(last_name,))
 results = cursor.fetchall()
elif choice == '4':
date_of_birth = input("Enter Date of Birth (YYYY-MM-DD): ").strip()
cursor.execute("SELECT * FROM students WHERE date_of_birth = %s",
(date_of_birth,))
results = cursor.fetchall()
else:
print("Invalid choice. Returning to the main menu.")
return

# Display results or no results found

if results:
for row in results:
print(row)
else:
print("No students found matching the criteria.")

# Deposit fee for a student

def deposit_fee(connection):
student_id = input("Student ID: ")
amount = input("Fee Amount: ")
query = "INSERT INTO fees (student_id, amount, status) VALUES (%s, %s,
'Paid')"
values = (student_id, amount)
cursor = connection.cursor()
cursor.execute(query, values)
connection.commit()
print("Fee deposited successfully.")
# Remove a student
def remove_student(connection):
student_id = input("Student ID to remove: ")
query = "DELETE FROM students WHERE student_id = %s"
cursor = connection.cursor()
cursor.execute(query, (student_id,))
connection.commit()
print("Student removed.")

# Main menu
def menu():
connection = create_connection()
if not connection:
return

while True:
print("\n--- Fee Management System ---")
print("1. Add Student")
print("2. View Students")
print("3. Deposit Fee")
print("4. Remove Student")
print("5. Exit")

choice = input("Enter your choice: ")

if choice == '1':
add_student(connection)
elif choice == '2':
 view_students(connection)
elif choice == '3':
deposit_fee(connection)
elif choice == '4':
remove_student(connection)
elif choice == '5':
print("Exiting program.")
connection.close()
break
else:
print("Invalid choice. Try again.")

# Run the program

if __name__ == "__main__":
menu()
OUTPUT
OUTPUT:
1. ADDING STUDENT:

2. VIEWING STUDENT BY:

i.)View All Students
 ii) First name

iii) Last name

iv) DOB

3. Fee Depositing
4. Removing Student

5. Existing
Limitation of the project

1. User Access Control: Lacks authentication, allowing unauthorized access to

sensitive data.
2. Error Handling: Minimal error feedback for database connection issues or
unexpected errors.
3. Data Validation: Insufficient validation for inputs like email and fee amounts.
4. Scalability: May not perform well with a large number of students or
transactions.
5. Reporting: No features for generating reports or analyzing student
performance.
6. User Interface: Basic command-line interface lacks user-friendliness.
7. Integration: Does not connect with other educational tools or payment
systems.
8. Backup and Recovery: No strategy for data backup or recovery.
9. Session Management: Lacks tracking of user interactions and state
management.
10. Limited Features: Only supports basic operations with no advanced
functionalities.
BIBLIOGRAPHY
Bibliography

To develop this project many references were used:

6. https://www.google.com
7. https://www.python.org.in
8. https://www.mysql.org
9. Cs with python, class XII by sumita arora
10. Project on fee management by Sanjeev bhadauria