A MICRO PROJECT REPORT

ON
“create event registration system to register and view events”
SUBMITTED IN PARTIAL FULFILLMENT OF THE REQUIREMENTS FOR
THE AWARD OF
DIPLOMA IN
ARTIFICIAL INTELLIGENCE AND MACHINE LEARNING

SUBMITTED TO
MAHARASTRA STATE BOARD OF TECHNICAL EDUCATION
SUBMITTED BY
Sr.no. Name of student Enrollment
. No.
1 Ashalesh Shalendra Ambade 23112490041

2 Kaustubh Tanaji Mhatre 23112490035

3 Mayuresh Aashok Palker 23112490007

4 Omkar Namdev 23112490055

Kondibane

UNDER THE GUIDANCE OF

MS.HEENA PATIL
 MAHARASTRA STATE BOARD OF TECHNICAL EDUCATION

CERTIFICATE

This is to certify that Mr. /Mrs. Ashalesh Shalendra Ambade, Kaustubh Tanaji Mhatre,
Mayuresh Aashok Palker, Omkar Namdev Kondibane.Roll No……. of Third Semester
Diploma in Alamuri Ratnamala Institute of Engineering and Technology has completed the
Micro Project in subject DATA STRUCTURE IN USING PYTHON(313306) in the
academic year 2024-25 as per the MSBTE prescribed curriculum of ‘K’ Scheme

Place: Shahapur Enrollment No: 23112490041, 23112490035,

23112490007, 23112490055
Date:………………... Exam Seat No:……………………………….

Subject Teacher Head of the Department Principal

 ACKNOWLEDGEMENT
A micro project is something that could not have been materialized without cooperation of
many people. This project shall be incomplete if do not convey my heartfelt gratitude to
those people from whom I have got considerable support and encouragement.

It is a matter of great pleasure for us to have respected Prof. Heena Patil as my project
guide. We are thankful to her for being constant source of inspiration.

We would also like to give our sincere thanks to Prof. Heena Patil Head of
Department, for their kind support.
 CONTENTS
CH.
TOPIC NAME PAGENO.
NO
1 Project Title 1
2 Certificate 2

3 Acknowledgement 3

4 Project Overview
5 Technology Used
6 Features
7 Flowchart
8 Implementation
9 Output
10 ADAVANTAGES AND DISADVANTAGES
11 Future Enhancement
12 Conclusion and References
 Project overview
Below is the Project Overview of an Event Registration System implemented in Python. The system
allows users to register for events, view events, and allows admins to manage events. We'll use
Python's SQLite library for the database and Flask for creating a web interface.
Event Registration System in Python: Project Overview
Below is the Project Overview of an Event Registration System implemented in Python. The system
allows users to register for events, view events, and allows admins to manage events. We'll use
Python's SQLite library for the database and Flask for creating a web interface.
1. Project Objective
➢ The Event Registration System is designed to provide a platform for users to:
• Register for events by signing up.
• View upcoming events and details.
• Allow Admins to manage events, approve registrations, and view user participation.
• Send notifications about event registration status, reminders, etc.
➢ Key features of the system:
• Users can register, login, and register for events.
• Admins can create, update, and delete events.
• Users and admins can view event details.
• Admins can approve or cancel user registrations for events.
• Email notifications will be sent upon registration and event reminders.
2. Functional Requirements
The system will have the following functionalities:
1. User Registration and Login:
o Users must register and login to register for events.
o User information (email, name, password) will be stored securely.
2. Event Management (Admin):
o Admins can create new events, update event details, and delete events.
o Each event has details like name, date, time, location, description, and capacity.
3. Event Registration:
o Registered users can view the list of upcoming events and register.
o Users will be able to check event details and register (first-come, first-served basis).
4. User Registration Status:
o Users can view the events they have registered for.
o Admins can manage and approve/reject user registrations.
5. Notifications:
o Users will receive notifications (via email) when they successfully register for an event
or if there are any changes.
o Admins can also send updates to participants.
 Technology Used
