EVENT MANAGEMENT SYSTEM

An mini project report submitted to the partial fulfillment of the requirement for the award of
the degree of
BACHELOR OF COMPUTER SCIENCE
Submitted by
ISWARYA.J
REG.NO: 2308211802112017
ARUL NISHMA ROSHAM.J
REG.NO: 2308211802112010
Under the guidance of
S. Mary Daisy MCA., M.Phil.,
(Assistant Professor, Department of Computer Science)

DEPARTMENT OF COMPUTER SCIENCE

ST. JEROME’S COLLEGE

(Affiliated to Manonmaniam Sundaranar University, Tirunelveli)
Anandhanadarkudy, Nagercoil- 629201

NOVEMBER– 2025

i
 ST. JEROME’S COLLEGE
(Affiliated to Manonmaniam Sundaranar University, Tirunelveli)
Anandhanadarkudy, Nagercoil- 629201

DEPARTMENT OF COMPUTER SCIENCE

BONAFIDE CERTIFICATE

This is to certify that the mini project report entitled “EVENT MANAGEMENT
SYSTEM” is the bonafide record of the min project work done by ISWARYA J
REG.NO: 2308211802112017, ARUL NISHMA ROSHAM.J REG.NO: 2308211802112010
inpartial fulfillment of the requirements for the award of the degree of Bachelor of
Science in Computer Science of Manonmaniam Sundaranar University, Tirunelveli
during the academic year 2025-2026.

S.Mary Daisy MCA., M.Phil., Dr.v.Juliet rani M.CA.,M.Phil.,Ph.D.,

(Project Guide) (Head of the Department)

Place: Anandhanadarkudy External Examiner(s)

Date:

ii
 DECLARATION

We, ISWARYA J, ARUL NISHMA ROSHAN.J hereby declare that the mini project
report titled as " EVENT MANAGEMENT SYSTEM ", submitted to St.
Jerome’s College as part of the requirements for the Degree of Bachelor of
Computer Science, the work done under the guidance of S. Mary Daisy MCA.,
M.Phil., Assistant Professor, Department of Computer Science, St. Jerome’s college.

The report is submitted in partial fulfillment of the requirement for the internship.

Place: Anandhanadarkudy Signature of the Student

Date: 1. ISWARYA J
2.ARUL NISHMA ROSHAN.J

iii
 ABSTRACT

The Event Management System is a comprehensive web-based application

designed to automate and simplify the management of events, ticket
bookings, and participant registrations. Traditional methods of organizing
events, such as offline registration through paper forms or manual tracking
using spreadsheets, often lead to errors, data redundancy, and inefficiencies.
In addition, participants face challenges in accessing detailed information
about events, available tickets, and booking statuses. The proposed system
addresses these challenges by providing a centralized, database-driven
platform that ensures secure, efficient, and user-friendly event management
for both participants and administrators.
The system allows users to register and create personalized accounts,
enabling them to browse a catalog of scheduled events, view detailed
information such as event date, location, and ticket prices, and make
bookings online. Participants can track their registered events through a
dedicated dashboard and manage their account details with ease. The ticket
booking process is streamlined, with secure handling of booking data and
automatic updates to the backend database, ensuring data integrity and
preventing duplicate or conflicting bookings.

iv
 ACKNOWLEDGEMENT

First, I convey my heart full thanks to almighty God for this countless
blessing shown on me for this academic project work. He let me in every
event.

I wish to convey my heart full thanks to Dear Rev Fr. S.Hirudhaya Raju
Vendi, Correspondent St. Jerome’s college for his timely help to do my
project.

I wish to convey my heart full thanks to eminent person Dr. C. James

M.Sc.,M.Phil.,Ph.D., Principal of St. Jerome’s college for giving me an
opportunity to do this work.

I also wish to extend my thanks to Dr.v.Juliet rani M.CA.,M.Phil.,Ph.D., Head

of the department of Computer Science. She gave full support and
guidance to complete this project work in a perfect manner.

Also, I extend my profound thanks to my project S.Mary Daisy MCA.,

M.Phil., for his valuable guidance, encouragement and immense help in
making the project successful one.

I wish to convey my thanks to all the staff of Computer Science

department, who helped me in completing the project.

BY,

1. ISWARYA J

2. ARUL NISHMA ROSHAN.J

v
 TABLE OF CONTENTS
CHAPTER TITLE PAGE NO
NO
1. INTRODUCTON 1
1.PROJECT PROFILE 1
1.2 Aim 2
1.3 Objectives 2
1.4 Motivation 3

2. SYSTEM STUDY AND SYSTEM 4

ANALYSIS
2.1 Existing System 4
2.2 Proposed System 4
2.3 Feasibility Study 5

3. SYSTEM SPECIFICATION 9
3.1 Hardware Specifications 9
3.2 Software Specifications 9
3.3 Software Description 10

4. SYSTEM DESIGN 28
4.1 DATAFLOW DIAGRAM 31
4.2 SYSTEM ARCHITECTURE 35
4.3 DATABASE DESIGN 36

5. PROJECT DESCRIPTION 40
5.1 Modules 40

6. SYSTEM TESTING 45

7. APPENDIX 49
7.1 SOURCE CODE 49

8 SYSTEM IMPLEMENTATION 129

vi
 8.1 SAMPLE SCREEN LAYOUT 130

9 CONCLUSION 133

10 FUTURE ENHANCEMENT 134

11 BIBLIOGRAPHY 135

vii
 LIST OF FIGURES

Figure No Title Page.no

Figure 4.1 DFD Level-0 33

Figure 4.2 DFD Level-1 33

Figure 4.3 DFD Level-2 34

Figure 4.4 System Architecture 35

Figure 4.3.1 user 38

Figure 4.3.2 admin 38

Figure 4.3.3 Schedule_events 39

Fig 8.1.1 Login 130

Figure 8.1.2 Admin dashboard 131

Figure 8.1.3 Schedule event 131

Figure 8.1.4 my events 132

Figure 8.1.5 Dashboard 132

viii
 LIST OF ABBRIEVIATION

DBMS Database Management DBMS

System

HTML Hyper Text Markup HTML

Language

CSS Cascading Style Sheets CSS

SQL Structured Query SQL

Language

CRUD Create, Read, Update, CRUD

Delete

DB Database DB

ix
 1. INTRODUCTION
1.1 PROJECT PROFILE

In today’s digital and technology-driven world, event management has evolved

beyond traditional manual planning to more efficient, automated, and data-driven
approaches. Organizing events such as conferences, workshops, concerts, weddings,
and corporate gatherings requires effective coordination between organizers,
attendees, vendors, and venues. With the increasing demand for virtual and hybrid
events, there is a growing need for a centralized system that simplifies event
scheduling, registration, ticketing, and communication.

This project aims to develop a comprehensive online platform for event

management, combining a user-friendly frontend interface with a robust backend
database to deliver a seamless and efficient event planning experience. The system
facilitates event creation, attendee registration, venue booking, and payment
management while ensuring data accuracy, security, and real-time updates. By
integrating Database Management System (DBMS) principles into its design, the
project ensures data integrity, consistency, and reliability across all operations.

This project highlights the real-world application of DBMS concepts such as

normalization, CRUD operations, and relational database design. It not only
provides a practical solution for managing events online but also serves as a
learning platform to understand how structured data, efficient queries, and secure
information handling are essential for modern web-based applications.

1
1.2 AIM

The aim of this project is to develop an efficient, secure, and user-friendly

online Event Management System that streamlines the process of organizing
and attending events. It integrates a robust backend database to ensure accurate
storage, retrieval, and manipulation of event-related data. The system enables
organizers to create events, manage venues, and monitor registrations, while
allowing users to browse, register, and make payments conveniently.

This project particularly focuses on implementing Database Management

System (DBMS) concepts such as data integrity, normalization, and CRUD
operations. By combining an intuitive frontend with a structured backend
database, the system aims to simplify event operations, reduce manual errors,
and enhance user experience.

1.3 OBJECTIVES

• To develop a secure user registration and login system for event organizers,
attendees, and administrators.
• To design an event catalog displaying details such as event title, date, venue,
category, and ticket price.
• To implement an online registration and booking system that allows users to
register or purchase tickets.
• To manage event scheduling, payment processing, and real-time status
tracking.
• To create a normalized MySQL database supporting all CRUD operations
while maintaining data consistency and reliability.

2
1.4 MOTIVATION

With the rapid increase in social, academic, and corporate events, traditional
event management methods are often inefficient, error-prone, and time-
consuming. Organizers struggle to coordinate registrations, payments, and
schedules manually, while attendees face challenges accessing information and
booking events.

3
 2. CHAPTER
SYSTEM STUDY AND SYSTEM ANALYSIS

2. SYSTEM STUDY AND SYSTEM ANALYSIS

System study involves examining the requirements, functionalities, and

feasibility of the proposed Event Management System. The study focuses on
understanding how the system will help users register for events, browse
schedules, book tickets, and manage their profiles efficiently while ensuring
secure handling of user and event data.

2.1.1 Existing System

In the current scenario, events are managed either manually through offline
registration or using basic online platforms. Offline methods often require
physical presence, paper forms, and manual tracking, which can lead to delays,
lost information, or double bookings. Existing online platforms may allow
event listing but often lack a structured database-driven approach for managing
user registrations, event schedules, ticket bookings, and administrative tasks
efficiently. These limitations can result in issues such as data redundancy, slow
retrieval of bookings, and difficulty in tracking user participation.

2.1.2 Proposed System

The proposed system aims to overcome the limitations of existing methods by

providing a dedicated, database-driven Event Management System. Users can
create accounts, browse upcoming events, book tickets, and track their
registrations. Admins can schedule events, manage users, and monitor
bookings in real-time. The backend database ensures data integrity,

4
consistency, and secure transaction handling. The system is scalable, allowing
addition of new events, users, and features with minimal effort.

2.1.3 Feasibility Study

The feasibility study evaluates the technical, operational, and economic

feasibility of the project:

Technical Feasibility: Uses HTML/CSS for frontend, MySQL for backend,

and Python Flask for server-side logic — technologies that are reliable and
widely supported.

Operational Feasibility: User-friendly design ensures smooth interaction for

both participants and administrators.

Economic Feasibility: Reduces manual effort and operational costs compared

to offline registration systems, providing value to event organizers and
participants.

2.2 System Analysis

System analysis focuses on understanding the requirements and specifications

needed to design and develop the Event Management System effectively.

2.2.1 Functional Requirements

• User registration, login, and account management.

• Event catalog with schedules, locations, and ticket prices.
• Booking management for users (book, view, cancel tickets).
• Admin functionalities to schedule events, manage users, and monitor
bookings.

5
 • Secure database handling for all CRUD operations (Create, Read,
Update, Delete).

2.2.2 Non-Functional Requirements

Performance: Quick response time for viewing events and booking tickets.

Security: Secure user authentication and ticket transaction handling.

Reliability: Accurate and consistent storage of user, event, and booking data.

Scalability: Ability to handle a growing number of events and participants.

2.2.3 Data Flow Analysis

Data flows from users to the system through registration, login, event selection,
and ticket booking. The backend database handles storage, retrieval, and
updates while ensuring integrity and proper normalization.

2.2.5 Advantages of the Proposed System

• Efficient handling of user, event, and booking data.

• Reduced manual errors through automated database management.
• Enhanced participant experience with easy navigation and detailed event
information.
• Secure and reliable ticket booking and registration process.

2.3 Problems of the Existing System

The existing event management methods present several limitations that affect
efficiency, accuracy, and user experience. Offline registration is prone to lost
data, double bookings, and manual errors. Many current online systems lack
proper database design, making it difficult to track participants, manage events,
6
or maintain consistent records. issues like data redundancy, inconsistent
records, and poor order tracking can result in slow system performance.

Security is also a concern, as some platforms do not implement proper

authentication or secure handling of participant information, exposing sensitive
data to risk. these limitations create challenges for both users and
administrators, including poor user experience, inefficient management, and
unreliable event monitoring. A database-driven, secure, and user-friendly Event
Management System addresses these issues effectively.

2.4 Feasibility Study

Feasibility study evaluates whether the proposed Event Management System is

practical, cost-effective, and capable of meeting participant and admin
requirements.

Technical Feasibility

The system is built using HTML/CSS for frontend, Flask (Python) for backend
logic, and MySQL for database management — reliable and widely supported
technologies. Essential functionalities like event scheduling, booking
management, user authentication, and secure ticket handling are fully
supported.

Economic Feasibility

The system reduces manual effort and operational costs compared to offline
registration and spreadsheet tracking. Academic resources are sufficient for
development, making the project cost-effective while providing high value to
both organizers and participants.

7
Operational Feasibility

The platform is designed to be intuitive and user-friendly, requiring minimal

training for participants or admins. All necessary infrastructure (computers and
internet access) is already available, and training administrators for database
and event management is straightforward, ensuring smooth operational
deployment.

8
 3.CHAPTER

SYSTEM SPECIFICATION
3.1 Hardware Specifications

The hardware for the system is selected considering factors such as CPU processing
speed, memory access speed, peripheral speed, hard disk seek time, and
communication speed to ensure smooth performance of the online Event
Management platform
Processor : Intel Core i3 or higher
Motherboard : Intel 945G Express Chipset or compatible
Bus Speed : 2.80 GHz or higher
RAM : 4 GB minimum
Hard Disk : 250 GB or more
Monitor : 17” LED or larger
.
3.2 Software Specifications
The proposed system is developed using widely supported and reliable technologies
to ensure ease of development, maintenance, and scalability.

Operating System: : Windows 10 or higher

