Design a Campus Event Promotion App with Object-Oriented Design

Designing a Campus Event Promotion App with Object-Oriented Design (OOD) principles involves focusing on the key components that would facilitate event discovery, promotion, and participation among students, faculty, and staff on campus. The app will have a central role in ensuring seamless event management, attendance tracking, and engagement.

Here’s how the design can be approached with Object-Oriented Design concepts:

1. System Requirements

The Campus Event Promotion App must support the following functionalities:

• Event creation and promotion

• Event discovery and RSVP management

• User registration and profile management

• Event feedback and ratings

• Notifications for upcoming events

• Categorization of events (e.g., academic, recreational, social)

• Search and filter capabilities

2. Key Entities and Classes

The core entities that the system will use include:

1. User
   The User class will represent a student, faculty member, or staff with the ability to register, log in, and interact with the app. Different user types (students, event organizers, faculty) might have different roles.

   • Attributes:

     • user_id: Unique identifier

     • name: Name of the user

     • email: User email address

     • role: Role of the user (student, staff, admin)

     • events_attended: List of events the user has attended or RSVP’d to

     • events_created: List of events created by the user

   • Methods:

     • register(): Register a new user.

     • login(): Log in a user.

     • createEvent(): Allow users with appropriate roles to create events.

     • RSVP(event_id): RSVP to an event.

     • viewEvents(): View events a user has RSVP’d to.

2. Event
   The Event class will represent an event happening on campus. This includes both the details of the event and its participation metrics.

   • Attributes:

     • event_id: Unique event identifier

     • title: Event title

     • description: Event description

     • event_date: Date and time of the event

     • location: Event location

     • category: Event category (academic, recreational, etc.)

     • organizer: Reference to the user who created the event

     • attendees: List of users who RSVP’d

     • max_attendees: Maximum number of attendees allowed

   • Methods:

     • create(): Create a new event.

     • update(): Update event details.

     • delete(): Delete an event.

     • addAttendee(user_id): Add an attendee to the event.

     • removeAttendee(user_id): Remove an attendee from the event.

     • getEventDetails(): Fetch event details.

     • notifyAttendees(): Notify attendees about the event.

3. Notification
   The Notification class will handle event reminders and alerts, including RSVP confirmations and reminders.

   • Attributes:

     • notification_id: Unique identifier for the notification

     • message: Notification message

     • user_id: User receiving the notification

     • event_id: Associated event (if any)

     • notification_date: Date and time of notification

   • Methods:

     • sendNotification(): Send a notification to a user.

     • viewNotifications(): Allow users to view their notifications.

4. Category
   The Category class will represent event categories for filtering and sorting events.

   • Attributes:

     • category_id: Unique identifier for the category

     • name: Name of the category (academic, recreational, etc.)

     • description: Description of the category

   • Methods:

     • createCategory(): Create a new event category.

     • getCategoryEvents(): Fetch events under a specific category.

5. Feedback
   The Feedback class allows users to provide feedback and ratings for events they attended.

   • Attributes:

     • feedback_id: Unique identifier for feedback

     • event_id: Associated event

     • user_id: User providing feedback

     • rating: Rating of the event (1-5 stars)

     • comment: Written feedback

   • Methods:

     • submitFeedback(): Submit feedback for an event.

     • viewFeedback(): View feedback for a specific event.

     • getEventRating(): Get the average rating for an event.

3. Relationships Between Classes

• User and Event: A user can create many events (1-to-many relationship), RSVP to many events (many-to-many relationship with the Event class), and provide feedback on events they attended.

• Event and Category: An event belongs to one category, but each category can have many events (many-to-one relationship).

• Event and Feedback: Each event can have many feedback submissions (1-to-many relationship), but each feedback belongs to one event.

4. Use Cases

• User Registration: A user creates an account by providing personal details such as name, email, and role (e.g., student, staff).

• Event Creation: An authorized user (like an event organizer) can create an event by filling in details such as title, date, and location.

• RSVP to Event: Users can RSVP to an event by selecting it from the list of available events and confirming their attendance.

• Event Notification: The system will send reminders and notifications to attendees before the event starts.

• Feedback Submission: After attending an event, users can submit feedback by rating and commenting on the event.

• Event Discovery: Users can browse or search for events based on categories (e.g., academic, recreational), dates, or locations.

5. Sample Code (in Python-like Syntax)

python
CopyEdit
class User:
    def __init__(self, user_id, name, email, role):
        self.user_id = user_id
        self.name = name
        self.email = email
        self.role = role
        self.events_attended = []
        self.events_created = []

    def create_event(self, event_details):
        if self.role == 'organizer':
            event = Event(event_details)
            self.events_created.append(event)
            return event
        else:
            raise PermissionError("Only organizers can create events.")

    def RSVP(self, event):
        if len(event.attendees) < event.max_attendees:
            event.add_attendee(self)
            self.events_attended.append(event)
        else:
            raise Exception("Event is full.")

class Event:
    def __init__(self, title, description, date, location, organizer, category, max_attendees=100):
        self.event_id = generate_event_id()  # This could be a UUID or database auto-increment ID
        self.title = title
        self.description = description
        self.event_date = date
        self.location = location
        self.organizer = organizer
        self.category = category
        self.max_attendees = max_attendees
        self.attendees = []

    def add_attendee(self, user):
        if len(self.attendees) < self.max_attendees:
            self.attendees.append(user)
        else:
            raise Exception("Event is at maximum capacity.")

    def notify_attendees(self):
        for attendee in self.attendees:
            notification = Notification(f"Reminder: {self.title} is happening soon!", attendee.user_id, self.event_id)
            notification.send_notification()

class Notification:
    def __init__(self, message, user_id, event_id):
        self.notification_id = generate_notification_id()  # This could be a UUID or database auto-increment ID
        self.message = message
        self.user_id = user_id
        self.event_id = event_id
        self.notification_date = datetime.now()

    def send_notification(self):
        # Simulate sending a notification
        print(f"Notification sent to user {self.user_id}: {self.message}")

class Feedback:
    def __init__(self, event, user, rating, comment):
        self.feedback_id = generate_feedback_id()
        self.event = event
        self.user = user
        self.rating = rating
        self.comment = comment

    def submit_feedback(self):
        # Store feedback in database or system
        print(f"Feedback for {self.event.title} submitted by {self.user.name}: {self.rating} stars")

# Example of creating an event
user1 = User(user_id=1, name="John Doe", email="johndoe@example.com", role="organizer")
event1 = user1.create_event({
    'title': 'Campus Tech Talk',
    'description': 'A session about the latest trends in technology.',
    'date': '2025-09-01',
    'location': 'Campus Auditorium',
    'category': 'academic'
})
user2 = User(user_id=2, name="Jane Smith", email="janesmith@example.com", role="student")
user2.RSVP(event1)

6. Potential Extensions

• Admin Dashboard: Admin users can manage and monitor events, users, and notifications.

• Advanced Search: Allow users to search events based on keywords, dates, or categories.

• Event Check-In: Implement a check-in system using QR codes or location-based check-ins for event attendance.

This app design leverages OOD principles by focusing on clear entity relationships, encapsulation, and reusability, which makes the app scalable and maintainable.