To create an event registration system that allows users to register for events and view available events,
we can break down the design and implementation into the following steps. The system would typically
involve a front-end interface for users to interact with, a back-end for managing data and user requests,
and a database for storing event and user information.
Key Features:
1. Event Registration: Users can register for an event.
2. Event Listing: Display available events for registration.
3. User Authentication: Users can create accounts and log in to register for events.
4. Admin Panel: For managing and creating events.
Technologies Used:
Here’s a list of potential technologies for each component of the system:
1. Front-End (User Interface)
• HTML/CSS/JavaScript: Basic structure and styling.
• React.js or Vue.js: For building an interactive and dynamic UI.
• Bootstrap or TailwindCSS: For responsive design and faster styling.
• Axios or Fetch API: For making API calls to the back-end to view events and register.
2. Back-End (Server)
• Node.js with Express.js: To handle server-side logic, API routes, and event registration
functionalities.
• Django (Python) or Flask (Python): Alternatively, Django/Flask can be used for back-end
services if Python is preferred.
3. Database
• MySQL or PostgreSQL: Relational databases to store events and user registration details.
• MongoDB: A NoSQL database, if the project requires more flexible data structures (e.g., event
categories, multi-day events).
4. User Authentication
• JWT (JSON Web Token): For securing the user sessions and authentication across requests.
• OAuth: If you want to implement third-party authentication (e.g., Google, Facebook login).
5. Hosting/Deployment
• Heroku or Vercel: For hosting and deploying the app.
• AWS (Amazon Web Services) or DigitalOcean: For more robust cloud hosting and services.
6. Version Control
• Git with GitHub: For version control and collaboration.
System Design and Flow
1. Database Schema:
• Users Table: To store user information (name, email, password).
o Columns: user_id, name, email, password_hash
• Events Table: To store event details.
o Columns: event_id, title, date, location, description, max_participants
• Registrations Table: To track user registrations for events.
o Columns: registration_id, user_id (FK), event_id (FK), registration_date
2. API Endpoints (Backend Logic)
• GET /events: Returns a list of available events.
• POST /register: Registers the user for an event.
• GET /events/{id}: Shows details for a specific event.
 • POST /login: Authenticates a user.
• POST /signup: Registers a new user.
3. Frontend UI Flow
• Homepage:
o Displays a list of available events (fetched from the /events endpoint).
o Each event has a button to register for it (only visible if the user is logged in).
• Event Detail Page:
o Displays more information about the event (date, description, location).
o Button to register for the event.
• User Authentication:
o Registration/Login form to allow users to create an account or log in.
• Registration Confirmation:
o After registration, a confirmation message appears.
 FEATURE