Frontend: : HTML5, CSS3, JavaScript
Backend: : MySQL for database management
Development Environment : Visual Studio Code

9
3.3 Software Description

HTML: (Hyper Text Markup Language)

HTML is the foundational markup language of the web, used to define the
structure and content of web pages. Every web page on the internet is built
using HTML, which organizes text, images, links, forms, multimedia, and
interactive elements. It is interpreted by browsers, which render the content
visually for users. HTML is not a programming language but a markup
language, meaning it annotates content with tags to describe its role or
meaning.

A standard HTML document follows a structured hierarchy:

1. DOCTYPE Declaration: `<!DOCTYPE html>` informs the browser about

the HTML version.

2. Root Element: `<html>` wraps all content on the page.

3. Head Section (`<head>`): Contains metadata, page title (`<title>`), character

encoding (`<meta charset="UTF-8">`), viewport settings for responsiveness,

links to CSS stylesheets (`<link>`), and scripts (`<script>`).

4. Body Section (`<body>`): Contains all visible elements like headings,

paragraphs, images, tables, lists, forms, and multimedia.

10
 Common HTML Tags

• Headings (`<h1>`–`<h6>`): Define headings, with `<h1>` being the most

important for hierarchy and SEO.

• Paragraphs (`<p>`): Structure text into readable blocks.

• Links (`<a>`): Navigate between pages or websites using `href` attribute.

• Images (`<img>`): Embed images with `src`, `alt`, `width`, and `height`.

• Lists:
• <ul> : Unordered lists (bullets)

• <ol>: Ordered lists (numbers)

• <li>`: Individual list items

• Tables: <table> organizes data in rows (`<tr>`), headers (`<th>`), and cells

(`<td>`).

• Divisions and Spans (`<div>`, `<span>`): Structural elements used for

grouping

and styling content.

11
 Attributes in HTML

Attributes provide extra information about elements:

• id: Unique identifier for JavaScript or CSS targeting.

• `class`: Groups elements for styling.

• `src`: Source path for images, videos, or scripts.

• `href`: Hyperlink reference.

• `alt`: Alternative text for accessibility.

• `title`: Tooltip text shown on hover.

Forms and Input Elements

Forms (`<form>`) collect user input through various elements:

`<input>`: Text, email, password, number, radio buttons, checkboxes, file

upload.
`<textarea>`: Multi-line text input.
`<select>`: Drop-down menus.
`<button>`: Submit, reset, or clickable buttons.

Multimedia Support :

HTML supports embedding multimedia:

• `<audio>`: Audio files with attributes like `controls`, `autoplay`, `loop`.

• `<video>`: Video files with `controls`, `poster`, and `autoplay`.
• `<canvas>`: Graphics and animations using JavaScript.

12
 Semantic HTML
• `<header>`, `<footer>`: Page header and footer sections.
• `<nav>`: Navigation menus.
• `<main>`: Main content area.
• `<article>`: Self-contained content.
• `<section>`: Grouped thematic content.
• `<aside>`: Sidebar or supplementary content.

Accessibility and SEO

HTML ensures web accessibility for all users, including those using screen
readers. Proper use of tags like `<label>` for form inputs, `alt` for images, and
heading hierarchy ensures inclusivity and search engine optimization.

Integration with CSS and JavaScript

HTML provides the structure, while CSS handles styling (colors, layouts,
responsiveness), and JavaScript adds interactivity (event handling, dynamic
content). Without HTML, web applications cannot exist, as it is the backbone
of the front-end.

2. CSS (Cascading Style Sheets)

CSS (Cascading Style Sheets) is a styling language used to control the
presentation of HTML content. While HTML provides the structure of a web
page, CSS defines its visual appearance, including layout, colors, fonts,
spacing, and interactive effects. CSS allows developers to separate content
(HTML) from design, promoting cleaner code, consistency across pages, and
easier maintenance.
13
Basic Syntax
CSS is composed of selectors and declarations:
Selector: Specifies the HTML element(s) to style. Example: `p`,
`.className`, `#idName`.

Declaration Block: Enclosed in `{}`, contains property-value pairs that

define the style.

Example:

p{
color: blue;
font-size: 16px;
}

Ways to Apply CSS :

1. Inline CSS: Directly in an HTML element using the `style` attribute. Example:

`<p style="color: red;">Text</p>`

2. Internal CSS: Within a `<style>` tag in the HTML `<head>`.

3. External CSS: Linked via a separate `.css` file using `<link>` in the `<head>`.

This is the preferred method for maintainability and reusability.

14
Selectors :
Selectors define which HTML elements the styles apply to:

• Type Selector: Targets elements by tag, e.g., `h1 {}`.

• Class Selector: Targets elements by class, e.g., `.button {}`.
• ID Selector: Targets unique elements by ID, e.g., `#header {}`.
• Universal Selector: applies styles to all elements.

Group Selector: Applies the same style to multiple elements, e.g., `h1, h2, p {}`.

Pseudo-classes: Style elements in specific states, e.g., `a:hover`, `input:focus`.

Pseudo-elements: Target parts of elements, e.g., `p::first-line`, `::before`, `::after`.

CSS properties control visual characteristics:

• Text and Fonts: `font-family`, `font-size`, `font-weight`, `line-height`, `text-

align`, `color`.
• Box Model: Defines element dimensions and spacing using `width`, `height`,
`padding`, `margin`, `border`.
• Backgrounds: `background-color`, `background-image`, `background-size`,
`background-repeat`.
• Display and Visibility: `display`, `visibility`, `opacity`.
• Positioning: `static`, `relative`, `absolute`, `fixed`, `sticky`.

15
Layout Techniques :

Modern web design relies on advanced layout systems:

• Flexbox: Aligns and distributes elements in one-dimensional space.

Properties include `display: flex`, `justify-content`, `align-items`, and `flex-
wrap`.
• CSS Grid: Two-dimensional layout system for rows and columns. Properties
include `grid-template-columns`, `grid-template-rows`, `gap`, `grid-area`.
• Float and Positioning: Older techniques for positioning elements, now
mostly replaced by Flexbox and Grid.

Responsive Design :

Media Queries: Apply styles based on screen width, height, or device type.
Example:

@media screen and (max-width: 768px) {

.container {
width: 100%;
}
}
Relative Units: Using `%`, `em`, `rem`, `vw`, and `vh` instead of fixed pixels for
flexible layouts.

16
Transitions, Animations, and Effects:

CSS allows dynamic effects without JavaScript:

Transitions: Smoothly change properties on events like hover. Example:

`transition: all 0.3s ease;`.
Animations: Keyframe-based animations using `@keyframes`. Example: moving,
fading, or rotating elements.

Transformations: `transform: scale()`, `rotate()`, `translate()`.

CSS Variables and Reusability :

CSS supports custom properties (variables) for consistency and maintainability.

Example:

:root {
--main-color: #3498db;
}
button {
background-color: var(--main-color);
}

CSS works alongside HTML and JavaScript:

HTML: CSS styles HTML elements to enhance aesthetics and readability.

17
JavaScript: CSS classes can be dynamically added, removed, or modified to create
interactive effects.

3. JavaScript (JS):

JavaScript is a high-level, interpreted scripting language primarily used for

creating dynamic, interactive, and responsive web applications. Unlike HTML
and CSS, which provide structure and style, JavaScript adds behavior and logic to
web pages. It can manipulate HTML elements, validate forms, respond to user
events, communicate with servers, and control multimedia content. JavaScript
runs directly in the browser (client-side) but can also be used on the server-side
with platforms like Node.js.

Core Features

Interactivity: JS enables elements to react to user actions such as clicks, scrolls,

mouse movements, and keyboard inputs.

Dynamic Content: Updates HTML content without reloading the page using DOM
manipulation.

Event Handling: Listens to events like `onclick`, `onmouseover`, `oninput`,

allowing responsive applications.

Validation: Performs real-time form validation to ensure correct user input before
submission.

Client-Side Logic: Reduces server load by performing calculations and decisions

directly in the browser.

18
Basic Syntax

JavaScript code is typically embedded in HTML using the `<script>` tag or linked
as an external `.js` file. It uses statements, variables, operators, functions, and
objects to implement logic.

Example:

function greetUser(name) {
alert("Welcome, " + name + "!");
}

Variables and Data Types

• Variables: Store data using `var`, `let`, or `const`.

• Data Types: Strings, numbers, booleans, arrays, objects, `null`, and
`undefined`.
• Objects and Arrays: Allow structured storage of related data and enable
complex operations.

DOM Manipulation
The Document Object Model (DOM) represents the HTML structure as objects.

Change text content: `document.getElementById("title").innerText = "New

Title";`

Modify attributes: `document.querySelector("img").src = "newimage.jpg";`

Add or remove elements: `element.appendChild()` and `element.remove()`.

Change CSS dynamically: `element.style.color = "blue";`

19
Event Handling

JavaScript allows websites to respond to user actions:

Mouse Events: `click`, `dblclick`, `mouseover`, `mouseout`.

Keyboard Events: `keydown`, `keyup`, `keypress`.

Form Events: `submit`, `change`, `input`.

Functions and Reusability :

Functions are reusable blocks of code performing specific tasks.

Example:

function calculateTotal(price, quantity) {

return price quantity;

AJAX and API Integration

JavaScript can communicate with the server asynchronously without reloading the
page using AJAX (Asynchronous JavaScript and XML) or Fetch API.

This enables:

• Loading data dynamically from a database or API.

• Real-time updates, such as chat systems or notifications.
• Smooth user experience in single-page applications (SPAs).

20
ES6 and Modern Features

Modern JavaScript (ES6 and above) introduces features like:

Arrow functions: `const sum = (a, b) => a + b;`

Template literals: `` `Hello, ${name}!

Destructuring: Extracting values from arrays and objects.

Modules: Organize code into reusable files.

Integration with HTML and CSS

HTML: JS interacts with HTML elements to dynamically update content,

hide/show sections, or validate inputs.

CSS: JavaScript can manipulate styles or add/remove CSS classes to create

animations, transitions, and responsive design effects.

4. MySQL (Structured Query Language) :

MySQL is a widely used open-source relational database management system
(RDBMS). It stores, organizes, and manages structured data in a way that allows
efficient retrieval, insertion, and modification using Structured Query Language
(SQL). MySQL is widely used in web and software applications for storing user
data, transactional records, and system configuration. Its robustness, scalability,
and reliability make it a popular choice for small to enterprise-level projects.

Database Concepts
Database: A collection of related data stored in an organized manner.

Table: Structured in rows and columns, tables store data logically.

Row (Record): Represents a single data entry in a table.

Column (Field): Defines the data type and attributes of each piece of
information.

21
Primary Key: A unique identifier for each record in a table.

Foreign Key: Establishes relationships between tables, maintaining referential

integrity.

Data Types in MySQL :

• Numeric: `INT`, `FLOAT`, `DOUBLE`, `DECIMAL`.
• String/Character: `VARCHAR`, `CHAR`, `TEXT`.
• Date & Time: `DATE`, `DATETIME`, `TIMESTAMP`, `TIME`.
• Boolean: `BOOLEAN` or `TINYINT(1)` for true/false values.

SQL Commands
MySQL operations are performed using SQL, divided into:
1. Data Definition Language (DDL): Define database structures.

CREATE DATABASE db_name;`

CREATE TABLE table_name (...);`

ALTER TABLE table_name ADD column_name datatype;`

DROP TABLE table_name;`

2. Data Manipulation Language (DML): Manage data within tables.

INSERT INTO table_name (...) VALUES (...);`
UPDATE table_name SET column=value WHERE condition;`
DELETE FROM table_name WHERE condition;`

22
3. Data Querying: Retrieve data using `SELECT` statements.
Filtering: `WHERE`, `LIKE`, `BETWEEN`.
Sorting: `ORDER BY`.
Grouping: `GROUP BY`, `HAVING`.

4. Data Control Language (DCL): Manage access and permissions.

- `GRANT` and `REVOKE` commands to control user privileges.

5. Transaction Control: Ensures data integrity.

- `COMMIT`, `ROLLBACK`, and `SAVEPOINT` to manage transactions.

Database Relationships
One-to-One: Each record in Table A corresponds to one in Table B.

One-to-Many: A single record in Table A relates to multiple records in Table B

(common in users and orders).

Many-to-Many: Achieved through junction tables (e.g., students and courses).

Indexing and Optimization :

Primary Index: Automatically created on primary keys.

Secondary Index: Custom indexes for frequently queried columns.

Unique Index: Ensures column values are unique.

23
Backup and Security

Data Backup: Using `mysqldump` or automated scheduled backups.

Access Control: User privileges and role management to prevent unauthorized

access.

Encryption: SSL/TLS connections and encrypted storage for sensitive data.

Integration with Web Applications

- Connection: Establish a connection using libraries such as `mysql-connector-

python` or `SQLAlchemy`.

- Query Execution: Send SQL commands to the database to fetch or update

records.

- Dynamic Content: Serve data from the database to HTML pages via
templates.

- Form Handling: Insert user input from web forms into database tables while
validating and sanitizing inputs.

Importance in Projects
MySQL serves as the backend data storage system, enabling persistent,
structured, and secure data management. It ensures data integrity through
relationships, supports scalable operations, and allows real-time data retrieval
for dynamic applications. In web-based projects, MySQL is critical for
handling users, transactions, reports, and application configurations efficiently.

Flask is a lightweight, micro web framework written in Python that is widely

used for developing dynamic web applications and APIs. Unlike full-stack
24
 frameworks, Flask provides the core tools needed for web development—such
as routing, templating, and request handling—without enforcing a specific
project structure. This minimalistic approach allows developers to build
scalable, modular, and flexible applications while choosing additional libraries
as needed. Flask is based on the WSGI (Web Server Gateway Interface)
standard, enabling smooth communication between web servers and Python
applications. Its simplicity, extensibility, and compatibility with modern
Python libraries make it ideal for both small projects and complex enterprise-
level applications.

Key Features of Flask

1. Routing
Routing in Flask determines how URLs correspond to functions in the
backend. Each route is defined using the `@app.route()` decorator, which maps
a specific URL endpoint to a Python function that processes requests and
returns responses.

Dynamic URLs: Flask supports variable URLs, e.g., `/user/<int:id>`, allowing

pages to be generated dynamically based on input.

HTTP Methods: Routes can handle multiple HTTP methods (`GET`,

`POST`, `PUT`, `DELETE`), enabling RESTful API development.

2. Templating with Jinja2

Flask integrates with Jinja2, a powerful templating engine that allows
developers to create dynamic HTML pages.

Variable Rendering: Python variables can be embedded in HTML using `{{

variable }}` syntax.

25
 Control Structures: Loops (`{% for %}`) and conditionals (`{% if %}`) can
control content display.

Template Inheritance: Enables reusable layouts, reducing redundancy and

improving maintainability.

3. Request and Response Handling

Flask provides the `request` object to access form data, query parameters,
cookies, and headers.

`request.form`: Retrieves POST form data.

`request.args`: Accesses query parameters in GET requests.
Response objects can include HTML, JSON, or files for client consumption.

4. Form Processing and Validation

Flask supports processing user input through forms. With libraries like Flask-
WTF, developers can implement.

Field validation (required fields, length, patterns).

CSRF (Cross-Site Request Forgery) protection for secure data handling.

Error messages and dynamic form feedback for improved user experience.

26
5. Database Integration
Flask can connect to relational databases (MySQL, PostgreSQL, SQLite) or
NoSQL databases using ORM libraries like SQL Alchemy.

CRUD Operations: Create, read, update, and delete database records.

Data Models: Define structured data models with relationships, constraints,

and indexes.

Transactions: Manage data consistency and integrity with commit and

rollback operations.

6. Extensibility and Modular Design

Flask’s modular architecture allows adding features as extensions without
bloating the application.

Flask-Login: User authentication and session management.

Flask-Mail: Sending emails.

Flask-Migrate: Database migrations and version control.

Flask-RESTful: Simplified creation of REST APIs.

7. Error Handling and Debugging

Flask provides tools for error handling and debugging:

Custom error pages for 404, 500, or other HTTP errors.

Debug mode for live code reloading and interactive debugging during
development.

27
 4.CHAPTER
SYSTEM DESIGN
4. SYSTEM DESIGN

Design is the first step into the development phase for any engineered product
or system. Design is a creative process. A good design is the key to effective
system. The term
“design” is defined as “the process of applying various techniques and
principles for the purpose of defining a process or a system in sufficient detail
to permit its physical realization”. It may be defined as a process of applying
various techniques and principles for the purpose of defining a device, a
process or a system in sufficient detail to permit its physical realization.

Software design sits at the technical kernel of the software engineering process
and is applied regardless of the development paradigm that is used. The system
design develops the architectural detail required to build a system or product.
As in the case of any systematic approach, this software too has undergone the
best possible design phase fine tuning all efficiency, performance and accuracy
levels. The design phase is a transition from a user-oriented document to a
document to the programmers or database personnel. System design goes
through two phases of development: Logical and Physical Design.

INPUT DESIGN

The input design is the process of entering data to the system. The input design
goal is to enter to the computer as accurate as possible. Here inputs are
designed effectively so that errors made by the operations are minimized. The
inputs to the system have been designed in such a way that manual forms and
the inputs are coordinated where the data elements are common to the source
document and to the input. The input is acceptable and understandable by the
users who are using it. The quality of the system input determines the quality
28
for system output. Input specification describes the manner in which data
entered the system processing. Input design is the process of converting user-
originated inputs to a computer-based format input data are collected and
organized into group of similar data. Once identified, appropriate input media
are selected for processing.

The input design also determines the user to interact efficiently with the
system. Input design is a part of overall system design that requires special
attention because it is the common source for data processing error. The goal of
designing input data is to make entry easy and free from errors. Five objectives
of the input design are:

• Effectiveness
• Accuracy
• Ease to use
• Consistency
• Attractiveness
The main objectives that are done during the input design are:

• Data are collected from the source

• Transfer of data to an input form is done

• Data is converted to a computer acceptable form
• The converted data are verified.

• Data are checked for its accuracy.

• Validation of input data are done

• Data collections are done to eliminate the error

29
OUTPUT DESIGN

The output design was done so that results of processing could be

communicated to the users. The various outputs have been designed in such a
way that they represent the same format that the office and management used
to. Computer output is the most important and direct source of information to
the user. Efficient, intelligible output design should improve the systems
relationships with the user and help in decision making. A major form of output
is the hardcopy from the printer. Output requirements are designed during
system analysis. A good starting point for the output design is the Data Flow
Diagram (DFD). Human factors educe issues for design involves addressing
internal controls to ensure readability. Modularity is one the desirable
properties of large systems. It implies that the system is divided into several
parts. In such a manner, the interaction between parts is minimal clearly
specified. Design will explain software components in detail.

This will help the implementation of the system. Moreover, this will guide the
further changes in the system to satisfy the future requirements

System design is described as a process of planning a new business system or

more to replace or to complement an existing system. The system design states
how a system will meet the requirements identified during the system analysis.
It describes a solution of approaching to the creation of new system. System
design is a transmission from a user-oriented document to a document oriented
to programmers. It goes through a logical and physical design. The key points
followed at the times of designing are:

• Preparing input and output specification

• Data flows and stores
• Preparing security and control specification
• Temporary and permanent collection of data

30
 Reviewing the study phase activities and making decisions about which
functions are to be performed by the hardware, software, and human ware
started in the design phase. The output, input and file design for each of the
programs was done. Finally, the generalized systems were e7lained to the
management for approval

The steps involved in designing phase were:

a) The function to be performed is identified

b) The input, output and file design is performed

c) The system and component cost requirements is specified

d) The design phase report is generated

4.1 DATAFLOW DIAGRAM

The Data Flow Diagram shows the flow of data or information. It can be
partitioned into single processes or functions. Data Flow Diagrams can be
grouped together or decomposed into multiple processes.

The DFD is an excellent communication tool for analysts to model processes

and functional requirements. Used effectively, it is a useful and easy to
understand modelling tool. It has broad application and usability across most
software development projects. It is easily integrated with data modelling,
workflow modelling tools, and textual specs. Together with these, it provides
analysts and developers with solid models and specs. Alone, however, it has
limited usability. It is simple and easy to understand by users.

And can be easily extended and refined with further specification into a
physical version for the design and development teams.

31
The symbols used to prepare DFD do not imply a physical implementation, a
DFD can be considered to an abstract of the logic of an information-oriented or
a process-oriented system flow-chart. For these reasons DFDs are often
referred to as logical data flow diagrams. The four basic symbols used to
construct data flow diagrams are shown below:

A rectangle represents a data source or destination.

A directed line represents the flow ofdata stream.

An enclosed figure, usually a circle or an oval

bubble, represent a process that transforms data

streams.

An open-ended rectangle represents data storage.

These are symbols that represent data flows, data sources, data
transformations and data storage. The points at which data are transformed are
represented by enclosed figures, usually circles, which are called nodes. The
principle processes that take place at nodes are:

1. Combining data streams.

2. Splitting data streams.

3. Modifying data streams.

32
DFD Level 0

EVENT
Admin MANAGEMENT User
SYSTEM

Fig 4.1 DFD Level 0

DFD Level 1

Fig 4.2 DFD Level 1

33
DFD Level-2

Fig 4.2 DFD Level 2

34
4.2 SYSTEM ARCHITECTURE

EVENT MANAGEMENT SYSTEM

5.

Admin Interface User Interface

Login Page New Customer

Information

Product Model Login Page

Information

Product Features Search Product

Order Purchase Product

Information

Fake Review Shipping

Detection Information

Card Transaction

Review Product

Fig 4.3 System Architecture

35
4.3 DATABASE DESIGN

A database is an organized mechanism that has the capability of storing

information through which a user can retrieve stored information in an
effective and efficient manner. The data is the purpose of any database and
must be protected.

The database design is a two-level process. In the first step, user

requirements are gathered together and a database is designed which will meet
these requirements as clearly as possible. This step is called Information Level
Design and it is taken independent of any individual DBMS.

In the second step, this Information level design is transferred into a design for
the specific DBMS that will be used to implement the system in question. This
step is called Physical Level Design, concerned with the characteristics of the
specific DBMS that will be used. A database design runs parallel with the
system design. The organization of the data in the database is aimed to achieve
the following two major objectives.

• Data Integrity.
• Data independence.

Normalization is the process of decomposing the attributes in an application,

which results in a set of tables with very simple structure. The purpose of
normalization is to make tables as simple as possible. Normalization is carried
out in this system for the following reasons.

• To structure the data so that there is no repetition of data, this helps in

saving.

• To permit simple retrieval of data in response to query and report request.

• To simplify the maintenance of the data through updates, insertions,

deletions.
36
 • To reduce the need to restructure or reorganize data which new application
requirements arise.

RELATIONSHIP DATABASE MANAGEMENT SYSTEM (RDBMS)

A relational model represents the database as a collection of relations. Each

relation resembles a table of values or file of records.

In formal relational model terminology, a row is called a tuple, a column

header is called an attribute and the table is called a relation. A relational
database consists of a collection of tables, each of which is assigned a unique
name. A row in a tale represents a set of related values.

RELATIONS, DOMAINS & ATTRIBUTES

A table is a relation. The rows in a table are called tuples. A tuple is an

ordered set of n elements. Columns are referred to as attributes. Relationships
have been set between every table in the database. This ensures both
Referential and Entity Relationship Integrity. A domain D is a set of atomic
values. A common method of specifying a domain is to specify a data type
from which the data values forming the domain are drawn. It is also useful to
specify a name for the domain to help in interpreting its values. Every value in
a relation is atomic, that is not decomposable.

RELATIONSHIPS

Table relationships are established using Key. The two main keys of prime
importance are Primary Key & Foreign Key. Entity Integrity and Referential
Integrity Relationships can be established with these keys. Entity Integrity
enforces that no Primary Key can have null values. Referential Integrity
enforces that no Primary Key can have null values.

37
 Referential Integrity for each distinct Foreign Key value, there must exist a
matching Primary Key value in the same domain. Other key are Super Key
and Candidate Keys. Relationships have been set between every table in the
database. This ensures both Referential and Entity Relationship Integrity.

Table Structures
4.3.1 User
Name Type
User_id int(125)
name varchar(150)
Email varchar(150)
Password varchar(150)
Phone Int(10)

4.3.2 admin
Name Type
admin_id int(100)
User_name int(100)
Password varchar(100)

38
4. 3.3 schedule__events
Name Type
schedule_id int(10)
user_id int(11)
name varchar(255)
Email varchar(255)
phone int(10)
event varchar(255)
event_type varchar(255)
event_services int(10)
addendess varchar(255)
event_date varchar(255)
Expdate varchar(255)
prod_count int(15)
total_amt int(15)
Cvv int(5)

39
 5.CHAPTER

PROJECT DESCRIPTION

5.PROJECT DESCRIPTION

The central idea of the web site is to allow the customer to shop effectively
using the Internet and allow consumers to buy the items and articles of their
yearning from the store. The information refers to the products are supplies on
an RDBMS at the server side (store). The Server process the consumers and
the items are shipped to the address submitted by them. The application was
planned into two segments first is for the customers who wish to buy the
articles. Second is for the storekeepers who maintains and updates the
statistics pertaining to the articles and those of the customers. The end user of
this product is a departmental store where the application is presented on the
web and the administrator maintains the database. The application which is
deployed at the customer database, the facts of the items are fetched forward
from the database for the customer view based on the choice through the menu
and the catalogue of all the products are updated at the end of each transaction.

5.1 Modules

User Interface

• Login Page
• My events
• Browse events
• Schedule events
• New Customer Information
• Login Page

40
 Admin Interface

• Login

• Dashboard

• Schedule events
Modules Description

Admin Interface

Login Page

•The admin application as login authentication for adding the Bank information. The
Administrator logs in using the admin login. In this administrator has the full
authority over the software. In this System, the administrator has the power to
add or update or delete all the details.

Product Model Information

•A module product model information is literally the form for the admin to create a
new model of mobile phone. A new mobile phone model is added with the
following details of the model’s name, with the model number.

Product Features

•This module consists of the information related to the product. The admin will have
the authority to add, update or delete the product. The information related to the
name, picture, price of the mobile phone will be there in this module.

Fake Review Detection

•Classification assigns items in a collection to target categories or classes. The goal

of classification is to accurately predict the target class for each case in the data.

41
 Each data in the review file is assigned a weight and depending upon which it is
classified into respective classes - Fake and Genuine.

User Interface

User Interface

New Customer Information

The New Customer Information page is dedicated to first-time users who wish to
register. It collects essential details such as name, email, contact number, and
password, which are securely stored in the users table. Upon successful
registration, the user gains access to all event scheduling and booking
functionalities. This page ensures proper onboarding of new users.

Login Page :

This second instance refers to login access for returning users who already have
an account. It includes form validation and error messages for incorrect
credentials. Users are redirected to their dashboard upon successful
authentication.

My Events

