1

PROJECT REPORT
ON
LIBRARY MANAGEMENT

SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENT FOR THE

AWARD OF THE DEGREE OF
BACHELOR OF TECHNOLOGY
( COMPUTER SCIENCE AND ENGINEERING )
( SESSION : 2024-25 )

SUBMITTED BY:
Pushpender
211401015054

Under the Supervision of

Internal Supervisor: External Supervisor:

Mr. SANDEEP BENIWAL

DEPARTMENT OF COMPUTER SCIENCE ENGINEERING

RPS COLLEGE OF ENGINEERING AND TECHNOLOGY
MAHENDERGARH -123029
2

CONTENTS

Contents Page Number

Declaration by Student 3

Abstract 4

S/W H/W Requirements 5

Introduction 6

Objective 7-8

Technologies Used 9-13

Features 14-15

Future Enhancement 15-16

Screenshots 17-20

Code 21-34

Conclusion 35

References 36
3

DECLARATION BY STUDENT

I hereby certify that the work which is being presented in the report entitled
_______________________________ by______________________ Roll number ____________
in partial fulfillment of requirements for the award of degree of [Link] submitted to Department
of Computer Science Engineering of RPS COLLEGE OF ENGINEERING AND
TECHNOLOGY , MAHENDERGARH is an authentic record of my own work carried out
during a period from __________ to_________under the supervision of Mr. Sandeep Beniwal.

Signature of the Student

This is to certify that the above statement made by the candidate is correct to the best of my/our
know ledge

Signature ( SUPERVISOR )
4

ABSTRACT

The Library Management System is a web-based application designed to streamline the operations
of a library by providing an efficient way to manage books, users, and transactions. Built using
HTML, CSS, Python (Flask), and MySQL, this system offers a user-friendly interface and robust
backend functionality to automate traditional library operations such as book cataloging, user
registration, book issuance, and return management.

The Admin Panel allows librarians to manage books, track issued and returned books, handle
overdue fines, and monitor system activities. The application implements CRUD (Create, Read,
Update, Delete) operations on books and user data using MySQL, ensuring efficient data storage
and retrieval. Flask, a lightweight Python web framework, is used to handle backend processes,
including request handling, authentication, and database interactions.

The frontend, designed with HTML and CSS, ensures a responsive and intuitive interface. The
integration of Flask with MySQL enables dynamic interactions, making real-time updates possible.
Security features such as user authentication, access control, and input validation are
incorporated to prevent unauthorized access and data breaches. Additionally, the system includes a
search and filtering mechanism to enhance the user experience by providing quick access to book
details.

This project aims to replace traditional manual record-keeping with an automated digital solution that
enhances efficiency, accuracy, and accessibility in library management. The implementation of
modern web technologies ensures scalability and adaptability, making it suitable for libraries of
various sizes. Future enhancements may include barcode scanning, advanced analytics, and
mobile compatibility to further improve functionality and usability.
5

SOFTWARE/HARDWARE REQUIREMENTS

S/W REQUIREMENTS :

( Any Web Browser e.g. Firefox, Edge, Chrome, Brave etc)

H/W REQUIREMENTS :

( Almost works with every chipset i.e. intel dual core or greater )
6

INTRODUCTION
Libraries play a crucial role in educational institutions, research centers, and public domains by
providing access to vast collections of books and resources. Traditional library management
methods, which rely on manual record-keeping, are often inefficient, time-consuming, and prone to
errors. To address these challenges, a Library Management System (LMS) has been developed as a
web-based solution that enhances the efficiency of library operations.
The Library Management System is built using HTML, CSS, Python (Flask), and MySQL,
providing a seamless and interactive platform for librarians and users. The primary objective of this
system is to automate routine library tasks such as book cataloging, user registration, book issuance,
return management, and fine calculation. By integrating Flask as the backend framework, the
system ensures secure and dynamic interactions between users and the database, while MySQL is
utilized for structured data storage and retrieval.
This system is designed with two major user roles: administrators (librarians) and library
members (students, faculty, or general users). Administrators have access to features such as
adding and removing books, managing user records, and tracking borrowed books. On the other
hand, users can search for books, request issues, and monitor their borrowing history through an
intuitive web interface built with HTML and CSS.
One of the key benefits of this system is its ability to provide real-time book availability status,
reducing manual workload and ensuring smooth library operations. The system also implements user
authentication and role-based access control, ensuring data security and preventing unauthorized
access.
By transitioning from traditional methods to a digitized and automated library management
system, this project significantly improves efficiency, minimizes errors, and enhances user
experience. Future enhancements can include features like barcode scanning, mobile application
integration, and AI-powered book recommendations to further modernize and optimize library
management.
7

