LAB ASSIGNMENT -11

Project Group Members:

1. ANAHAT DESHMUKH Roll No-23512

2. ARYA BHONGALE Roll No-23509

3. NIRANJAN PATIL Roll No-23573

4. ADITYA WAYKOLE Roll No-23562

Project Title: Event Management System

Abstract:
The Event Management System (EMS) is a C++ application designed to illustrate the use of data
structures in managing events. It employs parallel arrays to efficiently store event-related data,
including names, dates, locations, ticket prices, available seats, and total tickets sold,
supporting up to 100 events for organized storage and quick retrieval. The system facilitates
operations such as adding events, processing ticket purchases, and calculating revenue,
showcasing how data structures enhance performance and data integrity. Basic control
structures, including loops and conditionals, further improve functionality. Enhanced with ANSI
escape codes for a visually appealing interface, the EMS serves as an educational tool to
demonstrate key data structure concepts while providing a comprehensive solution for event
management.

Software Requirement Specification (SRS):

1. Introduction

1.1 Purpose

The purpose of this document is to outline the software requirements for the Event
Management System (EMS), a C++ application designed to facilitate the management of events,
including the addition of events, ticket purchasing, and revenue analysis.

1.2 Scope

The EMS will enable users to manage events effectively by providing features such as event
registration, ticket sales, revenue calculations, and data export. It will support up to 100 events
and will be utilized by event organizers and attendees.
1.3 Definitions, Acronyms, and Abbreviations

- EMS: Event Management System

- ICS: iCalendar file format

- CSV: Comma-Separated Values

2. Overall Description

2.1 Product Perspective

The EMS is a standalone application built in C++. It leverages data structures like parallel arrays
to store event information efficiently.

2.2 Product Functions

- Add new events with details (name, date, location, price, available seats).

- Display a list of existing events with formatted information.

- Purchase tickets for specified events, updating seat availability.

- Generate ICS files for calendar integration upon ticket purchase.

- Calculate and display total revenue generated per event.

- Export event analytics to a CSV file.

2.3 User Classes and Characteristics

- Event Organizers: Users who can add and manage events, view revenue, and export analytics.

- Attendees: Users who can view events and purchase tickets.

2.4 Operating Environment

- The EMS will run on any system with a C++ compiler and basic command-line interface
capabilities. It will utilize standard libraries for file handling and input/output operations.

3. Functional Requirements

3.1 Event Management

- Add Event

- Input: Event name, date, location, ticket price, available seats.

 - Output: Confirmation of event addition.

-Display Events

- Input: None.

- Output: Formatted list of all events with details.

3.2 Ticket Purchasing

- Purchase Tickets

- Input: Event name, number of tickets.

- Output: Confirmation of ticket purchase and updated available seats.

3.3 Revenue Management

- Calculate Revenue

- Input: None.

- Output: Total revenue generated per event.

3.4 Data Export

- Generate ICS File

- Input: Event details upon ticket purchase.

- Output: ICS file created for calendar integration.

- Export to CSV

- Input: None.

- Output: CSV file containing event analytics.

4. Non-Functional Requirements

4.1 Performance

- The system should handle up to 100 events without noticeable delays in operations.

4.2 Usability
- The interface should be user-friendly, with clear prompts and color-coded feedback for
actions.

4.3 Reliability

- The system should ensure data integrity and avoid data loss during file operations.

4.4 Maintainability

- The code should be well-commented and structured to facilitate future enhancements.

5. External Interface Requirements

5.1 User Interfaces

- Command-line interface with clear prompts for user interaction.

5.2 Hardware Interfaces

- No specific hardware requirements; any system with C++ compiler capabilities will suffice.

5.3 Software Interfaces

- Standard libraries for input/output and file handling in C++.

6. System Requirements

6.1 Software Requirements

- C++ compiler (e.g., GCC, Clang).

- Text editor or IDE for code development.

6.2 Hardware Requirements

- Minimum hardware specifications include a standard computer capable of running a C++

development environment.

7. Assumptions and Dependencies

- Users are assumed to have basic knowledge of using command-line applications.

- The system depends on standard libraries for functionality.

8. Future Enhancements

- Integration with a database for persistent storage of event data.

Design:

1. System Architecture

