Design a Shared Storage Facility Booking System with Object-Oriented Design

Shared Storage Facility Booking System Design Using Object-Oriented Design (OOD)

The Shared Storage Facility Booking System allows users to book storage units in a facility, manage their reservations, and ensure efficient allocation of space. The system needs to cater to multiple users, handle storage unit availability, and offer features for payments, user management, and scheduling. Object-Oriented Design (OOD) principles help create modular, scalable, and maintainable software for this system.

Key Classes and Objects in the System

1. User Class
   This class represents users who interact with the system, whether they are customers (renting storage) or admin (managing storage units).

   Attributes:

   • user_id: Unique identifier for the user

   • name: Name of the user

   • email: Contact email of the user

   • phone_number: Contact phone number

   • user_type: Type of user (e.g., Customer, Admin)

   • reservation_history: A list of past reservations made by the user

   Methods:

   • register_user(): Registers a new user

   • update_profile(): Allows the user to update their personal details

   • view_reservations(): Views all past and upcoming bookings

   • cancel_reservation(reservation_id): Cancels a booking

2. StorageUnit Class
   This class represents a storage unit in the facility.

   Attributes:

   • unit_id: Unique identifier for the unit

   • size: Size of the storage unit (e.g., small, medium, large)

   • location: The location within the facility

   • status: Current status (e.g., available, booked, under maintenance)

   • price_per_day: Daily cost of renting this storage unit

   Methods:

   • update_status(): Updates the availability of the unit (e.g., available or booked)

   • calculate_rent(duration): Calculates the rent based on the duration of the booking

   • mark_under_maintenance(): Marks the unit as under maintenance if needed

3. Reservation Class
   This class models a reservation made by a user to rent a storage unit.

   Attributes:

   • reservation_id: Unique identifier for the reservation

   • user: The user who made the reservation

   • storage_unit: The storage unit that has been reserved

   • start_date: Start date of the booking

   • end_date: End date of the booking

   • status: Reservation status (e.g., active, completed, cancelled)

   • total_cost: Total cost for the reservation

   Methods:

   • create_reservation(user, storage_unit, start_date, end_date): Creates a new reservation

   • cancel_reservation(): Cancels the reservation

   • update_reservation(new_dates): Updates the reservation with new dates

   • get_total_cost(): Returns the total cost based on the rental duration and unit price

4. Payment Class
   This class handles the payment for a reservation.

   Attributes:

   • payment_id: Unique identifier for the payment

   • reservation: The reservation associated with the payment

   • payment_date: The date the payment was made

   • amount: The total amount paid

   • payment_method: Method of payment (e.g., Credit Card, PayPal)

   Methods:

   • process_payment(): Processes the payment

   • refund_payment(): Refunds a payment (if applicable)

5. StorageFacility Class
   This class represents the storage facility and manages the units, reservations, and overall administration.

   Attributes:

   • facility_id: Unique identifier for the storage facility

   • name: Name of the facility

   • address: Location of the facility

   • storage_units: A list of available storage units in the facility

   • reservations: A list of all reservations made

   Methods:

   • add_storage_unit(storage_unit): Adds a new storage unit to the facility

   • remove_storage_unit(storage_unit): Removes a storage unit from the facility

   • search_available_units(size, start_date, end_date): Searches for available units based on size and dates

   • view_reservations(): Views all current reservations

   • generate_report(): Generates reports for facility utilization

System Use Cases

1. User Registration and Login:

   • Users can create an account, log in, and manage their profiles. Admins have the added ability to manage storage units.

2. Searching for Available Units:

   • Users can search for available units based on size, location, and rental dates. The system will return a list of storage units that match the criteria.

3. Making a Reservation:

   • Users can select a unit, specify the booking dates, and proceed to make a reservation. The system will check for availability and confirm the booking.

4. Managing Reservations:

   • Users can view, update, or cancel their reservations. Admins can modify the status of any reservation and manage overall availability.

5. Payment Processing:

   • Once a reservation is made, users are prompted to pay. The payment system processes the payment and associates it with the reservation.

6. Reporting for Admin:

   • Admins can generate reports that provide insights into facility usage, income, and available units.

Class Diagram Representation

plaintext
CopyEdit
+----------------+        +---------------------+        +-----------------+
|    User        |        |   StorageUnit       |        |   Reservation   |
+----------------+        +---------------------+        +-----------------+
| - user_id      |        | - unit_id           |        | - reservation_id|
| - name         |        | - size              |        | - user          |
| - email        |        | - location          |        | - storage_unit  |
| - phone_number |        | - status            |        | - start_date    |
| - user_type    |        | - price_per_day     |        | - end_date      |
| - reservations |        +---------------------+        | - status        |
+----------------+                                          | - total_cost    |
       |                                                    +-----------------+
       |                                                           ^
       v                                                           |
+-----------------+                                           +-----------------+
|   Payment      |                                           |  StorageFacility|
+-----------------+                                           +-----------------+
| - payment_id   |                                           | - facility_id   |
| - reservation  |                                           | - name          |
| - payment_date |                                           | - address       |
| - amount       |                                           | - storage_units |
| - payment_method|                                          | - reservations  |
+-----------------+                                           +-----------------+

System Flow Example

1. User Registration: A new user registers and logs into the system.

2. Unit Search: The user searches for available units for the desired dates and size.

3. Making a Reservation: Once the user selects a unit, they proceed with reserving it for the specified dates.

4. Payment: The user makes a payment for the reservation, and the system confirms the transaction.

5. Managing Reservation: The user can cancel or modify their reservation if needed.

6. Admin Management: Admins can manage storage units, check reservation reports, and generate financial reports.

Key Design Principles

1. Encapsulation: Each class encapsulates its attributes and methods, ensuring that the internal details are hidden and accessed only through public methods.

2. Modularity: The system is divided into distinct classes (User, Reservation, Payment, etc.), making it easy to maintain, extend, and debug.

3. Inheritance and Polymorphism: In case there are different types of users (e.g., Customer vs Admin), polymorphism can be used to define behavior for each user type.

4. Scalability: As demand increases, additional storage units or even entire storage facilities can be added without affecting the overall system.

This design should provide a solid framework for a shared storage facility booking system while following OOD principles to ensure modularity, maintainability, and scalability.