OBJECTIVES

The primary objective of the Library Management System is to design and develop a robust, user-
friendly, and automated system to streamline library operations and enhance efficiency. The system
aims to address various challenges associated with manual library management by leveraging
modern web technologies. The key objectives of the project are as follows:
1. Automation of Library Operations:
o Eliminate the need for manual processes in book issuance, returns, and cataloging,
reducing paperwork and administrative burden.
o Ensure faster and more accurate transaction processing, minimizing delays in book
borrowing and returning.
o Maintain digital records of all books, users, and transactions to prevent loss of
information and improve record-keeping accuracy.
2. Efficient Book and User Management:
o Store book and user information systematically in a MySQL database, ensuring fast
and efficient retrieval of records.
o Enable administrators to add, update, and delete book records, including details such
as title, author, genre, ISBN, and availability status.
o Provide user management features that allow librarians to register new members,
update membership details, and manage user accounts.
3. User-Friendly Interface:
o Develop a clean, intuitive, and responsive HTML and CSS-based frontend to ensure
easy navigation and accessibility for all users.
o Implement clear and organized layouts for different modules, such as book search,
borrowing history, and library management.
o Ensure cross-platform compatibility so that the system can be accessed from desktops,
tablets, and mobile devices.
4. Role-Based Access Control:
o Implement a secure login system that differentiates between user roles (librarians and
library members) and restricts access accordingly.
o Allow librarians to manage books, users, and transactions, while members can only
search for books, request borrowing, and view personal history.
o Ensure secure authentication using password encryption and session management
techniques to prevent unauthorized access.
5. Real-Time Availability and Tracking:
o Provide real-time updates on book availability status, ensuring users are informed
about which books are currently available or issued.
8

o Track each issued book, linking it to the corresponding user and due date, helping
librarians monitor borrowing activity effectively.
o Allow users to check their personal borrowing history, due dates, and remaining
allowed book loans.
6. Fine Calculation and Overdue Management:
o Automate fine calculations based on overdue book return policies, eliminating manual
calculations and discrepancies.
o Notify users via email or system notifications regarding approaching due dates,
overdue fines, and reminders to return books.
o Allow librarians to adjust fine amounts manually in case of exceptional circumstances
(e.g., damaged books, extensions, etc.).
7. Search and Filtering Mechanism:
o Implement a search functionality that enables users to find books by title, author,
ISBN, or genre.
o Introduce advanced filtering options that allow users to refine their searches based
on publication date, availability, or user ratings.
o Ensure fast query execution by optimizing search algorithms and database indexing
for better performance.
8. Security and Data Integrity:
o Utilize Flask’s security features to prevent SQL injection, Cross-Site Scripting
(XSS), and Cross-Site Request Forgery (CSRF) attacks.
o Ensure data encryption for sensitive information such as passwords and user
credentials.
o Implement regular database backups to prevent data loss and enable quick recovery
in case of system failures.
9. Scalability and Future Enhancements:
o Design a modular and flexible architecture that allows future upgrades and feature
additions without disrupting the existing system.
o Integrate barcode scanning for faster book check-ins and check-outs, improving
efficiency.
o Explore AI-based book recommendations to suggest books based on user
preferences and borrowing history.
o Develop a mobile application for Android and iOS to provide a more accessible and
on-the-go library management experience.
9

TECHNOLOGIES USED

The Library Management System is developed using a combination of modern web technologies to
ensure efficiency, security, and ease of use. The key technologies utilized in the project are:
1. Frontend Technologies:
o HTML5: Used for structuring web pages and presenting content in a user-friendly
manner.
o CSS3: Used for styling and enhancing the visual appeal of the system with responsive
design.
o JavaScript: Implemented for client-side interactions and dynamic UI functionalities.
2. Backend Technologies:
o Python (Flask Framework): Utilized as the backend framework to handle business
logic, request handling, and communication between the frontend and database.
o Jinja2 Templating Engine: Used within Flask to dynamically generate HTML pages
based on database content.
3. Database Management:
o MySQL: Used as the relational database to store and manage books, users,
transactions, and other essential data.
o SQLAlchemy ORM: Integrated to simplify database interactions and queries within
Flask.
4. Security Measures:
o Flask-WTF: Used for secure form handling and validation.
o Flask-Login: Implemented for user authentication and session management.
o Password Hashing (Werkzeug): Used to securely store user passwords in encrypted
form.
5. Development and Deployment Tools:
o Git & GitHub: Used for version control and collaborative development.
o Virtual Environment (venv): Used to manage dependencies and isolate the project
environment.
10

