Define Class Members (write code)

Attributes: For each class, define the attributes (data) it will hold...
Methods: Define the methods (functions) that operate on the attributes. Ensure they align with the object's responsibilities and adhere to the principle of encapsulation.
import math
import datetime
import unittest

class ReservationSystem {
  def __init__(self,pricePerHour,parkingFloors):
    self._pricePerHour = pricePerHour
    self._parkingFloors = parkingFloors

  def createParkingSession(self,vehicle):
    """
    Start a parking session
    """
    parkingSession = ParkingSession(vehicle.id)

  def endParkingSession(self,parkingSession):
    """
    End parking session by calculating the fee based on duration
    :param parkingSession: the active parking session to end
    :return: calculated fee
    """
    parkingSession.endParkingSession()
    fee = self.calculateFee(parkingSession.duration)
    return fee
  
  def calculateFee(duration):
    """
    Calculate the parking fee based on duration
    :param duration: The duration (in hours) of parking session
    :return: Total fee
    """
    return duration * self._pricePerHour

  def assignSpot(self,parkingSession):
      spot = self._getAvailableSpotForVehicle(parkingSession)
      spot.reserveSpot(vehicle)
      spot._unlock()
      return True

  def _getAvailableSpotForVehicle(self,parkingSession):
    for floor in self._floors:
      for spot in floor:
        # return first available spot
        if spot.IsLocked() == False and spot.isAvailable() == True and spot.getSize() >= parkingSession.getVehicleSize():
          spot.lock()
          return spot
    # if there is no available spot that meets size requirements, notify driver
    return False
}

class ParkingFloor:
  def __init__(self,parkingSpots):
    self._parkingSpots = parkingSpots

class Vehicle:
  def __init__(self,size):
    self._size = size

  def createVehicle(type):
    if type == "motorcycle":
      return Motorcycle()
    if type == "sedan":
      return Sedan()
    if type == "van":
      return Van()

class Motorcycle(Vehicle):
  def __init__(self):
    super().__init__(0)

class Sedan(Vehicle):
  def __init__(self):
    super().__init__(1)

class Van(Vehicle):
  def __init__(self):
    super().__init__(2)

class ParkingSession(self,vehicle):
  def __init__(self,vehicle):
      self._vehicle = vehicle
      self._parkingSpot = None
      self._createdAt = datetime.datetime.now()
      self._stoppedAt = None
      self._duration = None

    def endParkingSession(self):
       self._stoppedAt = datetime.datetime.now()
       self._calculateDuration()

    def _calculateDuration(self):
      if self._stoppedAt and self._startedAt:
        duration = self._stoppedAt - self._startedAt
        self._updateDuration(duration)

    def _updateDuration(self,duration):
      self._duration = duration

class ParkingSpot(size):
  def __init__(self):
    self._size = size
    self._locked = False
    self._isAvailable = True
    self._assignedVehicleId = None

  def reserve(self,vehicle):
    """
    Assigns a parking spot to a vehicle and returns if successful
    :param vehicle: The vehicle to assign to the spot
    :return: True/False reservation was successful
    """
    if self._isLocked():
      return False
    if self._isAvailable:
      self._isAvailable = False
      self._assignedVehicleId = vehicle.Id
      self._unlock()
      return True
    return False

  def getSize(self):
    return self._size

  def isAvailable(self):
    return self._isAvailable

  def _setIsAvailable(self,isAvailable):
    self._isAvailable = isAvailable

  def _isLocked(self):
    return self._locked

  def _lock(self):
    self._locked = True

  def _unlock(self):
    self._locked = False

class TestGetAvailableSpot(unittest.TestCase):
  def setUp(self):
    # initialize array of ParkingFloors, each an array of ParkingSpots
    floors = [ParkingFloor([ParkingSpot(0)] * 10 + [ParkingSpot(1)] * 100),
              ParkingFloor([ParkingSpot(1)] * 50 + [ParkingSpot(2)] * 50),
              ParkingFloor([ParkingSpot(1)] * 50 + [ParkingSpot(2)] * 50)]
    self.reservationSystem = ReservationSystem(2.00,floors)

  def test_vehicle_size_matches_spot_size(self):
    vehicles = [Sedan(), Motorcyle(), Van()]
    for vehicle in vehicles:
      self.reservationSystem.assignSpot(vehicle)
      self.assertEqual(vehicle.getSize(),spot.getSize())

  def test_spot_not_available_after_reserved(self):
      vehicles = [Sedan(), Motorcyle(), Van()]
      for vehicle in vehicles:
        self.reservationSystem.assignSpot(vehicle)
        self.assertFalse(spot.isAvailable())

if __name__ == "__main__":
  unittest.main()
Submissions

Displaying Solutions with Scores Ranging from 1 to 10