The My Events section allows users to view all events they have scheduled or
booked. Each record includes event name, type, date, location, services chosen,
and budget details. Users can also view ticket details, booking status, and modify
or cancel upcoming events if necessary. This feature enhances personalization
and convenience by keeping users informed about their event activities.

42
3. Browse Events

In the Browse Events page, users can explore available event types and services
offered by the system. Categories such as Weddings, Birthdays, Engagements,
and Corporate Meetings are displayed with detailed descriptions. Users can filter
and select preferred event types or services before scheduling. This module helps
customers understand service options and choose the best package for their
requirements.

4. Schedule Event

The Schedule Events page allows users to create and book new events. Users
provide details like event type, date, venue, number of attendees, services
required (Catering, Photography, Venue, etc.), and a short description. Once
submitted, the event is stored in the scheduled_events table and linked to the
user’s profile. The system automatically generates a unique schedule ID for each
event.

Admin Interface

Login

The Admin Login page is used by authorized administrators to securely access

the management panel. The system validates the username and password against
records in the admins table. Only verified admins can proceed to the dashboard
to perform management operations. This ensures data protection and restricted
access to sensitive system features.

43
Dashboard

The Admin Dashboard provides a centralized overview of system activities. It

displays statistics such as the total number of users, events scheduled, and tickets
booked. Admins can view recent event submissions, monitor ongoing events,
and quickly navigate to management sections. The dashboard serves as the main
control center for all administrative tasks.

Schedule Events

The Admin Schedule Events page enables administrators to create, approve, or

modify event schedules. Admins can assign event categories, verify event
details, and oversee booking confirmations. They can also update event statuses
or budgets as needed. This ensures that all scheduled events follow platform
standards and are properly managed.

44
 6.CHAPTER
SYSTEM TESTING

6.SYSTEM TESTING

System Testing is the process of executing software in a controlled manner.

Software testing is often used in association with the terms verification and
validation. Validation is the checking or testing of items, includes software, for
conformance and consistency with an associated specification. Software testing is
just one kind of verification, which also uses techniques such as reviews, analysis,
inspections, and walkthroughs. Validation is the process of checking that what has
been specified is what the user actually wanted.

Software testing should not be confused with debugging. Debugging is the

process of analysing and localizing bugs when software does not behave as
expected.

Although the identification of some bugs will be obvious from playing with
the software, a methodical approach to software testing is a much more thorough
means for identifying bugs. Debugging is therefore an activity which supports
testing, but cannot replace testing. Other activities which are often associated with
software testing are static analysis and dynamic analysis. Static analysis
investigates the source code of software, looking for problems and gathering
metrics without actually executing the code. Dynamic analysis

Looks at the behaviour of software while it is executing, to provide

information such as execution traces, timing profiles, and test coverage
information.

Testing is a set of activity that can be planned in advanced and conducted

systematically. Testing begins at the module level and work towards the integration

45
of entire computers based system. Nothing is complete without testing, as it vital
success of the system testing objectives, there are several rules that can serve as
testing objectives. They are:

Testing is a process of executing a program with the intend of finding an

error. A good test case is one that has high possibility of finding an undiscovered
error. A successful test is one that uncovers an undiscovered error.

If a testing is conducted successfully according to the objectives as stated

above, it would uncovered errors in the software also testing demonstrate that the
software function appear to be working according to the specification, that
performance requirement appear to have been met.

• For correctness
• For implementation efficiency
• For computational complexity

Test for correctness are supposed to verify that a program does exactly what it
was designed to do. This is much more difficult than it may at first appear,
especially for large programs.

UNIT TESTING

Unit testing focuses verification effort on the smallest unit of software

design – the software component or module. Using the component level
design description as a guide, important control paths are tested to uncover
errors within the boundary of the module. The relative complexity of tests and
uncovered scope established for unit testing. The unit testing is white-box
oriented, and step can be conducted in parallel for multiple components. The
modular interface is tested to ensure that information properly flows into and
out of the program unit under test. The local data structure is examined to
ensure that data stored temporarily maintains its integrity during all steps in an

46
 algorithm’s execution. Boundary conditions are tested to ensure that all
statements in a module have been executed at least once. Finally, all error
handling paths are tested.

Tests of data flow across a module interface are required before any other test
is initiated.

If data do not enter and exit properly, all other tests are moot. Selective
testing of execution paths is an essential task during the unit test. Good design
dictates that error conditions be anticipated and error handling paths set up to
reroute or cleanly terminate processing when an error does occur. Boundary
testing is the last task of unit testing step. Software often fails at its
boundaries.

Unit testing was done in Sell-Soft System by treating each module as

separate entity and testing each one of them with a wide spectrum of test
inputs. Some flaws in the internal logic of the modules were found and were
rectified.

INTEGRATION TESTING

Integration testing is systematic technique for constructing the program

structure while at the same time conducting tests to uncover errors associated
with interfacing. The objective is to take unit tested components and build a
program structure that has been dictated by design. The entire program is
tested as whole. Correction is difficult because isolation of causes is
complicated by vast expanse of entire program. Once these errors are
corrected, new ones appear and the process continues in a seemingly endless
loop.

47
 After unit testing in Sell-Soft System all the modules were integrated to test
for any inconsistencies in the interfaces. Moreover differences in program
structures were removed and a unique program structure was evolved.

VALIDATION TESTING

This is the final step in testing. In this the entire system was tested as a whole
with all forms, code, modules and class modules. This form of testing is
popularly known as Black Box testing or System testing.

Black Box testing method focuses on the functional requirements of the

software. That is, Black Box testing enables the software engineer to derive
sets of input conditions that will fully exercise all functional requirements for
a program.

Black Box testing attempts to find errors in the following categories; incorrect
or missing functions, interface errors, errors in data structures or external data
access, performance errors and initialization errors and termination errors.

ACCEPTANCE TESTING

Testing generally involves running a suite of tests on the completed system.

Each individual test, known as a case, exercises a particular operating
condition of the user's environment or feature of the system, and will result in
a pass or fail, or outcome. There is generally no degree of success or failure.

The test environment is usually designed to be identical, or as close as

possible, to the anticipated user's environment, including extremes of such.
These test cases must each be accompanied by test case input data or a formal
description of the operational activities (or both) to be performed intended to
thoroughly exercise the specific case and a formal description of the expected
results.

48
 7.CHAPTER
APPENDIX
7.1 SOURCE CODE
Index.html:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>Event Management - Welcome</title>
<link
href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;600;700&display=s
wap" rel="stylesheet">
<style>
*{
margin: 0;
padding: 0;
box-sizing: border-box;
font-family: 'Poppins', sans-serif;
}

body {
height: 100vh;
width: 100%;
background:
linear-gradient(rgba(15, 15, 15, 0.6), rgba(0, 0, 0, 0.6)),
url('/static/ban.jpg') no-repeat center center/cover;
display: flex;
flex-direction: column;
49
 justify-content: center;
align-items: center;
text-align: center;
color: #fff;
overflow: hidden;
animation: fadeIn 1.3s ease-in-out forwards;
}

h1 {
font-size: 3rem;
letter-spacing: 1px;
text-transform: uppercase;
margin-bottom: 1rem;
text-shadow: 0 0 10px rgba(255, 255, 255, 0.6);
animation: slideDown 1s ease-out forwards;
}

.tagline {
font-size: 1.2rem;
max-width: 700px;
color: #f1f1f1;
font-weight: 400;
margin-bottom: 2rem;
animation: fadeUp 1.5s ease-out forwards;
}

.info {
max-width: 700px;
font-size: 1rem;

50
 color: #e6e6e6;
margin-bottom: 2.5rem;
line-height: 1.6;
text-shadow: 0 0 6px rgba(255, 255, 255, 0.2);
animation: fadeUp 2s ease-out forwards;
}

.btn-container {
display: flex;
flex-wrap: wrap;
gap: 1.2rem;
justify-content: center;
animation: fadeInButtons 2.3s ease-in-out forwards;
}

a{
text-decoration: none;
}

/* Common Button Styles */

.btn {
border: none;
padding: 0.8rem 2rem;
border-radius: 40px;
font-size: 1.1rem;
font-weight: 600;
cursor: pointer;
transition: all 0.4s ease;
position: relative;

51
 overflow: hidden;
}

/* Glowing animation effect */

.btn::before {
content: "";
position: absolute;
top: 0;
left: -100%;
width: 100%;
height: 100%;
background: rgba(255,255,255,0.2);
transform: skewX(-20deg);
transition: 0.5s;
}

.btn:hover::before {
left: 100%;
}