FRONTEND DEVELOPMENT
The frontend technologies used in the development of the Library Management System play a
crucial role in ensuring a seamless, interactive, and visually appealing user experience. The
combination of HTML5, CSS3, and JavaScript allows for the creation of a responsive, efficient,
and user-friendly web interface.
1. HTML5 (HyperText Markup Language 5)
HTML5 is the latest version of HTML and serves as the backbone of web page structure. It is used
for organizing and presenting content in a structured manner. In the Library Management System,
HTML5 is utilized for:
 Defining webpage structure: It helps in organizing elements like headers, sections, footers,
and navigation menus.
 Enhancing accessibility: Semantic elements such as <header>, <article>, <section>, and
<footer> improve readability and accessibility.
 Embedding multimedia: HTML5 enables the inclusion of audio, video, and other interactive
elements without requiring external plugins.
 Form handling: It supports modern form elements like <input type="email">, <input
type="date">, and <input type="search">, making user input more efficient.
 Offline web applications: With the help of features like local storage and the application
cache, HTML5 enables web applications to function even without an active internet
connection.
 Canvas API: HTML5 provides the <canvas> element, allowing for dynamic rendering of
graphics, charts, and custom UI components.
2. CSS3 (Cascading Style Sheets 3)
CSS3 is used to enhance the visual appearance and responsiveness of the Library Management
System. It ensures that the web pages are aesthetically pleasing and adapt well to different screen
sizes. Key features include:
 Styling and layout: CSS3 provides advanced styling options, including gradients, shadows,
and animations, to create a visually appealing design.
 Responsive design: CSS media queries allow the system to adapt to various screen sizes,
making it accessible on desktops, tablets, and mobile devices.
 Flexbox and Grid Layout: These modern CSS techniques help in creating well-structured
and flexible layouts, improving user experience.
 Transitions and animations: CSS3 animations enhance interactivity by making elements
more engaging.
 Custom Fonts and Icons: CSS3 supports the use of web fonts like Google Fonts and
scalable vector graphics (SVGs) for a more modern UI.
 Variable Support: CSS3 introduces variables (--variable-name), making it easier to maintain
consistent styling across a website.
11

 Dark Mode and Themes: CSS3 allows for the implementation of different themes using
variables and media queries, improving user experience.
3. JavaScript
JavaScript is a powerful programming language used to add interactivity and dynamic functionalities
to the frontend of the Library Management System. Its implementation ensures a seamless user
experience with real-time updates and enhanced navigation. Key uses of JavaScript in the project
include:
 Client-side interactivity: JavaScript enables features such as form validation, dropdown
menus, and modal popups.
 DOM manipulation: It allows dynamic content updates without requiring page reloads.
 AJAX for asynchronous requests: JavaScript helps in sending and receiving data from the
backend without refreshing the page, improving system efficiency.
 Event handling: JavaScript responds to user actions like clicks, keypresses, and hover
effects, enhancing usability.
 Frameworks and libraries: JavaScript can be extended using frameworks like [Link],
Angular, and [Link], or libraries like jQuery to simplify frontend development.
 Local and Session Storage: JavaScript provides APIs like localStorage and sessionStorage
for storing data on the client-side, reducing the need for repeated server requests.
 JSON Data Handling: JavaScript efficiently processes JSON (JavaScript Object
Notation), which is widely used for exchanging data with backend systems.
 Progressive Web Apps (PWA): JavaScript enables the development of offline-capable web
applications that work like native apps.
12

BACKEND TECHNOLOGIES
The backend technologies used in the Library Management System are responsible for
handling business logic, database management, and request-response handling. The
combination of Python (Flask Framework) and Jinja2 Templating Engine ensures a
robust, scalable, and efficient backend for the system.
1. Python (Flask Framework)
Flask is a lightweight and powerful web framework in Python used to build scalable and
maintainable backend applications. It is utilized in the Library Management System to
manage data processing, request handling, and interaction between the frontend and database.
Key features include:
 Microframework Architecture: Flask provides a minimalistic approach, allowing
developers to choose components as per the project requirements.
 Routing System: It manages URLs and HTTP requests efficiently using decorators
like @[Link]().
 RESTful API Development: Flask supports the development of REST APIs,
enabling smooth communication between frontend and backend components.
 Session and Authentication Handling: Flask provides built-in support for user
authentication and session management.
 Integration with Databases: Flask seamlessly integrates with MySQL,
PostgreSQL, SQLite, and other databases for efficient data management.
 Flask Extensions: Additional functionalities such as Flask-SQLAlchemy (ORM),
