Design a Digital Peer-to-Peer Car Rental System Using OOD Principles

Overview

A Digital Peer-to-Peer (P2P) Car Rental System allows individuals to rent their personal vehicles to other users, effectively bypassing traditional car rental companies. The system can handle listing, booking, pricing, payment, and ratings, among other functions. By utilizing Object-Oriented Design (OOD) principles, the system becomes modular, scalable, and maintainable. In this design, we will focus on creating classes, objects, and interactions to cover the essential functions of such a system.

Key Functionalities

1. User Management: Users can register, manage their profiles, and authenticate to access the system.

2. Vehicle Listing: Car owners can list their vehicles for rent.

3. Booking: Renters can search and book available cars.

4. Payment: A secure payment system for rentals.

5. Rating & Review: Renters and owners can leave feedback for each other.

6. Notifications: Both owners and renters receive notifications for bookings, cancellations, and other relevant events.

Class Design

1. User Class

The User class is the base class for both renters and car owners. It holds basic information and common functions for both.

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.rentals = []  # List of rentals owned by the user
        self.bookings = []  # List of bookings made by the user

    def update_profile(self, name=None, email=None, phone=None):
        if name: self.name = name
        if email: self.email = email
        if phone: self.phone = phone

    def view_rentals(self):
        return self.rentals
    
    def view_bookings(self):
        return self.bookings

2. CarOwner Class

Inherits from the User class. This class represents a user who owns vehicles and rents them out.

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

    def list_vehicle(self, vehicle):
        self.vehicles.append(vehicle)
        vehicle.owner = self

    def view_vehicles(self):
        return self.vehicles

    def update_rental_status(self, vehicle_id, status):
        # Update vehicle availability status
        vehicle = self.find_vehicle(vehicle_id)
        if vehicle:
            vehicle.status = status
        return vehicle

    def find_vehicle(self, vehicle_id):
        for vehicle in self.vehicles:
            if vehicle.vehicle_id == vehicle_id:
                return vehicle
        return None

3. Vehicle Class

Represents a car available for rent, containing information like vehicle type, price, and status.

python
CopyEdit
class Vehicle:
    def __init__(self, vehicle_id, make, model, year, price_per_day, owner):
        self.vehicle_id = vehicle_id
        self.make = make
        self.model = model
        self.year = year
        self.price_per_day = price_per_day
        self.status = 'available'  # can be available, rented, or unavailable
        self.owner = owner

    def update_status(self, status):
        self.status = status

4. Renter Class

Inherits from User. Renters can search and book available vehicles.

python
CopyEdit
class Renter(User):
    def __init__(self, user_id, name, email, phone):
        super().__init__(user_id, name, email, phone)
    
    def search_vehicle(self, vehicles, make=None, model=None, price_range=None):
        available_vehicles = [v for v in vehicles if v.status == 'available']
        if make:
            available_vehicles = [v for v in available_vehicles if v.make == make]
        if model:
            available_vehicles = [v for v in available_vehicles if v.model == model]
        if price_range:
            min_price, max_price = price_range
            available_vehicles = [v for v in available_vehicles if min_price <= v.price_per_day <= max_price]
        return available_vehicles

    def book_vehicle(self, vehicle, start_date, end_date):
        if vehicle.status == 'available':
            vehicle.status = 'rented'
            booking = Booking(self, vehicle, start_date, end_date)
            self.bookings.append(booking)
            vehicle.owner.rentals.append(booking)
            return booking
        else:
            return None

5. Booking Class

Represents a booking made by a renter. This class tracks the dates of the booking and the rental status.

python
CopyEdit
class Booking:
    def __init__(self, renter, vehicle, start_date, end_date):
        self.booking_id = f"BOOK{len(renter.bookings) + 1}"
        self.renter = renter
        self.vehicle = vehicle
        self.start_date = start_date
        self.end_date = end_date
        self.status = 'confirmed'  # can be confirmed, completed, or cancelled

    def cancel_booking(self):
        self.status = 'cancelled'
        self.vehicle.status = 'available'

6. Payment Class

Handles the payment process for each booking.

python
CopyEdit
class Payment:
    def __init__(self, booking, amount):
        self.booking = booking
        self.amount = amount
        self.payment_status = 'pending'

    def process_payment(self):
        # Logic for processing payment (e.g., via a payment gateway)
        self.payment_status = 'successful'
        return self.payment_status

7. Rating Class

Allows users to rate each other after a rental is completed.

python
CopyEdit
class Rating:
    def __init__(self, user, vehicle, rating, review):
        self.user = user
        self.vehicle = vehicle
        self.rating = rating  # A score between 1 to 5
        self.review = review  # Text feedback
        self.timestamp = "2025-07-18"  # Date when the rating was given

    def update_review(self, new_review):
        self.review = new_review

System Interactions

1. Listing a Vehicle

• Car owners list their vehicle for rent, setting the price and availability.

• Renters can search for available vehicles based on certain criteria (e.g., make, model, price).

2. Booking a Vehicle

• Renters find an available vehicle and request a booking.

• Once a booking is made, the system processes the payment.

3. Payment Process

• The payment process is tied to the booking and is only confirmed after the renter pays the required amount.

4. Rating and Review

• After the rental period ends, both the renter and owner can rate each other.

• The rating affects the reputation of both parties in future transactions.

Sequence Diagram Example

The sequence for booking a vehicle would look like this:

1. Renter searches for available vehicles.

2. System returns a list of available vehicles.

3. Renter selects a vehicle and provides rental dates.

4. System checks the vehicle status and processes the booking.

5. Payment is processed.

6. Booking Confirmation sent to both renter and owner.

7. Renter and Owner can leave ratings after the rental.

Conclusion

This design uses fundamental OOD principles like encapsulation, inheritance, and polymorphism to structure the digital peer-to-peer car rental system. By breaking down the system into smaller, independent classes that represent core entities (users, vehicles, bookings, etc.), it makes the system more manageable, scalable, and maintainable.