User-side: View available events and register for them.
Admin-side: View the list of registered users for each event.
Database: SQLite with SQLAlchemy to manage events and registrations.
Features:
• View available events.
• Register for an event (using a simple form).
• View all registered users for an event (for admin).
Next Steps for Enhancement:
• User Authentication: Add login functionality using Flask-Login for user-specific registrations.
• Event Edit/Delete: Allow event organizers to update or delete events.
• Email Notifications: Send confirmation emails upon registration.
• Better UI: Enhance UI/UX with more advanced CSS or a front-end framework like Bootstrap.
Technologies:
• Python with Flask for web server.
• SQLite for database (as it's lightweight and easy to set up).
• HTML/CSS for basic frontend views.
FLOWCHART
 Implementation
class Events:
def _init_(self):
self.events = {}

def add_event(self, event_name, event_date, event_time):

self.events[event_name] = {
'date': event_date,
'time': event_time,
'registrants': []
}
print(f"Event '{event_name}' added successfully!")

def register_event(self, event_name, registrant_name):

if event_name in self.events:
self.events[event_name]['registrants'].append(registrant_name)
print(f"Registrant '{registrant_name}' added to event '{event_name}'
successfully!")
else:
print(f"Event '{event_name}' not found!")

def view_events(self):
for event_name, event_details in self.events.items():
print(f"Event Name: {event_name}")
print(f"Date: {event_details['date']}")
print(f"Time: {event_details['time']}")
print(f"Registrants: {', '.join(event_details['registrants'])}")
print("------------------------")

def view_registrants(self, event_name):

if event_name in self.events:
print(f"Registrants for event '{event_name}':")
for registrant_name in self.events[event_name]['registrants']:
print(registrant_name)
 else:
print(f"Event '{event_name}' not found!")

#Main Function

def main():
events = Events()

while True:
print("Event Registration System")
print("1. Add Event")
print("2. Register Event")
print("3. View Events")
print("4. View Registrants")
print("5. Exit")

choice = input("Enter your choice: ")

if choice == "1":
event_name = input("Enter event name: ")
event_date = input("Enter event date: ")
event_time = input("Enter event time: ")
events.add_event(event_name, event_date, event_time)
elif choice == "2":
event_name = input("Enter event name: ")
registrant_name = input("Enter registrant name: ")
events.register_event(event_name, registrant_name)
elif choice == "3":
events.view_events()
elif choice == "4":
event_name = input("Enter event name: ")
events.view_registrants(event_name)
elif choice == "5":
break
 else:
print("Invalid choice. Please try again.")

if _name_ == "_main_":
main()
Output
 ADAVANTAGES AND DISADVANTAGES
Advantages
Simple and Easy to Implement: The Python code is simple and easy to implement for beginners.
Scalable: More features can be added in the future, such as user authentication, event capacity limits,
and more detailed user management.
Modular: The code is modular with classes for events and registration management, making it easier
to modify or extend.
Real-world Application: The project mimics real-world event management systems, making it
practical for learning.
Disadvantages:
1. No Database: This implementation uses in-memory lists to store events and user data, which
means data is lost when the program ends. A real-world application would use a database for
persistence.
2. No Input Validation: There is minimal input validation. For example, the system doesn't check
if a user is already registered for an event or if the input data is valid (like checking if email
format is correct).
3. No User Interface: The system is command-line-based. A graphical user interface (GUI) or
web-based interface would be more user-friendly.
4. Limited Features: Advanced features like event cancellation, reminder notifications, or
payment integration are not implemented here.
5. No Error Handling: The code doesn't handle edge cases well, such as incorrect event IDs or
missing user details.
 Future Enhancement
To enhance the Event Registration System, there are many areas where
additional features and improvements can be made. These enhancements can
improve the functionality, scalability, and user experience. Below are some
ideas for future enhancements:
1. Persistent Data Storage (Database Integration)
• Current Limitation: The current system uses in-memory data (lists),
which means that all information is lost once the program ends.
• Enhancement: Integrate a database such as SQLite, MySQL, or
PostgreSQL to store events and registration data persistently.
o Use SQLite for lightweight, file-based storage if you don't need
complex database features.
•
o This would allow users to register for events, and data would remain intact even after the
program is restarted.
o Example: Save events and user registrations in a table and fetch data when needed.

Graphical User Interface (GUI)

• Current Limitation: The system is currently a command-line interface (CLI) application, which
may not be user-friendly for all users.
• Enhancement: Build a Graphical User Interface (GUI) using libraries such as Tkinter or
PyQt.
o A GUI would allow users to interact with the system using buttons, forms, and other
visual elements rather than text commands.
o A GUI would also make it easier to display available events, registration status, and
registered participants.

Email Notifications

• Current Limitation: The system does not send any notifications about event registrations.
• Enhancement: Implement an email notification system to inform users about successful
registrations, upcoming events, or cancellations.
o Use Python's smtplib to send automated email notifications after a user registers.

4. User Authentication & Authorization

• Current Limitation: There's no user login system; anyone can register on any event without
any user management.
• Enhancement: Implement user authentication so users can create accounts and log in before
registering for events.
o Use libraries like Flask (for web apps) or Django (for more robust systems) with JWT
tokens or OAuth for secure authentication.
o Add different roles (admin, user) so administrators can manage events, and users can
view and register for events.
 Conclusion and References
Conclusion:
The Event Registration System can be significantly improved with these
enhancements, turning it from a basic CLI-based project into a more robust,
feature-rich system suitable for real-world applications. Integrating databases,
GUI, authentication, and payment systems will give users a more professional
and complete experience.
1. Persistent Storage: Using a database (e.g., SQLite or MySQL) would
allow data to be stored permanently and accessed across sessions.
2. Graphical User Interface (GUI): A GUI could provide a more user-
friendly experience, moving beyond the command-line interface.
3. Email Notifications: Sending confirmation and reminder emails would
enhance user interaction.
4. User Authentication and Authorization: Implementing login systems
would add security and user management capabilities.
5. Event Capacity Management: Limiting the number of participants per
event would improve event organization.
6. Payment Integration: Payment gateways would allow users to pay for
event registrations directly within the system.
7. Admin Panel: An admin interface for managing events and
registrations would give organizers more control over the system.
References:
1. Python Documentation:
• Python Official Documentation – A comprehensive source for Python
language features, libraries, and best practices.
2. SQLite Documentation:
• SQLite Official Site – Official documentation for SQLite, a lightweight
database engine useful for integrating persistence into Python
applications.
3. Tkinter Documentation:
• Tkinter Documentation – Python’s standard GUI toolkit documentation
to help with building desktop applications.
4. Flask Documentation:
• Flask Documentation – A lightweight web framework for Python that
could be used to build web-based event registration systems.
5. Stripe API Documentation:
• Stripe API – Official documentation for integrating Stripe for payment
processing.
6. Python Email Libraries:
• smtplib Documentation – Python’s standard library for sending emails
using SMTP.
7. Flask-Login Documentation:
• Flask-Login Documentation – A Flask extension for handling user
authentication and session management.