Flask-WTF (Forms), and Flask-Login (User Authentication) enhance system
capabilities.
 Scalability: Due to its lightweight nature, Flask enables easy scaling and deployment
of web applications.
2. Jinja2 Templating Engine
Jinja2 is a powerful templating engine used in Flask to dynamically generate HTML pages by
embedding Python code. It allows the frontend to interact with backend data efficiently. Key
features include:
 Dynamic HTML Rendering: Jinja2 enables the integration of database-driven
content into HTML templates.
 Template Inheritance: It allows reusing base templates to maintain a consistent
structure across multiple pages.
 Filters and Functions: Jinja2 provides built-in filters ({{ variable | filter }}) and
custom functions to manipulate data before rendering.
 Conditional Statements & Loops: It supports control structures like {% if %}, {%
for %}, and {% else %} to create dynamic content.
 Security Features: Jinja2 has built-in security measures like auto-escaping to prevent
Cross-Site Scripting (XSS) attacks.
13

DATABASE MANAGEMENT

1. MySQL
MySQL is used as the relational database to store and manage books, users, transactions, and other
essential data. Key features include:
 Efficient Data Storage: Stores structured data in tables with relationships between them.
 Scalability: Supports large amounts of data and concurrent transactions.
 Security: Provides user authentication, encryption, and access control features.
2. SQLAlchemy ORM
SQLAlchemy ORM is integrated within Flask to simplify database interactions and queries. Key
features include:
 Object-Relational Mapping (ORM): Allows developers to interact with the database using
Python objects instead of SQL queries.
 Database Abstraction: Supports multiple database systems without modifying code.
 Automatic Table Creation: Generates tables based on defined Python models, reducing
manual SQL work.
14

FEATURES
The Library Management System is designed to enhance the efficiency, accessibility, and security
of library operations by automating tasks and providing a seamless user experience. Below are the
key features, elaborated in detail:
1. User Authentication & Role Management
 Secure Login System: The system ensures that only authorized users can access specific
functionalities by implementing a role-based access control (RBAC) mechanism. Different
roles, such as Librarian and Library Members, have different permissions.
 Password Encryption: User passwords are securely stored using hashing and encryption
techniques to prevent unauthorized access.
 Session Management: Active sessions are managed securely, ensuring users remain
authenticated without unnecessary logins while preventing session hijacking.
 Forgot Password & Account Recovery: Users can reset their passwords securely using
email verification or security questions.
 Multi-Factor Authentication (MFA) (Optional Future Enhancement): For added
security, a two-step verification system could be implemented.
2. Book Management
 Comprehensive Book Records: The system maintains detailed book records, including title,
author, ISBN, publication year, genre, and availability status.
 Real-Time Availability Updates: Whenever a book is issued or returned, the status updates
automatically in the database.
 Bulk Import & Export of Book Data: The librarian can upload multiple book records using
CSV files or export the database for backup purposes.
 Category & Genre Classification: Books can be classified based on categories such as
Fiction, Non-Fiction, Academic, etc.
 Barcode/QR Code Support (Future Enhancement): Integration with barcode scanners for
easy book entry and checkout.
3. User Management
 Library Member Registration & Profile Management: Users can register, update their
profiles, and manage their borrowing history.
 Membership Types & Privileges: Different membership levels (e.g., student, faculty, guest)
determine borrowing limits and privileges.
 Borrowing & Fine History: Users can view their borrowing records, due dates, and fines
incurred.
 Account Suspension for Overdue Fines: If a user repeatedly fails to return books on time,
their account can be temporarily suspended until fines are cleared.
4. Book Issuing & Returning System
 Efficient Checkout Process: Users can borrow books, with the system recording the
borrowing date and due date.
 Automated Due Date Calculation: Based on library policies, the system calculates due
dates and displays them for reference.
 Fine Calculation & Payment System: Fines for late returns are automatically calculated,
with the option for online fine payment (Future Enhancement).
 Overdue Notifications & Reminders: Automated email and SMS alerts notify users of
upcoming due dates or overdue books.
 Reservation & Hold System: Users can place a book on hold if it is currently issued to
another user.
5. Search & Filtering
 Advanced Search Functionality: Users can search for books using keywords, including
title, author, ISBN, or genre.
 Filtering Options: Books can be filtered by availability, category, author, most borrowed, or
recently added.
 Sorting Mechanism: Books can be sorted by publication date, popularity, or alphabetical
15

order.
 Predictive Search (Future Enhancement): AI-based recommendations for search queries
based on user behavior.
6. Security & Data Protection
 SQL Injection & XSS Protection: The system implements input validation and prepared
