Design a Real-Time Public Event Notification System with Object-Oriented Design

Real-Time Public Event Notification System Using Object-Oriented Design (OOD)

The Real-Time Public Event Notification System (REPENS) aims to provide users with up-to-date notifications about ongoing or upcoming public events in their local area, such as concerts, festivals, sports events, and more. This system ensures that users are always informed and can make decisions based on real-time information.

To achieve this, we will design the system using Object-Oriented Design (OOD) principles, which focuses on organizing software into objects that represent real-world entities and their interactions. The core principles we will utilize include encapsulation, inheritance, and polymorphism.

1. System Overview

The Real-Time Public Event Notification System will have the following core functionalities:

• Event Creation: Organizations or event hosts can create events that will be listed for public viewing.

• User Notification: Users receive real-time notifications about events based on their preferences and location.

• Event Updates: Real-time updates are provided, such as event cancellations or location changes.

• Event Categories: Events will be categorized (e.g., music, sports, community), allowing users to filter notifications based on their interests.

2. Key Entities and Classes

User Class

This class will represent the users who interact with the system. It will store information about the user and manage their event notification preferences.

• Attributes:

  • userID: Unique identifier for the user.

  • name: Name of the user.

  • email: Email for sending notifications.

  • location: User’s current location.

  • preferences: A list of event categories the user is interested in (e.g., sports, concerts).

• Methods:

  • updatePreferences(preferences): Update user’s event category preferences.

  • sendNotification(notification): Sends event notification to the user via email or push notification.

  • getLocation(): Returns the current location of the user.

Event Class

This class represents an individual event. Each event can have different details like the name, date, location, and category.

• Attributes:

  • eventID: Unique identifier for the event.

  • name: Name of the event.

  • date: Date and time of the event.

  • location: Event’s location.

  • category: Category of the event (e.g., music, sports).

  • host: Event host or organization.

  • status: Event status (e.g., live, upcoming, canceled).

  • participants: List of users attending the event.

• Methods:

  • updateStatus(status): Updates the status of the event (e.g., live, canceled).

  • sendEventUpdate(notification): Sends a notification to all participants if the event status changes.

  • addParticipant(user): Adds a user to the list of participants.

  • removeParticipant(user): Removes a user from the list of participants.

EventManager Class

This class manages the creation, updating, and notifications of events. It acts as a controller to handle interactions between users and events.

• Attributes:

  • events: A list of all events in the system.

  • users: A list of all users in the system.

• Methods:

  • createEvent(event): Creates a new event and adds it to the system.

  • updateEvent(eventID, status): Updates the status of an existing event.

  • sendNotificationsToUsers(event): Sends notifications to users who are interested in the event or are nearby.

  • filterEventsByCategory(category): Filters and retrieves events of a specific category.

  • notifyUsers(event): Sends event notifications based on user preferences and location.

Notification Class

This class handles the creation of notifications that will be sent to users when there are updates related to events.

• Attributes:

  • notificationID: Unique identifier for the notification.

  • event: The event associated with the notification.

  • message: The content of the notification.

  • recipient: The user who will receive the notification.

• Methods:

  • sendNotification(): Sends the notification to the recipient (user) via their preferred medium (email, SMS, push).

  • updateMessage(newMessage): Updates the notification message.

3. System Design Considerations

Encapsulation

Each class encapsulates its attributes and methods. For instance, the User class manages the user’s preferences and notifications, while the Event class encapsulates event details such as location and participants.

• The event’s status (live, canceled, etc.) is controlled and updated by methods inside the Event class, making sure only authorized entities can modify it.

• Users are able to update their preferences and receive notifications, but they cannot directly alter event details.

Inheritance

We can introduce inheritance to handle various types of events with specific features. For example, we might have different types of events, like ConcertEvent, SportEvent, or FestivalEvent, all inheriting from a base class Event.

python
CopyEdit
class ConcertEvent(Event):
    def __init__(self, name, date, location, artist):
        super().__init__(name, date, location)
        self.artist = artist
        self.category = "Music"

class SportEvent(Event):
    def __init__(self, name, date, location, teams):
        super().__init__(name, date, location)
        self.teams = teams
        self.category = "Sports"

Polymorphism

Polymorphism allows us to interact with different event types (like ConcertEvent and SportEvent) uniformly. The sendEventUpdate method in the Event class could behave differently depending on the event type.

python
CopyEdit
class Event:
    def sendEventUpdate(self, notification):
        # Default behavior for event update
        pass

class ConcertEvent(Event):
    def sendEventUpdate(self, notification):
        # Specialized update for concert events
        pass

Real-Time Interaction

To ensure the system can function in real-time, it should include a notification mechanism that can trigger instantly when an event’s status changes, or when new events are created. For instance:

• If an event’s status changes from “upcoming” to “live,” all users interested in that event or nearby should immediately receive notifications.

• If a concert is canceled, all attendees should receive a cancellation notice.

4. Example Workflow

1. Event Creation: An organization creates an event (e.g., a concert). The system stores the event in the EventManager.

2. User Preferences: A user sets preferences to be notified about music events.

3. Event Notification: The system sends a notification about the concert to the user when the event status changes to live.

4. Event Update: If the concert is canceled, users who are attending the event will receive an update immediately.

5. Conclusion

By applying object-oriented design principles, we have structured the Real-Time Public Event Notification System to effectively manage and notify users about public events. Each component (User, Event, EventManager, and Notification) has its own clear responsibility, and real-time updates are handled efficiently through notifications. The system’s design also ensures that it can be easily extended to include new event types or user features in the future.