The EMS features a modular architecture comprising:

 Event Management Module: Manages event addition and display.

 Ticket Management Module: Handles ticket purchases and seat updates.
 Revenue Management Module: Calculates and displays event revenue.
 Data Export Module: Generates ICS and CSV files for analytics.

2. User Interface Design

The command-line interface features color-coded prompts. Main menu options include
1. Add Event
2. Display Events
3. Purchase Tickets
4. Generate CSV File
5. Exit

3. Interaction Flow

 Add Event: User inputs details, and the system confirms addition.
 Display Events: Shows formatted list or a message if none exist.
 Purchase Tickets: Validates availability and confirms purchase, generating an ICS file.
 Generate CSV: Creates and confirms CSV file of event analytics.

Workflow:

Main Menu

 Options: Add Event, Display Events, Purchase Tickets, Generate CSV File, Exit.

Add Event

 User inputs event details (name, date, location, price, seats).

Display Events

 User selects to view events.

Purchase Tickets
  User inputs event name and number of tickets.

Generate CSV File

 User requests CSV export.

Exit

 User selects exit; system displays total revenue and closes.

IMPLEMENTATION:

The EMS is designed to streamline the planning and management of events, allowing users to
add events, manage ticket sales, and analyze revenue efficiently.

Key Concepts

- Data Structures: The system uses parallel arrays to store event data (names, dates, locations,
ticket prices, available seats, and total tickets sold), enabling efficient access and manipulation.
- Event Management: Users can add events with validation for inputs.

- Ticket Purchasing: Attendees can purchase tickets with real-time seat updates.

- Revenue Tracking: The system calculates total revenue generated for each event.

- Data Export: Generates ICS files for calendar integration and CSV files for analytics.

User Interaction

The EMS features a command-line interface (CLI) with a clear menu system and color-coded
feedback to enhance user experience.

Error Handling

Basic validation ensures correct inputs and manages issues like exceeding event capacity or
insufficient seat availability during ticket purchases.

Educational Value

The EMS serves as an educational tool, illustrating programming concepts, data structures, and
file handling techniques, while also providing potential for future enhancements like database
integration and a graphical user interface.
TESTING:

1. Test Objectives

 Validate the functionality of the EMS.

 Ensure data integrity and correct processing of events and ticket sales.
 Verify error handling mechanisms.

2. Test Cases

 Test Case 1: Add Event

o Input: Valid event details (name, date, location, price, seats).
o Expected Result: Event is added successfully, and a confirmation message is
displayed.
 Test Case 2: Add Event (Exceed Limit)
o Input: Add more than 100 events.
o Expected Result: Error message indicating the event limit is reached.
 Test Case 3: Display Events
o Input: No events added.
o Expected Result: Message indicating no events to display.

 Test Case 4: Purchase Tickets (Valid Purchase)

o Input: Event name and a valid number of tickets within available seats.
o Expected Result: Tickets are purchased, seat availability is updated, and an ICS
file is generated.
 Test Case 5: Purchase Tickets (Insufficient Seats)
o Input: Request tickets greater than available seats.
o Expected Result: Error message indicating not enough available seats.
 Test Case 6: Purchase Tickets (Invalid Event)
o Input: Non-existent event name.
o Expected Result: Error message indicating event not found.

 Test Case 7: Display Revenue

o Input: After multiple ticket purchases.
o Expected Result: Correct total revenue displayed for each event.

 Test Case 8: Generate CSV File

o Input: Request to generate the CSV file after adding events.
o Expected Result: CSV file created successfully with correct data.
 Test Case 9: Generate ICS File
o Input: Purchase tickets for an event.
o Expected Result: ICS file is generated for the event.

3. Performance Testing
  Test the system's performance when adding the maximum number of events.
 Measure response time for purchasing tickets during peak loads.

4. User Acceptance Testing

 Engage end-users to validate usability and functionality against requirements.

5. Error Handling Testing

 Intentionally input invalid data (e.g., negative ticket count) and ensure appropriate error
messages are displayed.

CONCLUSION:

The Event Management System (EMS) effectively demonstrates key programming concepts by
managing event data through parallel arrays. Its user-friendly command-line interface facilitates
tasks like event creation and ticket sales, ensuring data integrity with robust error handling.
Overall, the EMS serves as a practical educational tool, highlighting real-world applications of
software development principles.