statements to prevent security vulnerabilities.
 Cross-Site Request Forgery (CSRF) Protection: CSRF tokens are used to secure web
forms and prevent unauthorized actions.
 Encrypted User Credentials: All sensitive user information, such as passwords, is encrypted
using bcrypt or SHA hashing algorithms.
 Regular Database Backups: Automated backups ensure data recovery in case of system
failure.
 Role-Based Data Access: Prevents unauthorized users from modifying library records.
7. Report Generation
 Detailed Reports on Book Usage: Generates insights on frequently borrowed books, peak
borrowing times, and member activity.
 Overdue & Fine Reports: The system generates detailed overdue reports and total fines
collected.
 Exportable Reports: Reports can be downloaded in various formats, such as CSV, PDF, or
Excel, for administrative analysis.
 Graphical Data Representation: Uses charts and graphs to visualize borrowing trends and
book demand.
8. Future Scalability & Enhancements
 Barcode/QR Code Integration: Adding barcode scanning for easier book entry and
checkout.
 AI-Based Book Recommendations: Using machine learning to suggest books based on user
preferences and borrowing history.
 Mobile Application Development: A dedicated mobile app for library members to browse,
borrow, and receive notifications.
 Online Fine Payment System: Integration with payment gateways like PayPal, UPI, or
credit/debit cards for fine payments.
 Voice Search & Smart Assistance: Users can search for books using voice commands.
 Cloud-Based Library System: Migration to cloud-based storage for higher availability and
remote access.
16

FUTURE ENHANCEMENTS

The Library Management System has been designed with scalability in mind, ensuring that it can be
upgraded with new functionalities as library needs evolve. The following future enhancements are
proposed to further improve the efficiency, accessibility, and overall user experience of the system:
1. Mobile Application Development
o Develop a mobile application for Android and iOS platforms to provide users with a
seamless, on-the-go library experience.
o Users will be able to browse, search, and borrow books directly from their
smartphones.
o Push notifications can be integrated to remind users of due dates, overdue books, and
new book arrivals.
o A user-friendly UI will ensure smooth navigation and access to key features like
account management, borrowing history, and recommendations.
2. AI-Based Book Recommendation System
o Implement machine learning algorithms to analyze user reading patterns and provide
personalized book recommendations.
o The system can suggest books based on borrowing history, user ratings, and popular
books in similar categories.
o This feature will enhance user engagement and improve the discoverability of books
within the library.
3. Voice Search Integration
o Integrate a voice-enabled search functionality that allows users to find books using
voice commands.
o This will improve accessibility for users with disabilities and provide a faster
alternative to typing search queries.
o Natural Language Processing (NLP) techniques can be used to interpret user queries
and return relevant results.
4. Automated Inventory Management
o Implement a barcode or RFID-based book tracking system to automate the process of
issuing and returning books.
o This feature will significantly reduce human errors, improve transaction speed, and
prevent book misplacement.
o Librarians can scan books using a barcode scanner or mobile camera, automatically
updating the database in real time.
5. Cloud-Based Hosting & Scalability
17

o Deploy the Library Management System on a cloud platform such as AWS, Google
Cloud, or Azure.
o Cloud hosting will provide better accessibility, enhanced security, and scalability,
allowing multiple libraries to be managed under a single system.
o This will also enable users to access their library accounts from any device with an
internet connection.
6. Multilingual Support
o Introduce multilingual support to cater to users from diverse linguistic backgrounds.
o The system can allow users to switch languages dynamically, improving accessibility
for non-English speakers.
o Text-to-speech functionality can also be integrated to assist visually impaired users.
7. Advanced Analytics and Reporting
o Develop comprehensive analytics dashboards to provide librarians with insights into
book trends, user activity, and borrowing frequency.
o AI-driven predictive analysis can help in inventory forecasting, demand prediction,
and identifying underutilized books.
o Customizable exportable reports in formats such as PDF, CSV, and Excel can be
generated for administrative purposes.
8. Integration with Digital Libraries
o Enable integration with digital libraries and e-book platforms like Google Books,
Open Library, or Project Gutenberg.
o Users can access a wide range of e-books directly through the system, enhancing their
reading experience.
o This will provide students and researchers with instant access to digital resources,
reducing the need for physical book borrowing.
9. Automated Late Fee and Payment Integration
o Implement an automated fine calculation system that notifies users of overdue books
and outstanding fines.
o Integrate online payment gateways such as UPI, PayPal, or credit/debit card options
for quick and secure fine payments.
o This will reduce the manual workload of librarians and ensure smooth financial
transactions.
10. Social Features and Community Engagement
 Introduce discussion forums, book clubs, and review sections where users can interact, share
