Design a Smart Shared Laundry Room Booking System with OOD Principles

Designing a Smart Shared Laundry Room Booking System using Object-Oriented Design (OOD) principles involves breaking down the system into distinct classes and objects that manage the key functionalities. The design will focus on allowing users to book machines, monitor availability, and streamline the process of managing laundry room usage.

1. System Overview

The Smart Shared Laundry Room Booking System is designed to enable tenants or users of a shared space to book laundry machines, view available slots, and receive notifications for upcoming bookings or changes. This system will offer an interface for users to manage their laundry schedules, allowing efficient use of resources (washing machines, dryers) in a shared environment.

2. Key Features

• User Authentication: Users can create accounts, log in, and manage their profiles.

• Machine Availability: View availability and real-time status of each machine.

• Booking and Scheduling: Users can reserve washing machines and dryers for specified time slots.

• Notifications: Alerts for upcoming bookings or when machines become available.

• Admin Control: Admins can manage the system, monitor machine usage, and modify bookings.

3. Main Components and Classes

3.1. User Class

This class manages individual users (tenants) of the laundry room.

python
CopyEdit
class User:
    def __init__(self, user_id, username, password, email):
        self.user_id = user_id
        self.username = username
        self.password = password
        self.email = email
        self.bookings = []  # A list of bookings made by the user
    
    def make_booking(self, machine, time_slot):
        # Create a booking for the user
        booking = Booking(self, machine, time_slot)
        self.bookings.append(booking)
        machine.add_booking(booking)
    
    def cancel_booking(self, booking):
        # Cancel a specific booking
        booking.cancel()
        self.bookings.remove(booking)

3.2. Booking Class

This class stores the booking details, including the user, machine, and time slot.

python
CopyEdit
class Booking:
    def __init__(self, user, machine, time_slot):
        self.user = user
        self.machine = machine
        self.time_slot = time_slot
        self.status = "Booked"  # Can be 'Booked', 'Completed', 'Cancelled'
    
    def cancel(self):
        self.status = "Cancelled"
        self.machine.remove_booking(self)

3.3. Machine Class

Represents each washing or drying machine in the laundry room.

python
CopyEdit
class Machine:
    def __init__(self, machine_id, machine_type):
        self.machine_id = machine_id
        self.machine_type = machine_type  # e.g., 'Washing Machine' or 'Dryer'
        self.bookings = []  # A list of bookings made for this machine
    
    def add_booking(self, booking):
        # Add a booking to this machine
        self.bookings.append(booking)
    
    def remove_booking(self, booking):
        # Remove a booking from this machine
        self.bookings.remove(booking)
    
    def is_available(self, time_slot):
        # Check if the machine is available at a specific time
        for booking in self.bookings:
            if booking.time_slot == time_slot:
                return False  # Machine is already booked for this time slot
        return True

3.4. TimeSlot Class

Defines the time slots available for booking machines.

python
CopyEdit
class TimeSlot:
    def __init__(self, start_time, end_time):
        self.start_time = start_time
        self.end_time = end_time
    
    def __eq__(self, other):
        return (self.start_time == other.start_time and self.end_time == other.end_time)

3.5. Admin Class

Admin can monitor machine usage, and approve or reject booking changes.

python
CopyEdit
class Admin(User):
    def __init__(self, user_id, username, password, email):
        super().__init__(user_id, username, password, email)
    
    def monitor_machines(self, machines):
        for machine in machines:
            print(f"Machine {machine.machine_id} ({machine.machine_type}): {len(machine.bookings)} bookings.")
    
    def approve_booking(self, booking):
        if booking.machine.is_available(booking.time_slot):
            booking.status = "Confirmed"
        else:
            print("Machine is not available for the requested time slot.")
    
    def cancel_booking(self, booking):
        booking.cancel()

3.6. LaundryRoom Class

This class manages all machines and handles the booking process at a higher level.

python
CopyEdit
class LaundryRoom:
    def __init__(self, name):
        self.name = name
        self.machines = []  # List of all machines in the laundry room
    
    def add_machine(self, machine):
        self.machines.append(machine)
    
    def get_available_slots(self, machine, requested_time_slot):
        # Returns available time slots for a particular machine
        if machine.is_available(requested_time_slot):
            return True
        return False

4. Relationships and Interactions

• Users interact with Machines via Bookings.

• Bookings associate a User with a Machine and a TimeSlot.

• Admins manage Users, Bookings, and the overall system.

• LaundryRoom acts as a central point where multiple Machines are managed.

5. System Flow

1. User Login/Signup: The user creates an account and logs into the system.

2. Machine Availability: The user views available machines and time slots.

3. Booking: The user selects a machine and a time slot and books it. If the slot is already taken, the system will notify them.

4. Booking Confirmation: The system confirms the booking and sends a notification to the user.

5. Admin Monitoring: Admin monitors usage and can approve or reject any booking requests.

6. Booking Cancellation: The user or admin can cancel a booking if necessary.

6. Considerations and Enhancements

• Real-time Notifications: Using event-driven design, notifications can be sent in real-time for upcoming bookings or available machines.

• Booking Limits: Users may be limited to booking one machine per day, or for certain times of day, based on usage patterns.

• Payment Integration: If charging for machine use, a payment gateway can be integrated.

• Overbooking Prevention: The system should prevent overbooking by maintaining real-time machine availability.

• User Feedback: Users could rate machines or share feedback after usage, helping others choose better machines.

7. Final Thoughts

This design follows key OOD principles like encapsulation, inheritance, and polymorphism, making it scalable and easy to maintain. Additional features, such as an advanced admin dashboard, user ratings, or integration with IoT sensors in the laundry room, can be added for future iterations.