Design a Real-Time Parking Space Reservation System with OOD Principles

Designing a Real-Time Parking Space Reservation System using Object-Oriented Design (OOD) principles requires breaking down the problem into manageable components that can interact seamlessly. Here, we will define classes, relationships, and behaviors to ensure efficient parking space management.

1. Identify Key Entities and Classes

To start, we need to identify the main objects (classes) involved in the system. For a real-time parking space reservation system, the essential entities are:

• ParkingLot: Represents a parking area that can have multiple parking spaces.

• ParkingSpace: A single parking space within a parking lot.

• User: The person who reserves or cancels a parking space.

• Reservation: Represents a reservation made by a user for a parking space.

• Payment: Handles payment transactions for reserved parking spots.

• ParkingLotManager: Manages and tracks the availability of parking spaces in different parking lots.

• Notification: Sends updates or reminders to the user regarding their reservation.

2. Define the Class Structure

2.1 User Class

python
CopyEdit
class User:
    def __init__(self, user_id, name, email, phone):
        self.user_id = user_id
        self.name = name
        self.email = email
        self.phone = phone
        self.reservations = []  # List of reservations made by the user

    def make_reservation(self, parking_space, reservation_time):
        # Create a new reservation for the parking space
        reservation = Reservation(self, parking_space, reservation_time)
        self.reservations.append(reservation)
        parking_space.reserve(parking_space)
        return reservation

    def cancel_reservation(self, reservation):
        # Cancel a reservation
        if reservation in self.reservations:
            reservation.cancel()
            self.reservations.remove(reservation)
            reservation.parking_space.release()

2.2 ParkingLot Class

python
CopyEdit
class ParkingLot:
    def __init__(self, lot_id, location, capacity):
        self.lot_id = lot_id
        self.location = location
        self.capacity = capacity
        self.parking_spaces = [ParkingSpace(i) for i in range(capacity)]  # List of parking spaces

    def available_spaces(self):
        return [space for space in self.parking_spaces if space.is_available()]

    def get_space(self):
        for space in self.parking_spaces:
            if space.is_available():
                return space
        return None

2.3 ParkingSpace Class

python
CopyEdit
class ParkingSpace:
    def __init__(self, space_id):
        self.space_id = space_id
        self.available = True  # Initially available
        self.reservation = None

    def is_available(self):
        return self.available

    def reserve(self, user):
        if self.is_available():
            self.available = False
            self.reservation = user
            return True
        return False

    def release(self):
        self.available = True
        self.reservation = None

2.4 Reservation Class

python
CopyEdit
class Reservation:
    def __init__(self, user, parking_space, reservation_time):
        self.user = user
        self.parking_space = parking_space
        self.reservation_time = reservation_time
        self.status = "Reserved"  # Can be "Reserved" or "Cancelled"
    
    def cancel(self):
        self.status = "Cancelled"

2.5 Payment Class

python
CopyEdit
class Payment:
    def __init__(self, user, amount, payment_method):
        self.user = user
        self.amount = amount
        self.payment_method = payment_method
        self.status = "Pending"  # Can be "Pending", "Completed", "Failed"
    
    def process_payment(self):
        # Simulate a payment gateway
        # On success:
        self.status = "Completed"
        return True
        # On failure:
        # self.status = "Failed"
        # return False

2.6 ParkingLotManager Class

python
CopyEdit
class ParkingLotManager:
    def __init__(self):
        self.parking_lots = []

    def add_parking_lot(self, parking_lot):
        self.parking_lots.append(parking_lot)

    def find_available_space(self):
        for lot in self.parking_lots:
            available_spaces = lot.available_spaces()
            if available_spaces:
                return available_spaces[0]  # Return first available space
        return None

2.7 Notification Class

python
CopyEdit
class Notification:
    def __init__(self, user, message):
        self.user = user
        self.message = message

    def send(self):
        print(f"Sending notification to {self.user.name}: {self.message}")

3. Define Relationships and Interactions

• User can reserve a ParkingSpace through a Reservation.

• ParkingLotManager tracks all ParkingLot instances, and ParkingLot contains multiple ParkingSpace instances.

• Payment is associated with Reservation to handle financial transactions.

• Notification is used to alert the User about their reservation status.

4. Workflow and Behavior

1. A User wants to reserve a parking space.

2. The User interacts with the ParkingLotManager, which finds an available ParkingSpace in one of the ParkingLots.

3. The User makes a Payment for the reservation, which is processed and completed.

4. If the payment is successful, a Reservation is made, and the ParkingSpace is marked as Reserved.

5. A Notification is sent to the User confirming the reservation.

6. When the user is done, they can cancel the reservation, which releases the parking space and updates the reservation status.

5. Sample Usage

python
CopyEdit
# Create parking lot manager and parking lots
manager = ParkingLotManager()
lot1 = ParkingLot(1, "Downtown", 10)
manager.add_parking_lot(lot1)

# Create a user and reserve a space
user = User(101, "Alice", "alice@example.com", "1234567890")
parking_space = manager.find_available_space()

if parking_space:
    reservation = user.make_reservation(parking_space, "2023-07-18 10:00 AM")
    print(f"Reservation made for {user.name} at space {reservation.parking_space.space_id}")

    # Process payment
    payment = Payment(user, 20, "Credit Card")
    if payment.process_payment():
        print(f"Payment successful! Reservation confirmed for {user.name}")
    
    # Send notification
    notification = Notification(user, "Your parking reservation is confirmed!")
    notification.send()
else:
    print("No available spaces.")

6. Conclusion

This object-oriented design approach leverages the principles of encapsulation, inheritance (if necessary), and polymorphism (for notification systems or payment gateways). By decomposing the system into small, manageable classes, the parking reservation process becomes scalable, easy to maintain, and adaptable to changes in the future.