recommendations, and write reviews.
 Users can follow other readers, see trending books, and participate in library events or
reading challenges.
18

Glimpses / Snapshots of Project Modules

Login Page

Home Page
19

Add New Student

Issue a Book
20

List of Books

List of Students
21

SOME CODE SNIPPETS

[Link]
import [Link]
from flask import Flask, request, render_template,redirect,session,flash
from flask_session import Session
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
[Link]['SESSION_TYPE'] = 'filesystem'
[Link]['SECRET_KEY'] = 'abc'
Session(app)

db_config = {
'host' : 'localhost',
'user' : 'root',
'password' : 'pushpender',
'database' : 'library_db',
'port':'3306'
}
conn = [Link](**db_config)
cursor = [Link]()

@[Link]("/")
def home():
if 'Name' not in session:
return redirect('/login')
return render_template("[Link]")

@[Link]('/add_faculty', methods=['POST','GET'])
def add_faculty():
22

if 'Name' not in session:

return redirect('/login')

elif [Link] == 'POST':

name = [Link]('name')
branch = [Link]('branch')
connection = [Link](**db_config)
cursor = [Link]()
query = "INSERT INTO faculty (Name, Branch) VALUES (%s, %s)"
values = (name, branch)
[Link](query, values)
[Link]()
[Link]()
[Link]()
return redirect("/faculty")
return render_template('[Link]')

@[Link]('/faculty')
def list_faculty():
connection = [Link](**db_config)
cursor = [Link]()
query = "SELECT * FROM faculty"
[Link](query)
faculty = [Link]()
[Link]()
[Link]()
[Link]()
return render_template("[Link]", faculty=faculty)

@[Link]('/add_student', methods=['POST','GET'])
def add_student():

if 'Name' not in session:

23

return redirect('/login')

elif [Link] == 'POST':

name = [Link]('name')
branch = [Link]('branch')
connection = [Link](**db_config)
cursor = [Link]()
query = "INSERT INTO student (Name, Branch) VALUES (%s, %s)"
values = (name, branch)
[Link](query, values)
[Link]()
[Link]()
[Link]()
return redirect("/students")
return render_template('[Link]')

@[Link]('/students')
def list_student():

if 'Name' not in session:

return redirect('/login')
else:
connection = [Link](**db_config)
cursor = [Link]()
query = "SELECT * FROM student"
[Link](query)
student = [Link]()
[Link]()
[Link]()

return render_template('[Link]', student=student)

@[Link]('/add_book', methods=['POST','GET'])
24

def add_book():

if 'Name' not in session:

return redirect('/login')

elif [Link] == 'POST':

title = [Link]("title")
branch = [Link]("branch")
author_id = [Link]("author_id")
connection = [Link](**db_config)
cursor = [Link]()
query = "INSERT INTO Book (Title, Branch, Author_ID) VALUES (%s, %s, %s)"
values = (title, branch, author_id)
[Link](query, values)
[Link]()
return redirect("/book")
return render_template("[Link]")

@[Link]('/book')
def list_books():
if 'Name' not in session:
return redirect('/login')
else:
connection = [Link](**db_config)
cursor = [Link]()
query = '''SELECT
b.Book_ID,
[Link],
[Link],
COALESCE([Link]) AS Author_Name
FROM book b
LEFT JOIN authors a ON b.Author_ID = a.Author_ID
'''
25

[Link](query)
book = [Link]()
[Link]()
[Link]()
return render_template("[Link]", book=book)

@[Link]('/borrow_book', methods=['POST','GET'])
def borrow_book():
connection = [Link](**db_config)
cursor = [Link]()

if 'Name' not in session:

return redirect('/login')

elif [Link] == 'POST':

student_id = [Link]('student_id')
faculty_id = [Link]('faculty_id')
admin_Name = session['Name']
book_id = [Link]('book_id')
borrow_date = [Link]('borrow_date')

if (student_id and faculty_id) or (not student_id and not faculty_id):

return "Select either a student or a faculty member, not both.", 400

student_id = int(student_id) if student_id else None

faculty_id = int(faculty_id) if faculty_id else None

query = """
INSERT INTO BorrowedBooks (Student_ID, Faculty_ID, Book_ID,
Borrow_Date,admin_Name)
VALUES (%s, %s, %s, %s,%s)
"""
values = (student_id, faculty_id, book_id, borrow_date,admin_Name)
26

[Link](query, values)
[Link]()
[Link]()
[Link]()

return redirect("/borrow_list")
return render_template("Book_issued.html")

