Design a Smart Fitness Equipment Reservation System with Object-Oriented Design

Smart Fitness Equipment Reservation System (OOD)

The Smart Fitness Equipment Reservation System allows gym members to efficiently book, manage, and access fitness equipment. The system is designed to handle reservations for equipment based on availability, user preferences, and scheduling. It ensures that fitness centers maximize the usage of their resources while providing convenience to gym members.

1. Identify the Key Components

The system needs to manage several key elements, such as:

• Fitness Equipment: Different types of gym equipment, such as treadmills, bikes, dumbbells, etc.

• Users (Members): Gym members who can reserve equipment.

• Reservations: Details about the booking, such as time slots and duration.

• Availability: The status of each piece of equipment (available, reserved, out-of-service).

• Notifications: Informing users about booking confirmations, cancellations, or reminders.

2. Object-Oriented Design Classes

Class 1: Equipment

This class represents each piece of fitness equipment.

python
CopyEdit
class Equipment:
    def __init__(self, equipment_id, name, type, status="available"):
        self.equipment_id = equipment_id  # Unique ID for the equipment
        self.name = name  # Name of the equipment (e.g., Treadmill)
        self.type = type  # Type of equipment (Cardio, Strength, etc.)
        self.status = status  # Status of the equipment (available, reserved, out-of-service)
    
    def reserve(self):
        if self.status == "available":
            self.status = "reserved"
            return True
        return False
    
    def release(self):
        self.status = "available"
        
    def is_available(self):
        return self.status == "available"

Class 2: User

This class represents the gym members who will use the equipment.

python
CopyEdit
class User:
    def __init__(self, user_id, name, membership_type):
        self.user_id = user_id  # Unique ID for the user
        self.name = name  # User's name
        self.membership_type = membership_type  # Membership type (e.g., Regular, Premium)
        self.reservations = []  # List to track user's reservations
    
    def reserve_equipment(self, equipment, start_time, duration):
        if equipment.reserve():
            reservation = Reservation(self, equipment, start_time, duration)
            self.reservations.append(reservation)
            return reservation
        return None

Class 3: Reservation

This class represents the actual reservation of equipment by a user.

python
CopyEdit
from datetime import datetime

class Reservation:
    def __init__(self, user, equipment, start_time, duration):
        self.reservation_id = f"{user.user_id}_{equipment.equipment_id}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
        self.user = user  # The user who made the reservation
        self.equipment = equipment  # The equipment reserved
        self.start_time = start_time  # Start time of the reservation
        self.duration = duration  # Duration of the reservation in minutes
        self.end_time = self.calculate_end_time()  # End time calculated based on duration
    
    def calculate_end_time(self):
        return self.start_time + timedelta(minutes=self.duration)
    
    def cancel(self):
        self.equipment.release()
        self.user.reservations.remove(self)

Class 4: Gym

This class handles the overall operations, such as managing equipment and reservations.

python
CopyEdit
from datetime import datetime, timedelta

class Gym:
    def __init__(self):
        self.equipment_list = []  # List of all available equipment
        self.users = []  # List of users in the gym
    
    def add_equipment(self, equipment):
        self.equipment_list.append(equipment)
    
    def register_user(self, user):
        self.users.append(user)
    
    def check_availability(self, equipment, start_time, duration):
        for reservation in self.get_reservations_by_equipment(equipment):
            if (start_time < reservation.end_time) and (start_time + timedelta(minutes=duration) > reservation.start_time):
                return False  # Equipment is not available
        return True
    
    def get_reservations_by_equipment(self, equipment):
        return [res for user in self.users for res in user.reservations if res.equipment == equipment]

Class 5: NotificationService

This class is responsible for sending notifications to users.

python
CopyEdit
class NotificationService:
    @staticmethod
    def send_notification(user, message):
        print(f"Notification to {user.name}: {message}")

3. Interactions Between Classes

1. Gym Manager/Admin adds the available equipment to the system.

2. Users register on the system, and they can view and reserve available equipment.

3. When a user reserves an equipment, the system checks the availability of that equipment at the requested time. If it’s available, the reservation is confirmed.

4. If a reservation is cancelled, the system updates the status of the equipment and removes the reservation from the user’s list.

5. Notifications are sent to users regarding the status of their reservation.

4. Scenario

1. User Registration: A user registers with the system and becomes eligible to reserve equipment.

   python
   CopyEdit
   gym = Gym()
   user1 = User(user_id="U1001", name="John Doe", membership_type="Premium")
   gym.register_user(user1)
   

2. Adding Equipment: Equipment is added to the system, which is available for reservations.

   python
   CopyEdit
   treadmill = Equipment(equipment_id="E1001", name="Treadmill", type="Cardio")
   gym.add_equipment(treadmill)
   

3. Making a Reservation: A user attempts to reserve a piece of equipment.

   python
   CopyEdit
   start_time = datetime(2025, 7, 17, 10, 0)  # July 17, 2025, 10:00 AM
   duration = 30  # 30 minutes
   if gym.check_availability(treadmill, start_time, duration):
       reservation = user1.reserve_equipment(treadmill, start_time, duration)
       NotificationService.send_notification(user1, f"Reservation successful for {treadmill.name} at {start_time}.")
   else:
       NotificationService.send_notification(user1, f"{treadmill.name} is not available at the requested time.")
   

4. Cancelling a Reservation: A user may cancel a reservation, and the equipment status will be updated.

   python
   CopyEdit
   reservation.cancel()
   NotificationService.send_notification(user1, f"Reservation for {treadmill.name} has been cancelled.")
   

5. Key Features

• Availability Check: Ensures equipment is available before a reservation.

• Reservation Management: Allows users to reserve, cancel, and modify their reservations.

• User Notifications: Alerts users about successful reservations, cancellations, and upcoming sessions.

• Equipment Status: Tracks and updates the status of each piece of equipment in real-time.

This design provides a scalable, flexible system for managing equipment reservations in a fitness center. By using object-oriented principles, the system is modular, maintainable, and easy to extend with additional features, such as handling peak times, user priority (e.g., premium members), or advanced notifications (SMS, email).