/* User buttons */
.btn-user {
background: linear-gradient(45deg, #00c6ff, #0072ff);
color: #fff;
box-shadow: 0 0 12px rgba(0, 183, 255, 0.5);
}

.btn-user:hover {
transform: scale(1.08);

52
 box-shadow: 0 0 20px rgba(0, 204, 255, 0.8);
}

/* Admin button */
.btn-admin {
background: linear-gradient(45deg, #ff512f, #dd2476);
color: #fff;
box-shadow: 0 0 12px rgba(255, 80, 80, 0.5);
}

.btn-admin:hover {
transform: scale(1.08);
box-shadow: 0 0 20px rgba(255, 95, 109, 0.9);
}

footer {
position: absolute;
bottom: 20px;
color: #ccc;
font-size: 0.9rem;
animation: fadeIn 2.5s ease forwards;
}

/* Animations */
@keyframes fadeIn {
from { opacity: 0; }
to { opacity: 1; }
}

53
 @keyframes slideDown {
from { transform: translateY(-40px); opacity: 0; }
to { transform: translateY(0); opacity: 1; }
}

@keyframes fadeUp {
from { transform: translateY(40px); opacity: 0; }
to { transform: translateY(0); opacity: 1; }
}

@keyframes fadeInButtons {
from { opacity: 0; transform: scale(0.9); }
to { opacity: 1; transform: scale(1); }
}

/* Responsive */
@media (max-width: 768px) {
h1 { font-size: 2.2rem; }
.tagline { font-size: 1rem; padding: 0 15px; }
.btn-container { flex-direction: column; }
.btn { width: 80%; margin: 0 auto; }
}
</style>
</head>
<body>
<h1>Welcome to Event Management</h1>
<p class="tagline">Where creativity meets celebration — making every event
unforgettable.</p>

<div class="info">
54
 From corporate conferences to grand weddings and cultural fests — our event
management system brings everything under one roof.
Plan, organize, and manage events seamlessly with advanced tools and real-time
updates.
Let’s make your moments shine with perfection and style!
</div>

<div class="btn-container">
<a href="{{ url_for('signup') }}"><button class="btn btn-user">User
Signup</button></a>
<a href="{{ url_for('login') }}"><button class="btn btn-user">User
Login</button></a>
<a href="{{ url_for('admin_login') }}"><button class="btn btn-admin">Admin
Login</button></a>
</div>

<footer>© 2025 EventSphere | Crafted for Memorable Experiences</footer>

</body>
</html>

Login.html :

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>User Login</title>

55
 <link
href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;600&family=Playf
air+Display:wght@600&display=swap" rel="stylesheet">
<style>
body {
margin: 0;
height: 100vh;
display: flex;
justify-content: center;
align-items: center;
background: linear-gradient(135deg, #c9f7d0, #e3f0d9, #d0f0cf);
font-family: 'Poppins', sans-serif;
overflow: hidden;
animation: bgMove 6s ease-in-out infinite alternate;
}

@keyframes bgMove {
0% { background-position: left top; }
100% { background-position: right bottom; }
}

.login-container {
background: linear-gradient(145deg, #f0fff2, #dff7e1);
padding: 3rem 2.8rem;
border-radius: 20px;
box-shadow: 0 10px 25px rgba(76, 128, 98, 0.3), 0 0 50px rgba(180, 240, 180, 0.4);
text-align: center;
width: 360px;
animation: floaty 4s ease-in-out infinite;
}
56
@keyframes floaty {
0%, 100% { transform: translateY(0); }
50% { transform: translateY(-8px); }
}

h2 {
margin-bottom: 1.5rem;
font-family: 'Playfair Display', serif;
font-size: 1.9rem;
color: #3a6647;
letter-spacing: 1px;
}

label {
display: block;
text-align: left;
margin-bottom: 0.3rem;
font-weight: 600;
color: #507f5a;
}

input[type="email"],
input[type="password"] {
width: 80%;
padding: 0.65rem 0.8rem;
margin-bottom: 1.25rem;
border: 1.5px solid #d3e6d6;
border-radius: 10px;

57
 font-size: 1rem;
outline: none;
transition: 0.3s ease;
background: #ffffff9e;
}

input[type="email"]:focus,
input[type="password"]:focus {
border-color: #67ad7c;
box-shadow: 0 0 10px rgba(103, 173, 124, 0.5);
background: #ffffff;
}

.btn-login {
background: linear-gradient(90deg, #68b37c, #4d9664);
color: white;
border: none;
padding: 0.75rem 2rem;
border-radius: 25px;
font-size: 1.05rem;
font-weight: 600;
width: 100%;
cursor: pointer;
transition: all 0.3s ease;
box-shadow: 0 6px 15px rgba(90, 150, 100, 0.4);
}

.btn-login:hover {
background: linear-gradient(90deg, #558e69, #3f7c59);

58
 box-shadow: 0 8px 20px rgba(60, 120, 80, 0.5);
transform: translateY(-2px);
}

a.signup-link {
display: inline-block;
margin-top: 1.1rem;
color: #3f7c59;
text-decoration: none;
font-weight: 600;
transition: color 0.3s ease, transform 0.3s ease;
}

a.signup-link:hover {
color: #27563b;
transform: scale(1.05);
text-decoration: underline;
}

/* Soft glow floating dots for decoration */

.glow-dot {
position: absolute;
width: 12px;
height: 12px;
background: rgba(100, 200, 150, 0.3);
border-radius: 50%;
animation: floatDots 6s infinite ease-in-out alternate;
}

59
 .glow-dot:nth-child(1) { top: 10%; left: 20%; animation-delay: 0s; }
.glow-dot:nth-child(2) { top: 70%; left: 80%; animation-delay: 1s; }
.glow-dot:nth-child(3) { top: 50%; left: 10%; animation-delay: 2s; }
.glow-dot:nth-child(4) { top: 20%; left: 85%; animation-delay: 3s; }

@keyframes floatDots {
from { transform: translateY(0); opacity: 0.4; }
to { transform: translateY(-15px); opacity: 1; }
}
</style>
</head>
<body>
<div class="glow-dot"></div>
<div class="glow-dot"></div>
<div class="glow-dot"></div>
<div class="glow-dot"></div>

<div class="login-container">
<h2>User Login</h2>
<form method="POST">
<label for="email">Email</label>
<input type="email" id="email" name="email" required />

<label for="password">Password</label>
<input type="password" id="password" name="password" required />

<button type="submit" class="btn-login">Login</button>

<a href="{{ url_for('signup') }}" class="signup-link">Don't have an account?
Signup</a>
</form>
60
 </div>
</body>
</html>
Sign-up:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>User Signup</title>
<link
href="https://fonts.googleapis.com/css2?family=Poppins:wght@400;600&family=Playf
air+Display:wght@600&display=swap" rel="stylesheet">
<style>
body {
margin: 0;
height: 100vh;
display: flex;
justify-content: center;
align-items: center;
background: linear-gradient(135deg, #d3f2df, #f2e8d0, #d2eed4);
font-family: 'Poppins', sans-serif;
overflow: hidden;
animation: bgShift 6s ease-in-out infinite alternate;
}

@keyframes bgShift {
0% { background-position: left top; }
100% { background-position: right bottom; }
}

61
.signup-container {
background: linear-gradient(145deg, #ffffff, #e9f9ea);
padding: 3rem 2.5rem;
border-radius: 20px;
box-shadow: 0 10px 25px rgba(76, 128, 98, 0.3), 0 0 45px rgba(200, 250, 200, 0.35);
width: 370px;
animation: floaty 4s ease-in-out infinite;
position: relative;
text-align: center;

@keyframes floaty {
0%, 100% { transform: translateY(0); }
50% { transform: translateY(-8px); }
}

h2 {
font-family: 'Playfair Display', serif;
color: #3a6647;
font-size: 2rem;
margin-bottom: 1.5rem;
letter-spacing: 0.5px;
text-shadow: 0 1px 3px rgba(90, 150, 100, 0.15);
}

label {
display: block;
text-align: left;

62
 font-weight: 600;
color: #507f5a;
margin-bottom: 0.3rem;
}

input[type="text"],
input[type="email"],
input[type="password"] {
width: 80%;
padding: 0.65rem 0.8rem;
margin-bottom: 1.2rem;
border: 1.5px solid #c5dfc5;
border-radius: 10px;
font-size: 1rem;
outline: none;

background: #ffffff9e;
transition: 0.3s ease;
}

input:focus {
border-color: #68b37c;
box-shadow: 0 0 10px rgba(104, 179, 124, 0.5);
background: #fff;
}

.btn-signup {
background: linear-gradient(90deg, #68b37c, #4d9664);
color: white;

63
 border: none;
border-radius: 25px;
font-weight: 600;
font-size: 1.05rem;
padding: 0.75rem 2rem;
width: 100%;
box-shadow: 0 6px 15px rgba(90, 150, 100, 0.4);
cursor: pointer;
transition: all 0.3s ease;
}

.btn-signup:hover {
background: linear-gradient(90deg, #4e8b64, #3a724f);
box-shadow: 0 8px 20px rgba(60, 120, 80, 0.5);
transform: translateY(-2px);
}

a.login-link {
display: inline-block;
margin-top: 1.1rem;
color: #3f7c59;
text-decoration: none;
font-weight: 600;
transition: color 0.3s ease, transform 0.3s ease;
}

a.login-link:hover {
color: #27563b;
transform: scale(1.05);

64
 text-decoration: underline;
}

/* Floating glowing orbs */

.glow {
position: absolute;
width: 12px;
height: 12px;
background: rgba(100, 200, 150, 0.35);
border-radius: 50%;
animation: floatDots 6s infinite ease-in-out alternate;
}

.glow:nth-child(1) { top: 10%; left: 25%; animation-delay: 0s; }

.glow:nth-child(2) { top: 75%; left: 80%; animation-delay: 1.5s; }
.glow:nth-child(3) { top: 50%; left: 10%; animation-delay: 2.5s; }
.glow:nth-child(4) { top: 20%; left: 90%; animation-delay: 3s; }

@keyframes floatDots {
from { transform: translateY(0); opacity: 0.4; }
to { transform: translateY(-15px); opacity: 1; }
}

@media (max-width: 420px) {

.signup-container {
width: 90vw;
padding: 2rem 1.5rem;
}
}

65
 </style>
</head>
<body>
<div class="glow"></div>
<div class="glow"></div>
<div class="glow"></div>
<div class="glow"></div>

<div class="signup-container">
<h2>User Signup</h2>
<form method="POST">
<label>Name</label>
<input type="text" name="name" required>

<label>Email</label>
<input type="email" name="email" required>

<label>Password</label>
<input type="password" name="password" required>

<label>Phone</label>
<input type="text" name="phone">

<button type="submit" class="btn-signup">Signup</button>

<a href="{{ url_for('login') }}" class="login-link">Already have an account?
Login</a>
</form>
</div>
</body>
</html>
66
Schedule.html :

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Schedule Event</title>
<style>
body {
font-family: Arial, sans-serif;
background: linear-gradient(to right,rgb(247, 212, 212), #e4fde4);/* pale green
background */
padding: 20px;
}
h2 {
text-align: center;
color: #2e4d2c;
margin-bottom: 20px;
}
form {
max-width: 900px;
margin: auto;
backdrop-filter: blur(10px);
background-color: rgba(153, 187, 250, 0.295);
padding: 25px;
border-radius: 10px;
box-shadow: 0 0 12px rgba(0, 0, 0, 0.288);
display: grid;
grid-template-columns: 1fr 1fr;
67
 gap: 20px 30px;
}
label {
font-weight: bold;
margin-bottom: 5px;
display: block;
}
input, select, textarea {
width: 100%;
padding: 8px;
border-radius: 6px;
border: 1px solid #ccc;
margin-top: 5px;
transition: all 0.3s ease; /* smooth effect */
}

/* Hover effect for fields */

input:hover, select:hover, textarea:hover {
border-color:rgba(33, 33, 63, 0.767);
box-shadow: 1px 2px 2px rgba(48, 47, 45, 0.616);
transform: scale(1.02);
}

textarea {
grid-column: span 2;
resize: none;
}
.full-width {
grid-column: span 2;

68
 }
button {
grid-column: span 1;
position: relative;
left: 230px;
padding: 22px;
background:crimson;
color: #fff;
border: none;
border-radius: 6px;
cursor: pointer;
font-size: 16px;
transition: all 0.3s ease;
height: 60px;
}
button:hover {
background: cornflowerblue;
color: #000;
transform: scale(1.05);
}
h2{
margin-top: -20px;
padding: 20px;
font-size: 2.5rem;
color: rgb(195, 43, 43);
font-family: 'Gill Sans', 'Gill Sans MT', Calibri, 'Trebuchet MS', sans-serif;
}
</style>
</head>

69
<body>

<h2>Schedule Your Event</h2>

<form method="POST">
<!-- Row 1 -->
<div>
<label for="name">Name</label>
<input type="text" name="name" id="name" required>
</div>
<div>
<label for="email">Email</label>
<input type="email" name="email" id="email" required>
</div>

<!-- Row 2 -->

<div>
<label for="event_type">Event Type</label>
<select name="event_type" id="event_type" required>
<option value="Weddings">Weddings</option>
<option value="Birthday">Birthday</option>
<option value="Engagement">Engagement</option>
<option value="Wedding-Anniversary">Wedding-Anniversary</option>
<option value="Personal-Meeting">Personal-Meeting</option>
</select>
</div>
<div>
<label for="event_services">Event Services</label>
<select name="event_services" id="event_services" required>

70
 <option value="Catering">Catering</option>
<option value="Photography">Photography</option>
<option value="Venue">Venue</option>
<option value="Makeup-Styling">Makeup-Styling</option>
<option value="Decor">Decor</option>
<option value="All-End-to-End">All-End-to-End</option>
</select>
</div>

<!-- Row 3 -->

<div>
<label for="phone">Phone Number</label>
<input type="text" name="phone" id="phone" required>
</div>
<div>
<label for="event_date">Event Date</label>
<input type="date" name="event_date" id="event_date" required>
</div>

<!-- Row 4 -->

<div>
<label for="event_location">Event Location (City)</label>
<input type="text" name="event_location" id="event_location" required>
</div>
<div>
<label for="attendees">Number of Attendees</label>
<select name="attendees" id="attendees" required>
<option value="<100">&lt;100</option>
<option value=">100">&gt;100</option>

71
 <option value=">500">&gt;500</option>
<option value=">1000">&gt;1000</option>
</select>
</div>

<!-- Row 5 -->

<div class="full-width">
<label for="budget">Your Budget (₹)</label>
<input type="number" name="budget" id="budget" min="0" required>
</div>

<!-- Row 6 (optional fields) -->

<div class="full-width">
<label for="description">Event Description (Optional)</label>
<textarea name="description" id="description" rows="3" placeholder="Describe
your event..."></textarea>
</div>

<!-- Submit -->

<button type="submit">Schedule Event</button>
</form>

</body>
</html>
Myevents.html:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
72
 <meta name="viewport" content="width=device-width, initial-scale=1" />
<title>My Events</title>
<style>
@import
url('https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&display=swap');

body {
font-family: 'Roboto', Arial, sans-serif;
background:
url('/static/eve.jpg') no-repeat center center fixed;
background-size: cover;
margin: 0;
padding: 30px 20px;
color: #f6f8f9;

/* overlay to soften background */

body::before {
content: "";
position: fixed;
top: 0; left: 0; right: 0; bottom: 0;
background: rgba(153, 155, 156, 0.169);
z-index: -1;
}

a.btn {
display: inline-block;
margin-bottom: 30px;
padding: 10px 22px;
73
 background: #34495e;
color: #ecf0f1;
border-radius: 6px;
font-weight: 600;
text-decoration: none;
box-shadow: 0 4px 12px rgba(52, 73, 94, 0.2);
transition: background-color 0.3s ease, transform 0.2s ease;
}

a.btn:hover {
background: #1abc9c;
color: white;
transform: scale(1.05);
box-shadow: 0 6px 18px rgba(26, 188, 156, 0.5);
}

h2 {
text-align: center;
font-size: 2.8rem;
margin-bottom: 40px;
font-weight: 700;
letter-spacing: 1px;
text-transform: uppercase;
color: #eceff3;
font-family:'Times New Roman', Times, serif;
text-shadow: 0 1px 2px rgb(46, 43, 43);
}

.events-grid {

74
 display: grid;
grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
gap: 24px;
}

.event-card {
background: rgba(255, 255, 255, 0.9);
border-radius: 10px;
box-shadow: 0 6px 18px rgba(0,0,0,0.08);
padding: 24px 28px;
display: flex;
flex-direction: column;
transition: box-shadow 0.3s ease, transform 0.3s ease;
animation: fadeInUp 0.8s ease forwards;
opacity: 0;
transform: translateY(20px);
}

.event-card:hover {
box-shadow: 0 12px 36px rgba(26, 188, 156, 0.25);
transform: translateY(-6px);
}

@keyframes fadeInUp {
to {
opacity: 1;
transform: translateY(0);
}
}

75
.event-row {
display: flex;
justify-content: space-between;
padding: 8px 0;
flex-wrap: wrap;
}

.label {
font-weight: 600;
color: #7f8c8d;
font-size: 0.85rem;
text-transform: uppercase;
flex-basis: 40%;
max-width: 40%;
}

.value {
flex-basis: 60%;
max-width: 60%;
font-weight: 500;
color: #2c3e50;
font-size: 1.1rem;
white-space: nowrap;
overflow: hidden;
text-overflow: ellipsis;
}

.status {

76
 font-weight: 700;
padding: 6px 14px;
border-radius: 20px;
width: fit-content;
font-size: 0.95rem;
text-align: center;
}

.status.Pending {
background-color: #fcefe6;
color: #d35400;
}

.status.Confirmed {
background-color: #dff0d8;
color: #27ae60;
}

.status.Finished {
background-color: #dce4ec;
color: #7f8c8d;
}

@media (max-width: 480px) {

.label, .value {
flex-basis: 100%;
max-width: 100%;
white-space: normal;
}

77
 .event-row {
padding: 12px 0;
}
}
</style>
</head>
<body>

<a href="{{ url_for('home') }}" class="btn">← Back to Home</a>

<h2>My Scheduled Events</h2>

{% if events %}
<div class="events-grid">
{% for e in events %}
<div class="event-card" style="animation-delay: {{ loop.index0 * 0.1 }}s;">
<div class="event-row">
<div class="label">Name</div>
<div class="value" title="{{ e.name }}">{{ e.name }}</div>
</div>
<div class="event-row">
<div class="label">Type</div>
<div class="value">{{ e.event_type }}</div>
</div>
<div class="event-row">
<div class="label">Services</div>
<div class="value" title="{{ e.event_services }}">{{ e.event_services }}</div>
</div>
<div class="event-row">

78
 <div class="label">Date</div>
<div class="value">{{ e.event_date }}</div>
</div>
<div class="event-row">
<div class="label">Location</div>
<div class="value" title="{{ e.event_location }}">{{ e.event_location }}</div>
</div>
<div class="event-row">
<div class="label">Attendees</div>
<div class="value">{{ e.attendees }}</div>
</div>
<div class="event-row">
<div class="label">Budget</div>
<div class="value">₹{{ e.budget }}</div>
</div>
<div class="event-row">
<div class="label">Status</div>
<div>
<span class="status {{ e.status if 'status' in e else 'Pending' }}">{{ e.status if
'status' in e else 'Pending' }}</span>
</div>
</div>
</div>
{% endfor %}
</div>
{% else %}
<p style="text-align:center; font-size:1.2rem; color:#7f8c8d;">You have not
scheduled any events yet.</p>
{% endif %}

79
</body>
</html>
Home.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Event Management - Home</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link
href="https://fonts.googleapis.com/css2?family=Roboto:ital,wght@0,100..900;1,100..90
0&display=swap" rel="stylesheet">
<link rel="stylesheet" href="{{ url_for('static', filename='home.css') }}">
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-
awesome/6.4.0/css/all.min.css">
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link
href="https://fonts.googleapis.com/css2?family=DM+Serif+Text:ital@0;1&family=Rob
oto:ital,wght@0,100..900;1,100..900&display=swap" rel="stylesheet">
</head>
<body>
<!-- Navbar -->
<nav class="navbar">
<div class="logo">EventPlanner</div>
<ul class="nav-links">
<li><a href="{{ url_for('home') }}">Home</a></li>
<li><a href="{{ url_for('my_events_page') }}">My Events</a></li>
<li><a href="{{ url_for('tickets') }}">Tickets</a></li>
80
 <li><a href="{{ url_for('accounts') }}">Accounts</a></li>
<li><a href="#services">Services</a></li>
<li><a href="#about">About Us</a></li>
</ul>
</nav>

<!-- Hero Banner -->

<section class="hero">
<img src="{{ url_for('static', filename='cover.jpg') }}" alt="Event Banner">
<div class="hero-text">
<h1>Welcome to Event Planner</h1>
<p>Your trusted partner in creating unforgettable moments.</p>
</div>
</section>

<!-- About Section -->

<section class="about">
<h2>About Our Event Management</h2>
<p>
We specialize in planning and managing events that leave lasting impressions.
From weddings and birthdays to corporate meetings and entertainment nights,
our dedicated team ensures every detail is taken care of. With years of
experience in photography, venue décor, and entertainment, we make your
special moments extraordinary.
</p>
<a href="{{ url_for('schedule_event') }}" class="btn">Schedule an Event</a>
</section>

<!-- Blog Section -->

81
<section class="blog">
<h2>Our Event Stories</h2>
<div class="blog-cards">
<div class="card">
<img src="{{ url_for('static', filename='wedding.jpg') }}" alt="Wedding Event">
<h3>Wedding Celebrations</h3>
<p>Elegant wedding planning with décor, catering, and entertainment.</p>
</div>
<div class="card">
<img src="{{ url_for('static', filename='birthday.jpg') }}" alt="Birthday Event">
<h3>Birthday Parties</h3>
<p>Fun-filled birthday parties with unique themes and decorations.</p>
</div>
<div class="card">
<img src="{{ url_for('static', filename='food.jpg') }}" alt="Entertainment">
<h3>Catering</h3>
<p>Taste the wonderful world class foods.Enjoy your ever meal</p>
</div>
<div class="card">
<img src="{{ url_for('static', filename='photography.jpg') }}" alt="Photography">
<h3>Photography</h3>
<p>Capture your best memories with our professional photography team.</p>
</div>
<div class="card">
<img src="{{ url_for('static', filename='decor.jpg') }}" alt="Venue Decor">
<h3>Venue Decoration</h3>
<p>Beautiful decoration services that transform any venue.</p>
</div>
<div class="card">

82
 <img src="{{ url_for('static', filename='entertainment.jpg') }}"
alt="Entertainment">
<h3>Entertainment</h3>
<p>Music, dance, and fun-filled entertainment for your events.</p>
</div>
</div>
</section>

<!-- Services Section -->

<section id="services" style="padding:50px 20px; background:#fff;">
<h2 style="text-align:center; color:#6f2e5d; margin-bottom:30px;">Our Event
Services</h2>

<p>
At <strong> Event Management</strong>, we specialize in making your events
unforgettable.
Whether it’s a grand wedding, an intimate birthday celebration,
<br> or a corporate meeting,
our dedicated team handles every detail with precision and creativity.
Our services include: event planning, venue selection, catering, photography,
decoration,
makeup and styling, live entertainment, and end-to-end management. We tailor each
event
to your style, budget, and preferences.
We offer flexible packages for all kinds of events: weddings, engagements,
anniversaries,
birthday parties, personal gatherings, and corporate functions. No detail is too small,
no event is too big.
</p>

<p>
83
 Our photography and videography teams capture every precious moment with artistic
excellence.
Our decorators transform venues into
<br>stunning spaces that reflect your unique style.
Catering services include gourmet menus customized to your taste.

We also provide entertainment services including live bands, DJs, and performers.
Our coordinators ensure that timelines are met,
<br> and every element comes together
seamlessly for a memorable experience.
</p>

<p>
We pride ourselves on professionalism, reliability, and creativity.
From concept to completion, we deliver excellence.
<br> Our goal is to make your event stress-free
and joyful, leaving you to enjoy the celebration with your loved ones.
</p>

<p>
Contact us today to discuss your dream event.
Let our experts guide you through planning, execution, and post-event services.
Your satisfaction is our priority.
</p>

<p style="text-align:center; margin-top:20px;">

<a href="{{ url_for('gallery') }}" class="btn" style="padding:20px 30px;
background:#6f2e5d; color:#fff; border-radius:5px; text-decoration:none; ">Event
Gallery</a>
</p>

84
</section>

<!-- Footer -->

<footer id="about">
<div class="footer-content">
<div class="footer-about">
<h3>About Us</h3>
<p>
EventPlanner is dedicated to organizing events that bring happiness
and unforgettable experiences. From personal milestones to professional
gatherings, we handle it all with creativity and precision.
</p>
</div>
<div class="footer-social">
<h3>Follow Us</h3>
<a href="#"><i class="fab fa-facebook"></i></a>
<a href="#"><i class="fab fa-instagram"></i></a>
<a href="#"><i class="fab fa-twitter"></i></a>
<a href="#"><i class="fab fa-linkedin"></i></a>
</div>
<div class="footer-contact">
<h3>Contact</h3>
<p>Email: [email protected]</p>
<p>Phone: +91 98765 43210</p>
</div>
</div>
<div class="footer-bottom">
<p>&copy; 2025 EventPlanner. All rights reserved.</p>
</div>

85
 </footer>
</body>
</html>

Gallery.thml:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Event Gallery</title>
<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-
awesome/6.4.0/css/all.min.css">

<style>
body {
font-family: Arial, sans-serif;
background: linear-gradient(to right, #f7d4d4, #e4fde4);
margin: 0;
padding: 0;
}

h2 {
text-align: center;
color: #2e4d2c;
margin: 40px 0 20px 0;
font-size: 36px;
}
86
.gallery-container {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(250px, 1fr));
gap: 20px;
max-width: 1200px;
margin: auto;
padding: 20px;
}

.gallery-item {
position: relative;
overflow: hidden;
border-radius: 12px;
cursor: pointer;
transition: transform 0.3s ease, box-shadow 0.3s ease;
}

.gallery-item img {
width: 100%;
height: 100%;
object-fit: cover;
display: block;
transition: transform 0.4s ease;
}

.gallery-item:hover img {
transform: scale(1.1);
}

87
.overlay {
position: absolute;
top: 0;
left: 0;
right: 0;
bottom: 0;
background: rgba(0,0,0,0.4);
color: #fff;
opacity: 0;
display: flex;
align-items: center;
justify-content: center;
font-size: 18px;
font-weight: bold;
transition: opacity 0.3s ease;
text-align: center;
padding: 10px;
}

.gallery-item:hover .overlay {
opacity: 1;
}

/* Responsive adjustments */
@media (max-width: 600px) {
h2 {
font-size: 28px;
}

88
 }
</style>
</head>
<body>

<h2>Our Highlight Events</h2>

<div class="gallery-container">
<!-- Gallery Item 1 -->
<div class="gallery-item">
<img src="{{ url_for('static', filename='wed.jpeg') }}" alt="Event 1">
<div class="overlay">Wedding Celebration</div>
</div>

<!-- Gallery Item 2 -->

<div class="gallery-item">
<img src="{{ url_for('static', filename='day.jpg') }}" alt="Event 2">
<div class="overlay">Birthday Bash</div>
</div>

<!-- Gallery Item 3 -->

<div class="gallery-item">
<img src="{{ url_for('static', filename='enage.jpg') }}" alt="Event 3">
<div class="overlay">Engagement Party</div>
</div>

<!-- Gallery Item 4 -->

<div class="gallery-item">
<img src="{{ url_for('static', filename='ani.jpg') }}" alt="Event 4">

89
 <div class="overlay">Wedding Anniversary</div>
</div>

<!-- Gallery Item 5 -->

<div class="gallery-item">
<img src="{{ url_for('static', filename='off.jpg') }}" alt="Event 5">
<div class="overlay">Corporate Event</div>
</div>

<!-- Gallery Item 6 -->

<div class="gallery-item">
<img src="{{ url_for('static', filename='fas.jpg') }}" alt="Event 6">
<div class="overlay">Fashion Show</div>
</div>

<!-- Gallery Item 7 -->

<div class="gallery-item">
<img src="{{ url_for('static', filename='music.jpeg') }}" alt="Event 7">
<div class="overlay">Music Concert</div>
</div>

<!-- Gallery Item 8 -->

<div class="gallery-item">
<img src="{{ url_for('static', filename='awar.png') }}" alt="Event 8">
<div class="overlay">Award Ceremony</div>
</div>

<!-- Gallery Item 9 -->

<div class="gallery-item">

90
 <img src="{{ url_for('static', filename='com.jpg') }}" alt="Event 9">
<div class="overlay">Community Gathering</div>
</div>

<!-- Gallery Item 10 -->

<div class="gallery-item">
<img src="{{ url_for('static', filename='car.jpg') }}" alt="Event 10">
<div class="overlay">Charity Event</div>
</div>

<!-- Gallery Item 11 -->

<div class="gallery-item">
<img src="{{ url_for('static', filename='per.jpg') }}" alt="Event 11">
<div class="overlay">Personal Party</div>
</div>

<!-- Gallery Item 12 -->

<div class="gallery-item">
<img src="{{ url_for('static', filename='sep.jpg') }}" alt="Event 12">
<div class="overlay">Special Celebration</div>
</div>
</div>

</body>
</html>

91
buy tickets.html:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Buy Tickets</title>
<style>
@import
url('https://fonts.googleapis.com/css2?family=Montserrat:wght@400;600&display=swa
p');

body {
font-family: 'Montserrat', Arial, sans-serif;
background: #eaf4f4;
padding: 30px 20px;
color: #3a5a40;
display: flex;
flex-direction: column;
align-items: center;
min-height: 100vh;
margin: 0;
}

h2 {
font-family:Arial, Helvetica, sans-serif;
text-transform: capitalize;
color: #3b3737;
font-size: 3rem;

92
 margin-bottom: 40px;
}

form {
background: #ffffff;
padding: 30px 40px;
border-radius: 15px;
box-shadow: 0 8px 30px rgba(73, 121, 107, 0.15);
display: flex;
flex-direction: column;
align-items: center;
width: 320px;
}

label {
font-weight: 600;
font-size: 1.2rem;
margin-bottom: 20px;
color: #49796b;
letter-spacing: 0.05em;
align-self: flex-start;
}

.ticket-counter {
display: flex;
align-items: center;
gap: 15px;
margin-bottom: 30px;
width: 100%;

93
 justify-content: center;
}

input[type="number"] {
font-size: 1.6rem;
font-weight: 700;
color: #355e44;
width: 90px;
padding: 8px 14px;
border-radius: 12px;
border: 2px solid #a8d5ba;
text-align: center;
outline-offset: 2px;
transition: border-color 0.3s ease;
}

input[type="number"]:focus {
border-color: #49796b;
background-color: #d9f0e1;
}

.counter-btn {
background: #a8d5ba;
border: none;
border-radius: 50%;
width: 50px;
height: 50px;
cursor: pointer;
display: flex;

94
 justify-content: center;
align-items: center;
box-shadow: 0 4px 10px rgba(72, 121, 107, 0.3);
transition: background-color 0.3s ease, transform 0.15s ease;
user-select: none;
flex-shrink: 0;
}

.counter-btn:hover {
background: #87c38f;
transform: scale(1.1);
}

.counter-btn:active {
transform: scale(0.95);
box-shadow: 0 2px 6px rgba(72, 121, 107, 0.5);
}

.counter-btn svg {
fill: #355e44;
width: 24px;
height: 24px;
}

.btn {
background: #49796b;
color: #fff;
border: none;
padding: 14px 32px;

95
 border-radius: 30px;
font-weight: 700;
font-size: 1.1rem;
cursor: pointer;
box-shadow: 0 6px 18px rgba(73, 121, 107, 0.4);
transition: background-color 0.3s ease, transform 0.2s ease;
width: 100%;
}

.btn:hover {
background: #84a7db;
color: #2d2c6e;
transform: scale(1.05);
box-shadow: 0 8px 25px rgba(168, 213, 186, 0.7);
}
</style>
</head>
<body>

<h2>Buy Tickets</h2>

<form method="POST" onsubmit="return validateTickets()">

<label for="number_of_tickets">Number of Tickets:</label>

<div class="ticket-counter">
<button type="button" class="counter-btn" id="decrease-btn" aria-label="Decrease
Tickets">
<svg viewBox="0 0 24 24"><path d="M19 13H5v-2h14v2z"/></svg>
</button>

96
 <input type="number" id="number_of_tickets" name="number_of_tickets"
value="1" min="1" required aria-describedby="ticketCountDesc" />

<button type="button" class="counter-btn" id="increase-btn" aria-label="Increase

Tickets">
<svg viewBox="0 0 24 24"><path d="M19 13h-6v6h-2v-6H5v-
2h6V5h2v6h6v2z"/></svg>
</button>
</div>

<button type="submit" class="btn">Buy Now</button>

</form>

<script>
const decreaseBtn = document.getElementById('decrease-btn');
const increaseBtn = document.getElementById('increase-btn');
const ticketInput = document.getElementById('number_of_tickets');

decreaseBtn.addEventListener('click', () => {
let count = parseInt(ticketInput.value, 10);
if (isNaN(count) || count <= 1) {
ticketInput.value = 1;
return;
}
ticketInput.value = count - 1;
animateButton(decreaseBtn);
});

increaseBtn.addEventListener('click', () => {
let count = parseInt(ticketInput.value, 10);

97
 if (isNaN(count)) {
ticketInput.value = 1;
return;
}
ticketInput.value = count + 1;
animateButton(increaseBtn);
});

ticketInput.addEventListener('input', () => {
let val = ticketInput.value;
if (val === '' || val <= 0) {
ticketInput.setCustomValidity('Please enter a ticket quantity of at least 1.');
} else {
ticketInput.setCustomValidity('');
}
});

function animateButton(button) {
button.style.transform = 'scale(0.9)';
setTimeout(() => {
button.style.transform = 'scale(1)';
}, 150);
}

function validateTickets() {
const val = ticketInput.value;
if (val === '' || val < 1) {
alert('Please enter at least 1 ticket.');
return false;

98
 }
return true;
}
</script>

</body>
</html>

Admin_login:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>Admin Login</title>
<link rel="stylesheet"
href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" />
<style>
body {
background: linear-gradient(45deg, #3a6186, #89253e);
height: 100vh;
display: flex;
align-items: center;
justify-content: center;
font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
}
.login-container {
background: #fff;
padding: 40px 30px;
border-radius: 12px;
box-shadow: 0 8px 24px rgba(0, 0, 0, 0.15);
99
 width: 100%;
max-width: 400px;
text-align: center;
animation: fadeIn 1s ease forwards;
}
h2 {
margin-bottom: 30px;
font-weight: 700;
color: #343a40;
}
.btn-danger {
background: #89253e;
border: none;
transition: background 0.3s ease;
width: 100%;
font-weight: 600;
}
.btn-danger:hover {
background: #b63c58;
}
label {
font-weight: 600;
color: #444;
}
/* Smooth fade in animation */
@keyframes fadeIn {
from {opacity: 0; transform: translateY(20px);}
to {opacity: 1; transform: translateY(0);}
}

100
 </style>
</head>
<body>
<div class="login-container">
<h2>Admin Login</h2>
<form method="POST">
<div class="mb-3 text-start">
<label for="username" class="form-label">Username</label>
<input id="username" type="text" name="username" class="form-control" required
autofocus />
</div>
<div class="mb-4 text-start">
<label for="password" class="form-label">Password</label>
<input id="password" type="password" name="password" class="form-control"
required />
</div>
<button type="submit" class="btn btn-danger">Login</button>
</form>
</div>
</body>
</html>

Admin_dashboard.html:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<title>Admin Login</title>
<link rel="stylesheet"
href="https://cdn.jsdelivr.net/npm/[email protected]/dist/css/bootstrap.min.css" />

101
<style>
body {
font-family: 'Roboto', Arial, sans-serif;
background:linear-gradient(to right,wheat,crimson);
margin: 0;
padding: 30px 20px;
color: #2c3e50;
}

h2 {
font-weight: 700;
font-size: 2.4rem;
margin: 0;
color: #34495e;
text-transform: capitalize;
}

.header-bar {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 25px;
}

.btn {
background: #34495e;
color: #ecf0f1;
border: none;
padding: 10px 22px;

102
 border-radius: 6px;
font-weight: 600;
text-decoration: none;
box-shadow: 0 4px 12px rgba(52, 73, 94, 0.2);
transition: background-color 0.3s ease, transform 0.2s ease;
cursor: pointer;
}

.btn:hover {
background: #13894eb7;
color: white;
transform: scale(1.05);
box-shadow: 0 6px 18px rgba(24, 25, 25, 0.5);
}

.events-grid {
display: grid;
grid-template-columns: repeat(auto-fill, minmax(380px, 1fr));
gap: 24px;
}

.event-card {
background: #fff;
border-radius: 10px;
padding: 25px 28px;
box-shadow: 0 6px 18px rgba(0,0,0,0.08);
display: flex;
flex-direction: column;
animation: fadeInUp 0.8s ease forwards;

103
 opacity: 0;
transform: translateY(20px);
}

.event-card:hover {
box-shadow: 0 12px 36px rgba(31, 34, 32, 0.493);
transform: translateY(-6px);
transition: 0.5s;
}

@keyframes fadeInUp {
to {
opacity: 1;
transform: translateY(0);
}
}

.field-row {
display: flex;
justify-content: space-between;
align-items: center;
margin-bottom: 14px;
}

.field-label {
font-weight: 600;
color: #7f8c8d;
width: 40%;
}

104
.field-value {
font-weight: 500;
color: #2c3e50;
width: 58%;
overflow-wrap: break-word;
}

form {
display: flex;
flex-wrap: wrap;
gap: 10px;
justify-content: flex-start;
align-items: center;
margin-top: 10px;
}

form select, form input[type="number"] {

padding: 6px 10px;
font-size: 1rem;
border-radius: 6px;
border: 1.5px solid #bdc3c7;
width: 45%;
min-width: 120px;
transition: border-color 0.3s ease;
}

form select:focus, form input[type="number"]:focus {

border-color: #1abc9c;

105
 outline: none;
}

form button {
flex-grow: 1;
background-color: #34495e;
color: white;
border: none;
padding: 8px 14px;
border-radius: 6px;
font-weight: 600;
cursor: pointer;
transition: background-color 0.3s ease, transform 0.2s ease;
min-width: 100px;
}

form button:hover {
background-color: #1abc9c;
transform: scale(1.05);
}

@media (max-width: 480px) {

.field-row {
flex-direction: column;
align-items: flex-start;
gap: 6px;
}

.field-label,

106
 .field-value {
width: 100%;
}

form {
flex-direction: column;
gap: 12px;
align-items: stretch;
}

form select, form input[type="number"], form button {

width: 100%;
min-width: unset;
}
}
</style>

<body>
<div class="header-bar">
<h2>Admin Dashboard - Scheduled Events</h2>
<a href="{{ url_for('index') }}" class="btn">Back to Home</a>
</div>

{% if events %}
<div class="events-grid">
{% for e in events %}
<div class="event-card" style="animation-delay: {{ loop.index0 * 0.1 }}s;">
<div class="field-row">
<div class="field-label">User Name:</div>

107
 <div class="field-value">{{ e.name }}</div>
</div>
<div class="field-row">
<div class="field-label">Event Name:</div>
<div class="field-value">{{ e.event_type }}</div>
</div>
<div class="field-row">
<div class="field-label">Date:</div>
<div class="field-value">{{ e.event_date }}</div>
</div>
<div class="field-row">
<div class="field-label">Location:</div>
<div class="field-value">{{ e.event_location }}</div>
</div>
<div class="field-row">
<div class="field-label">Attendees:</div>
<div class="field-value">{{ e.attendees }}</div>
</div>
<div class="field-row">
<div class="field-label">Status:</div>
<div class="field-value">{{ e.status }}</div>
</div>
<div class="field-row">
<div class="field-label">Budget (₹):</div>
<div class="field-value">{{ e.budget }}</div>
</div>
<form method="POST">
<input type="hidden" name="schedule_id" value="{{ e.schedule_id }}">
<select name="status">

108
 <option value="Pending" {% if e.status=='Pending' %}selected{% endif
%}>Pending</option>
<option value="Confirmed" {% if e.status=='Confirmed' %}selected{% endif
%}>Confirmed</option>
<option value="Finished" {% if e.status=='Finished' %}selected{% endif
%}>Finished</option>
</select>
<input type="number" name="budget" value="{{ e.budget }}" placeholder="Set
budget" min="0" />
<button type="submit" class="btn">Update</button>
</form>
</div>
{% endfor %}
</div>
{% else %}
<p style="text-align:center;">No events scheduled yet.</p>
{% endif %}
</body>

</html>

Accounts.html:

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>My Account</title>
<style>

109
 @import
url('https://fonts.googleapis.com/css2?family=Great+Vibes&family=Open+Sans&displa
y=swap');

body {
font-family: 'Open Sans', Arial, sans-serif;
background: linear-gradient(135deg, #fcd7e6, #aaf4e4);
padding: 30px;
margin: 0;
animation: fadeInBg 1.5s ease forwards;
}

@keyframes fadeInBg {
from { background-position: 0 0; }
to { background-position: 100% 100%; }
}

.container {
max-width: 500px;
margin: auto;
background: #fff9fb;
padding: 30px 35px;
border-radius: 12px;
box-shadow:
0 4px 20px rgba(111, 46, 93, 0.15),
0 0 40px rgba(78, 76, 68, 0.2);
animation: fadeInUp 1s ease forwards;
opacity: 0;
transform: translateY(20px);
}
110
@keyframes fadeInUp {
to {
opacity: 1;
transform: translateY(0);
}
}

h2 {
font-family: 'Great Vibes', cursive;
font-size: 3rem;
text-align: center;
color: #6f2e5d;
margin-bottom: 35px;
letter-spacing: 1.2px;
opacity: 0;
animation: fadeInText 1.5s ease 0.5s forwards;
}

@keyframes fadeInText {
to {
opacity: 1;
}
}

.detail {
margin-bottom: 20px;
animation: fadeInText 1.3s ease forwards;
opacity: 0;

111
 animation-delay: 0.7s;
}

.detail:nth-child(2) {
animation-delay: 0.9s;
}
.detail:nth-child(3) {
animation-delay: 1.1s;
}

.detail label {
font-weight: 700;
display: block;
color: #90509f;
margin-bottom: 6px;
font-size: 1.15rem;
text-transform: uppercase;
letter-spacing: 0.06em;
}

.detail p {
color: #4a2a58;
font-size: 1.1rem;
margin-top: 0;
padding-left: 10px;

.btn {

112
 display: block;
width: 100%;
padding: 14px 0;
margin-top: 30px;
background: #6f2e5d;
color: #fff;
border: none;
border-radius: 8px;
text-align: center;
text-decoration: none;
font-weight: 700;
font-size: 1.2rem;
cursor: pointer;
box-shadow: 0 4px 15px rgba(111, 46, 93, 0.4);
transition: background 0.4s ease, color 0.4s ease, transform 0.3s ease, box-shadow
0.3s ease;
will-change: transform;
}

.btn:hover,
.btn:focus {
background: #178247;
color: #ffffff;
transform: scale(1.05);
box-shadow:
0 6px 20px rgba(31, 35, 33, 0.313),
0 0 30px rgba(28, 32, 29, 0.5);
outline: none;
}
</style>
113
</head>
<body>
<center>

<div class="container">
<h2>My Account</h2>

<div class="detail">
<label>Name:</label><p>{{ user_name }}</p>

</div>

<div class="detail">
<label>Email:</label><p>{{ user_email }}</p>

</div>

<div class="detail">
<label>Phone:</label><p>{{ user_phone }}</p>

</div>

<a href="{{ url_for('logout') }}" class="btn">Logout</a>

</div>
</center>

</body>
</html>

114
Schema.sql :
create database event;
use event;

-- Users table
CREATE TABLE users (
user_id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(100) NOT NULL,
email VARCHAR(100) UNIQUE NOT NULL,
password VARCHAR(100) NOT NULL,
phone VARCHAR(15)
);
select *from users;

DELETE FROM users

WHERE user_id = 4;

-- Admins table
CREATE TABLE admins (
admin_id INT AUTO_INCREMENT PRIMARY KEY,
username VARCHAR(50) UNIQUE NOT NULL,
password VARCHAR(100) NOT NULL
);

INSERT INTO admins (username, password)

VALUES ('admin', '0000');

CREATE TABLE scheduled_events (

schedule_id INT AUTO_INCREMENT PRIMARY KEY,
115
 user_id INT NOT NULL, -- links to the user
name VARCHAR(100) NOT NULL,
email VARCHAR(100) NOT NULL,
phone VARCHAR(15) NOT NULL,
event_type ENUM('Weddings', 'Birthday', 'Engagement', 'Wedding-Anniversary',
'Personal-Meeting') NOT NULL,
event_services ENUM('Catering', 'Photography', 'Venue', 'Makeup-Styling', 'Decor',
'All-End-to-End') NOT NULL,
attendees ENUM('<100','>100','>500','>1000') NOT NULL,
event_date DATE NOT NULL,
event_location VARCHAR(150) NOT NULL,
description TEXT, -- optional
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (user_id) REFERENCES users(user_id) ON DELETE CASCADE
);
ALTER TABLE scheduled_events
ADD COLUMN budget DECIMAL(12,2) DEFAULT 0;
ALTER TABLE scheduled_events
ADD COLUMN status ENUM('Pending','Confirmed','Finished') DEFAULT 'Pending';

select*from scheduled_events;
TRUNCATE TABLE users;

CREATE TABLE tickets (

ticket_id INT AUTO_INCREMENT PRIMARY KEY,
schedule_id INT NOT NULL, -- matches scheduled_events primary key
user_id INT NOT NULL,
number_of_tickets INT NOT NULL,

116
 total_amount DECIMAL(12,2) NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
FOREIGN KEY (schedule_id) REFERENCES scheduled_events(schedule_id) ON
DELETE CASCADE,
FOREIGN KEY (user_id) REFERENCES users(user_id) ON DELETE CASCADE
);
select * from tickets;

app.py:
from flask import Flask, render_template, request, redirect, url_for, session, flash
from db_config import get_connection

app = Flask(__name__)
app.secret_key = "secret123" # required for session

# ---------------- Index Page ----------------

@app.route('/')
def index():
return render_template('index.html')

# ---------------- Signup ----------------

@app.route('/signup', methods=['GET', 'POST'])
def signup():
if request.method == 'POST':
name = request.form.get('name')
email = request.form.get('email')
password = request.form.get('password')
117
 phone = request.form.get('phone') # get phone number

conn = get_connection()
cursor = conn.cursor()
try:
# Check if email already exists
cursor.execute("SELECT * FROM users WHERE email = %s", (email,))
existing = cursor.fetchone()
if existing:
flash("Email already registered. Please log in.", "warning")
return redirect(url_for('login'))

# Insert user with phone number

cursor.execute(
"INSERT INTO users (name, email, password, phone) VALUES (%s, %s, %s,
%s)",
(name, email, password, phone)
)
conn.commit()
flash("Signup successful! Please log in.", "success")
return redirect(url_for('login'))

except Exception as e:
conn.rollback()
flash(f"Error: {str(e)}", "danger")
finally:
cursor.close()
conn.close()

return render_template('signup.html')
118
# ---------------- Login ----------------
@app.route('/login', methods=['GET', 'POST'])
def login():
if request.method == 'POST':
email = request.form.get('email')
password = request.form.get('password')

conn = get_connection()
cursor = conn.cursor(dictionary=True)
try:
cursor.execute("SELECT * FROM users WHERE email = %s AND password =
%s", (email, password))
user = cursor.fetchone()
if user:
session['user_id'] = user['user_id']
session['user_name'] = user['name']
session['user_email'] = user['email']
session['user_phone'] = user['phone'] # store phone
session['role'] = 'user'
flash("Login successful!", "success")
return redirect(url_for('home'))
else:
flash("Invalid email or password.", "danger")
except Exception as e:
flash(f"Error: {str(e)}", "danger")
finally:
cursor.close()
conn.close()

119
 return render_template('login.html')

@app.route('/home')
def home():
if 'user_id' not in session:
flash("Please login first!", "warning")
return redirect(url_for('login'))

conn = get_connection()
cursor = conn.cursor(dictionary=True)
try:
# Fetch all scheduled events (optional: only upcoming)
cursor.execute("SELECT * FROM scheduled_events WHERE event_date >=
CURDATE()")
events = cursor.fetchall()
finally:
cursor.close()
conn.close()

return render_template('home.html', events=events, user_name=session['user_name'])

# Logout
@app.route('/logout')
def logout():
session.clear()
flash("Logged out successfully!", "success")
return redirect(url_for('index'))

# ---------------- My Events ----------------

120
# ---------------- Accounts ----------------
@app.route('/accounts')
def accounts():
if 'user_id' not in session:
flash("Please login first!", "warning")
return redirect(url_for('login'))

return render_template(
'accounts.html',
user_name=session.get('user_name'),
user_email=session.get('user_email'),
user_phone=session.get('user_phone')
)

# ---------------- Gallery ----------------

# Route for Gallery Page

@app.route('/gallery')
def gallery():
return render_template('gallery.html')

# ---------------- Schedule Event (button link) ----------------

@app.route('/schedule_event', methods=['GET', 'POST'])
def schedule_event():
if 'user_id' not in session:
flash("Please login first!", "warning")
return redirect(url_for('login'))
121
 if request.method == 'POST':
# Get form data
name = request.form.get('name')
email = request.form.get('email')
phone = request.form.get('phone')
event_type = request.form.get('event_type')
event_services = request.form.get('event_services')
attendees = request.form.get('attendees')
event_date = request.form.get('event_date')
event_location = request.form.get('event_location')
description = request.form.get('description', '')

# --- Fetch budget properly ---

budget = request.form.get('budget', '0')
try:
budget = float(budget)
except ValueError:
budget = 0.0

conn = get_connection()
cursor = conn.cursor()
try:
cursor.execute("""
INSERT INTO scheduled_events
(user_id, name, email, phone, event_type, event_services, attendees,
event_date, event_location, description, budget)
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)
""", (

122
 session['user_id'], name, email, phone, event_type, event_services, attendees,
event_date, event_location, description, budget
))
conn.commit()
flash("Your event has been scheduled successfully! Waiting for admin
approval.", "success")
return redirect(url_for('home'))

except Exception as e:
conn.rollback()
flash(f"Error: {str(e)}", "danger")
finally:
cursor.close()
conn.close()

return render_template('schedule_event.html')

@app.route('/my_events')
def my_events_page(): # unique function name
if 'user_id' not in session:
flash("Please login first!", "warning")
return redirect(url_for('login'))

conn = get_connection()
cursor = conn.cursor(dictionary=True)
try:
# Fetch all scheduled events for the logged-in user
cursor.execute("""

123
 SELECT * FROM scheduled_events
WHERE user_id = %s
ORDER BY event_date ASC
""", (session['user_id'],))
events = cursor.fetchall()
finally:
cursor.close()
conn.close()

return render_template('my_events.html', events=events,

user_name=session['user_name'])

@app.route('/tickets')
def tickets():
if 'user_id' not in session:
flash("Please login first!", "warning")
return redirect(url_for('login'))

conn = get_connection()
cursor = conn.cursor(dictionary=True)
try:
# Fetch events with ticket info
cursor.execute("""
SELECT s.schedule_id, s.name, s.event_date, s.event_location, s.status,
s.budget,
IFNULL(SUM(t.number_of_tickets),0) AS tickets_purchased,
IFNULL(SUM(t.total_amount),0) AS amount_spent
FROM scheduled_events s
LEFT JOIN tickets t ON s.schedule_id = t.schedule_id AND t.user_id = %s
WHERE s.user_id = %s
124
 GROUP BY s.schedule_id
ORDER BY s.event_date ASC
""", (session['user_id'], session['user_id']))
events = cursor.fetchall()
finally:
cursor.close()
conn.close()

return render_template('tickets.html', events=events,

user_name=session['user_name'])

@app.route('/buy_ticket/<int:schedule_id>', methods=['GET','POST'])
def buy_ticket(schedule_id):
if 'user_id' not in session:
flash("Please login first!", "warning")
return redirect(url_for('login'))

conn = get_connection()
cursor = conn.cursor(dictionary=True)

try:
# Get event info
cursor.execute("SELECT * FROM scheduled_events WHERE schedule_id=%s",
(schedule_id,))
event = cursor.fetchone()
if not event:
flash("Event not found.", "danger")
return redirect(url_for('tickets'))

# Prevent buying if event is finished

125
 if event['status'] == 'Finished':
flash("Event is finished. Tickets cannot be purchased.", "warning")
return redirect(url_for('tickets'))

if request.method == 'POST':
number_of_tickets = int(request.form.get('number_of_tickets'))
total_amount = number_of_tickets * 1000 # Example ticket price, change as
needed

cursor.execute("""
INSERT INTO tickets (user_id, schedule_id, number_of_tickets,
total_amount)
VALUES (%s, %s, %s, %s)
""", (session['user_id'], schedule_id, number_of_tickets, total_amount))
conn.commit()
flash(f"{number_of_tickets} tickets purchased successfully!", "success")
return redirect(url_for('tickets'))

finally:
cursor.close()
conn.close()

return render_template('buy_ticket.html', event=event)

@app.route('/admin_login', methods=['GET', 'POST'])

def admin_login():
if request.method == 'POST':
username = request.form.get('username')
password = request.form.get('password')

126
 conn = get_connection()
cursor = conn.cursor(dictionary=True)
try:
cursor.execute(
"SELECT * FROM admins WHERE username=%s AND password=%s",
(username, password)
)
admin = cursor.fetchone()
if admin:
session['admin_id'] = admin['admin_id']
session['role'] = 'admin'
flash("Admin login successful!", "success")
return redirect(url_for('admin_dashboard'))
else:
flash("Invalid admin username or password", "danger")
finally:
cursor.close()
conn.close()

return render_template('admin_login.html')

@app.route('/admin_dashboard', methods=['GET', 'POST'])

def admin_dashboard():
if 'role' not in session or session['role'] != 'admin':
flash("Admin access only!", "danger")
return redirect(url_for('admin_login'))

conn = get_connection()

127
 cursor = conn.cursor(dictionary=True)

if request.method == 'POST':
schedule_id = request.form.get('schedule_id')
new_status = request.form.get('status')
new_budget = request.form.get('budget')

try:
cursor.execute("""
UPDATE scheduled_events
SET status=%s, budget=%s
WHERE schedule_id=%s
""", (new_status, new_budget, schedule_id))
conn.commit()
flash("Event updated successfully!", "success")
except Exception as e:
conn.rollback()
flash(f"Error updating event: {str(e)}", "danger")
try:
cursor.execute("SELECT * FROM scheduled_events ORDER BY event_date
ASC")
events = cursor.fetchall()
finally:
cursor.close()
conn.close()

return render_template('admin_dashboard.html', events=events)

if __name__ == "__main__":
app.run(debug=True)
128
 8.CHAPTER

IMPLEMENTATION

8.SYSTEM IMPLEMENTATION

Implementation is that stage of the project when the theoretical design is turned
into a working system. After testing the modules successfully, the necessary privileges
are given to the users. All the users are requested to handle the system carefully. The real
time problems that occur are successfully solved. The objective is to put the tested
system into operation. It consists of
• Testing the developed program with sample data.
• Detection and corrections of errors.
• Making necessary changes in the system.
• Checking of reports.
• Creating computer compatible files.
• Installation of hardware and software utilities.
There are four basic methods for implementation:
1. Install a system in a operation or organization one just being formed.
2. Cut off the old system and install the new. This is practical only for small
organization or small systems where installation requires one or more day.
3. Cut over by the segments. This is also referred as phasing in the new system.
Small part or sub systems are after the other in a phased manner.
Operate in parallel and cutover. The new system installed and operated in parallel with
current system until it has been checked out. Then the current system is cut off. These
methods are extensive because of personal and relate costs.

129
8.1 SAMPLE SCREEN LAYOUT

Fig 8.1.1 Login

130
Fig 8.1.2 Admin dashboard

Fig 8.1.3 Schedule event

131
Figure 8.1.4 my events

Fig 8.1.5 Dashboard

132
 CHAPTER 9

CONCLUSION

9.CONCLUSION

This project designed to provide a web based application that would

make searching, viewing and selection of a product easier. The search
engine provides an easy and convenient way to search for products. User
can Search for a product interactively and the search engine would refine
the products available based on the user’s input. The user can then view
the complete specification of each product. They can also view the
product reviews and also write their own reviews. By enabling product
capabilities at each stage of the store- shopping journey, retailers can
influence sales revenue and potentially improve conversion rates.
Retailers can also significantly influence the customer experience
including what factors influence the customers’ buying decisions.

133
 CHAPTER 10
FUTURE ENHANCEMENT

6.FUTURE ENHANCEMENT

The users could subscribe for price alerts which would enable them
to receive messages when price for products fall below a particular level.
System may keep track of history of purchases of each customer and
provide suggestions based on their history.
The following things can be done in future.
• The current system can be extended to allow the users to create
accounts and save products in to wish list.
• The users could subscribe for price alerts which would enable them to
receive messages when price for products fall below a particular level.
• The current system is confined only to the shopping cart process. It
can be extended to have an easy to use check out process.

134
 CHAPTER 11

BIBLIOGRAPHY

11.1BIBLIOGRAPHY
Books

• Jason Butler and Tony Caudil,”ASP.NET Database Programming”

Fifth Edition, Hungry minds,Inc.Publishing Company Limited,New
Delhi, 2000
• Glen Johnsonwiley, Learning ASP.NET, Fourth Edition, Hungry
minds, Inc.Publishing Company Limited,,Uttar Pradesh,2001.
• Jason Butler and Tony Caudill ,ASP.NET Database Programming,
Second Edition, Hungry minds, Inc. Publishing Company
Limited.,2000.
• K.M. Hussain and Donna Hussain, Information Systems: Analysis,
Design and Implementation, Second Edition, Tata McGraw-Hill,
Delhi, 1995.
• Edward Yourdon, Managing the Systems Life Cycle, Second Edition.
Englewood Cliffs, N.J.: Prentice-Hall, US 1988.
• Edward Yourdon and Larry L. Constantine, Structured Design:
Fundamentals and Applications in Software Engineering , Second
Edition, Englewood Cliffs, N.J.: Yourdon Press, US,1989.
• Shaku Atre, Data Base: Structured Techniques for Design,
Performance, and management, Third Edition,. New York: Wiley,
1980.
• Online References
• www.visual.com
• www.dotnetspider.com

135