@[Link]("/borrow_list")
def borrow_list():
connection = [Link](**db_config)
cursor = [Link]()

if 'Name' not in session:

return redirect('/login')
else:
query = '''SELECT
i.Borrow_ID,
[Link],
COALESCE([Link], 'N/A') AS Student_Name,
COALESCE([Link], 'N/A') AS Faculty_Name,
i.borrow_date,
i.renew_date,
i.return_date,
admin_Name
FROM borrowedbooks i
LEFT JOIN student s ON i.Student_ID = s.Student_ID
LEFT JOIN faculty f ON i.Faculty_ID = f.Faculty_ID
LEFT JOIN book b ON i.Book_ID = b.Book_ID;
'''
[Link](query)
borrowedbooks = [Link]()
[Link]()
27

[Link]()
return render_template("borrow_list.html",borrowedbooks=borrowedbooks)

@[Link]("/update_borrow/<int:Borrow_ID>", methods=["GET", "POST"])

def update_borrow(Borrow_ID):
connection = [Link](**db_config)
cursor=[Link]()

if 'Name' not in session:

return redirect('/login')
else:
query = '''SELECT
i.Borrow_ID,
[Link],
COALESCE([Link], 'N/A') AS Student_Name,
COALESCE([Link], 'N/A') AS Faculty_Name,
i.borrow_date,
i.renew_date,
i.return_date
FROM borrowedbooks i
LEFT JOIN student s ON i.Student_ID = s.Student_ID
LEFT JOIN faculty f ON i.Faculty_ID = f.Faculty_ID
LEFT JOIN book b ON i.Book_ID = b.Book_ID
where i.Borrow_ID=%s;
'''
[Link](query, (Borrow_ID,))
borrow_record = [Link]()

if [Link]=='POST':
renew_date = [Link]("renew_date")
return_date = [Link]("return_date")

renew_date = renew_date if renew_date else None

28

return_date = return_date if return_date else None

update_query = """
UPDATE borrowedbooks
SET renew_date= %s, return_date = %s
WHERE Borrow_ID = %s
"""
[Link](update_query, (renew_date, return_date, Borrow_ID))
[Link]()

[Link]()
[Link]()
return redirect(("/borrow_list"))
[Link]()
[Link]()
return render_template("update_table.html", borrow=borrow_record, Borrow_ID=Borrow_ID)

@[Link]('/update_book/<int:Book_ID>', methods=['POST','GET'])
def update_book(Book_ID):
connection = [Link](**db_config)
cursor = [Link]()

if 'Name' not in session:

return redirect('/login')
else:
query = '''SELECT
b.Book_ID,
[Link],
[Link],
b.author_id
FROM book b
Where b.Book_ID = %s
'''
29

[Link](query,(Book_ID,))
book_record = [Link]()

if [Link] == 'POST':
title = [Link]("title")
branch = [Link]("branch")
author_id = [Link]("author_id")

update_query = """
UPDATE book
SET title = %s, branch = %s, author_id = %s
WHERE Book_ID = %s
"""

[Link](update_query, (title, branch, author_id, Book_ID))

[Link]()

[Link]()
[Link]()
return redirect("/book")
[Link]()
[Link]()
return render_template("update_book.html",book=book_record, Book_ID=Book_ID)

@[Link]('/update_student/<int:Student_ID>', methods=['POST','GET'])
def update_student(Student_ID):
connection = [Link](**db_config)
cursor = [Link]()

if 'Name' not in session:

return redirect('/login')
else:
query = '''SELECT
30

s.Student_ID,
[Link],
[Link]
FROM student s
Where s.Student_ID = %s
'''
[Link](query,(Student_ID,))
student_record = [Link]()

if [Link] == 'POST':
name = [Link]("name")
branch = [Link]("branch")

update_query = """
UPDATE student
SET name = %s, branch = %s
WHERE Student_ID = %s
"""

[Link](update_query, (name, branch, Student_ID))

[Link]()

[Link]()
[Link]()
return redirect("/students")
[Link]()
[Link]()
return render_template("update_student.html",student=student_record, Student_ID=Student_ID)

@[Link]('/update_faculty/<int:Faculty_ID>', methods=['POST','GET'])
def update_faculty(Faculty_ID):
connection = [Link](**db_config)
cursor = [Link]()
31

if 'Name' not in session:

return redirect('/login')
else:
query = '''SELECT
s.Faculty_ID,
[Link],
[Link]
FROM faculty s
Where s.Faculty_ID = %s
'''
[Link](query,(Faculty_ID,))
faculty_record = [Link]()

if [Link] == 'POST':
name = [Link]("name")
branch = [Link]("branch")

update_query = """
UPDATE faculty
SET name = %s, branch = %s
WHERE Faculty_ID = %s
"""

[Link](update_query, (name, branch, Faculty_ID))

[Link]()

[Link]()
[Link]()
return redirect("/faculty")
[Link]()
[Link]()
return render_template("update_faculty.html",faculty=faculty_record, Faculty_ID=Faculty_ID)
32

@[Link]("/delete_student/<int:Student_ID>", methods=['DELETE','POST','GET'])
def delete_student(Student_ID):
connection = [Link](**db_config)
cursor = [Link]()
if 'Name' not in session:
return redirect('/login')
else:
query = "DELETE FROM student WHERE Student_ID = %s"

[Link](query,(Student_ID,))
[Link]()

[Link]()
[Link]()

return redirect("/students")

@[Link]("/delete_faculty/<int:Faculty_ID>", methods=['POST','GET'])
def delete_faculty(Faculty_ID):

connection = [Link](**db_config)
cursor = [Link]()

if 'Name' not in session:

return redirect('/login')
elif [Link]=='POST' and [Link]('DELETE'):

query = "DELETE FROM faculty WHERE Faculty_ID = %s"

[Link](query,(Faculty_ID,))
[Link]()
33

[Link]()
[Link]()
return ("/faculty")

@[Link]('/login', methods=['POST','GET'])
def login():
connection = [Link](**db_config)
cursor = [Link]()

if [Link] == 'POST':
Name = [Link]("Name")
Password = [Link]("Password")

query = "SELECT * FROM admin WHERE Name = %s and Password = %s"

[Link](query,(Name,Password))
user = [Link]()

if user:
session['Name'] = Name
session_data = str(session)

update_query = "UPDATE admin SET session_data = %s WHERE Name = %s"

[Link](update_query, (session_data, Name))
[Link]()
return redirect('/loginu')
else:
return('invalid name or password','danger')
[Link]()
[Link]()
return render_template("[Link]")

@[Link]('/logout')
def logout():
34

[Link]()
return redirect("/login")

@[Link]('/loginu')
def login_success():
if 'Name' in session:
return redirect("/")
else:
return redirect('/login')

if __name__ == "__main__":
[Link](debug=True)
35

CONCLUSION

The Library Management System is a comprehensive solution designed to streamline and enhance
the management of library operations. By leveraging modern web technologies such as HTML,
CSS, Python, Flask, and MySQL, the system provides an intuitive and efficient platform for
librarians and users alike. It simplifies book borrowing, returns, inventory tracking, and user
management, thereby reducing manual effort and improving overall library efficiency.
Through the implementation of key features such as user authentication, book search, issue and
return management, automated reminders, and reporting, the system effectively addresses the
common challenges faced in traditional library management. The user-friendly interface ensures
accessibility for both librarians and readers, fostering an organized and systematic approach to book
handling.
The project also emphasizes security and data integrity, ensuring that user data and book records
are well protected. The integration of MySQL ensures efficient database management, while Flask
provides a flexible and scalable backend for seamless system operation.
Looking ahead, several future enhancements can be integrated to further optimize the system.
Features such as mobile application support, AI-driven book recommendations, voice search,
cloud hosting, multilingual support, and automated inventory management will enhance
accessibility, engagement, and efficiency. These advancements will allow the Library Management
System to evolve into a smart and technology-driven platform, meeting the dynamic needs of
modern libraries and users.
In conclusion, this Library Management System serves as a robust, scalable, and user-friendly
solution for efficient library operations. It not only modernizes traditional library workflows but also
paves the way for innovative enhancements and digital transformation in library management.
36

REFERENCES

1. Books & Articles:

o Tanenbaum, A. S. (2009). Modern Operating Systems (3rd ed.). Prentice Hall.

o Ullman, J. D., & Widom, J. (2008). A First Course in Database Systems (3rd ed.).
Pearson.

o Flanagan, D. (2020). JavaScript: The Definitive Guide (7th ed.). O'Reilly Media.

2. Websites & Online Resources:

o Mozilla Developer Network (MDN): [Link]

o W3Schools: [Link]

o Flask Documentation: [Link]

o MySQL Documentation: [Link]

o SQLAlchemy Documentation: [Link]

3. Software & Tools Used:

o Python (Flask Framework) - Version 3.9

o MySQL Database - Version 8.0

o HTML5, CSS3, JavaScript

o Visual Studio Code (VS Code)

o Git & GitHub for version control

4. Project-Specific References:

o Internal project documentation and team discussions.

o User feedback and testing reports.

o Industry standards and best practices for web development.