Naheed & Dionisia's Ride Share Edges

README.md

@@ -165,7 +165,7 @@ We will do this by creating a `Driver` class which inherits from `User`.  A `Dri
 
 **Attribute**|**Description**
 -----|-----
-vehicle_id|The driver's Vehicle Identification Number (VIN Number), Each vehicle identification number should be a specific length of 17 to ensure it is a valid vehicle identification number
+|The driver's Vehicle Identification Number (VIN Number), Each vehicle identification number should be a specific length of 17 to ensure it is a valid vehicle identification number
 driven_trips | A list of trips the user has acted as a driver for.
 status|Indicating availability, a driver's availability should be either `:AVAILABLE` or `:UNAVAILABLE`
 
@@ -208,7 +208,7 @@ net_expenditures|This method will **override** the cooresponding method in `User
 
 **All the new methods above should have tests**
 
-<!-- # Wave 3
+# Wave 3
 
 Our program needs a way to make new trips and appropriately assign a driver and user.
 
@@ -246,7 +246,7 @@ Your code from waves 1 & 2 should _ignore_ any in-progress trips. That is to say
 
 You should also **add explicit tests** for this new situation. For example, what happens if you attempt to calculate the total money spent for a `User` with an in-progress trip, or the average hourly revenue of a `Driver` with an in-progress trip? -->
 
-<!-- # Wave 4
+# Wave 4
 
 We want to evolve `TripDispatcher` so it assigns drivers in more intelligent ways. Every time we make a new trip, we want to pick drivers who haven't completed a trip in a long time, or who have never been assigned a trip.
 

lib/driver.rb

@@ -0,0 +1,82 @@
+module RideShare
+  class Driver < User
+    attr_reader :vin
+    attr_accessor :driven_trips, :status
+
+    def initialize(input)
+      super(input)
+      if input[:vin].length != 17
+        raise ArgumentError, 'ID must be 17 characters'
+      end
+
+      # valid_staus = [:AVAILABLE, :UNAVAILABLE]
+      # if valid_staus.include?(@status)
+      #   raise ArgumentError, 'Not a valid status'
+      # end
+
+      @vin = input[:vin]
+      @driven_trips = input[:driven_trips].nil? ? [] : input[:driven_trips]
+      @status = input[:status] == nil ? :AVAILABLE : input[:status]
+    end
+
+    def average_rating
+      total_ratings = 0
+      @driven_trips.each do |trip|
+        total_ratings += trip.rating
+      end
+
+      if @driven_trips.length == 0
+        average = 0
+      else
+        average = (total_ratings.to_f) / @driven_trips.length
+      end
+
+      return average
+    end
+
+
+    # def average_rating
+    #   ratings = @driven_trips.find { |trip| trip.rating } #FIX ME PLEASE
+    #   # binding.pry
+    #   average = ratings.sum / @driven_trips.length
+    #   total_ratings = 0
+    #   @trips.each do |trip|
+    #     total_ratings += trip.rating
+    #   end
+    #
+    #   if trips.length == 0
+    #     average = 0
+    #   else
+    #     average = (total_ratings.to_f) / trips.length
+    #   end
+    #   return average
+    # end
+
+    def add_driven_trip(trip)
+      if trip.class != Trip
+        raise ArgumentError.new("Can only add trip instance to driven_trips array")
+      end
+      @driven_trips << trip
+      return @driven_trips
+    end
+
+    def total_revenue
+      revenue = 0.0
+      income = 0.0
+      @driven_trips.each do |trip|
+        if trip.cost == nil
+          raise ArgumentError, "Trip still in progress, no revenue"
+        else
+          revenue = (trip.cost - 1.65) * 0.8
+          income += revenue
+        end
+      end
+      return income.round(2)
+    end
+
+    def net_expenditures
+      return super - total_revenue
+    end
+
+  end
+end

lib/trip.rb

@@ -1,20 +1,38 @@
 require 'csv'
+require 'pry'
+
 
 module RideShare
   class Trip
-    attr_reader :id, :passenger, :start_time, :end_time, :cost, :rating
+    attr_reader :id, :passenger, :start_time, :end_time, :cost, :rating, :driver
 
     def initialize(input)
       @id = input[:id]
       @passenger = input[:passenger]
       @start_time = input[:start_time]
       @end_time = input[:end_time]
-      @cost = input[:cost]
-      @rating = input[:rating]
+      @cost = input[:cost].to_f
+      @rating = input[:rating].nil? ? nil : input[:rating]
+      @driver = input[:driver]
 
-      if @rating > 5 || @rating < 1
+      if @rating != nil && (@rating > 5 || @rating < 1)
         raise ArgumentError.new("Invalid rating #{@rating}")
       end
+
+      if @end_time != nil && (@start_time > @end_time)
+        raise ArgumentError, "Invalid end time"
+      end
+
+    end
+
+    # def retrieve_driver(driver)
+    #   driver = Driver.find(line[0])
+    # end
+
+    def trip_duration
+      duration = @end_time - @start_time
+      duration_in_seconds = duration.to_i
+      return duration_in_seconds
     end
 
     def inspect

lib/trip_dispatcher.rb

@@ -1,16 +1,20 @@
 require 'csv'
 require 'time'
+require 'pry'
 
 require_relative 'user'
 require_relative 'trip'
+require_relative 'driver'
 
 module RideShare
   class TripDispatcher
     attr_reader :drivers, :passengers, :trips
 
     def initialize(user_file = 'support/users.csv',
-                   trip_file = 'support/trips.csv')
+      trip_file = 'support/trips.csv',
+      driver_file = 'support/drivers.csv')
       @passengers = load_users(user_file)
+      @drivers = load_drivers(driver_file)
       @trips = load_trips(trip_file)
     end
 
@@ -25,52 +29,132 @@ def load_users(filename)
 
         users << User.new(input_data)
       end
-
       return users
     end
 
+    def load_drivers(filename)
+      driver_data = CSV.open(filename, 'r', headers: true, header_converters: :symbol)
+
+      return driver_data.map do |each_driver|
+        user = find_passenger(each_driver[:id].to_i)
+        # binding.pry
+        driver = {
+          id: each_driver[:id].to_i,
+          trips: user.trips,
+          vin: each_driver[:vin],
+          status: each_driver[:status].to_sym,
+          name: user.name,
+          phone: user.phone_number
+        }
+
+        Driver.new(driver)
+      end
+
+    end
 
     def load_trips(filename)
       trips = []
       trip_data = CSV.open(filename, 'r', headers: true,
-                                          header_converters: :symbol)
-
-      trip_data.each do |raw_trip|
-        passenger = find_passenger(raw_trip[:passenger_id].to_i)
-
-        parsed_trip = {
-          id: raw_trip[:id].to_i,
-          passenger: passenger,
-          start_time: raw_trip[:start_time],
-          end_time: raw_trip[:end_time],
-          cost: raw_trip[:cost].to_f,
-          rating: raw_trip[:rating].to_i
-        }
+        header_converters: :symbol)
+
+        trip_data.each do |raw_trip|
+          passenger = find_passenger(raw_trip[:passenger_id].to_i)
+          driver = find_driver(raw_trip[:driver_id].to_i)
+          raw_trip[:start_time] = Time.parse(raw_trip[:start_time])
+          raw_trip[:end_time] = Time.parse(raw_trip[:end_time])
+          parsed_trip = {
+            id: raw_trip[:id].to_i,
+            passenger: passenger,
+            start_time: raw_trip[:start_time],
+            end_time: raw_trip[:end_time],
+            cost: raw_trip[:cost].to_f,
+            rating: raw_trip[:rating].to_i,
+            driver: driver
+          }
+
+          trip = Trip.new(parsed_trip)
+          passenger.add_trip(trip)
+          driver.add_driven_trip(trip)
+          trips << trip
+
+        end
+        return trips
+      end
 
-        trip = Trip.new(parsed_trip)
-        passenger.add_trip(trip)
-        trips << trip
+      def find_passenger(id)
+        check_id(id)
+        return @passengers.find { |passenger| passenger.id == id }
       end
 
-      return trips
-    end
+      def find_driver(id)
+        check_id(id)
+        return @drivers.find { |driver| driver.id == id }
+      end
 
-    def find_passenger(id)
-      check_id(id)
-      return @passengers.find { |passenger| passenger.id == id }
-    end
+      def inspect
+        return "#<#{self.class.name}:0x#{self.object_id.to_s(16)} \
+        #{trips.count} trips, \
+        #{drivers.count} drivers, \
+        #{passengers.count} passengers>"
+      end
 
-    def inspect
-      return "#<#{self.class.name}:0x#{self.object_id.to_s(16)} \
-              #{trips.count} trips, \
-              #{drivers.count} drivers, \
-              #{passengers.count} passengers>"
-    end
+      def check_id(id)
+        raise ArgumentError, "ID cannot be blank or less than zero. (got #{id})" if id.nil? || id <= 0
+      end
+
+      def request_trip(user_id)
+        chosen_driver = assign_driver(user_id)
+        passenger = find_passenger(user_id)
 
-    private
+        valid_trip_id = [1..1000].select
+        @trips.each do |trip|
+          if trip.id == valid_trip_id
+            raise ArgumentError, "ID already exists"
+          end
+        end
 
-    def check_id(id)
-      raise ArgumentError, "ID cannot be blank or less than zero. (got #{id})" if id.nil? || id <= 0
+        trip = RideShare::Trip.new(id: valid_trip_id, driver: chosen_driver, passenger: passenger, start_time: Time.now, end_time: nil, cost: nil, rating: nil)
+
+        chosen_driver.add_driven_trip(trip)
+        passenger.add_trip(trip)
+        @trips << trip
+        return trip
+      end
+
+      def assign_driver(passenger_id)
+        # iterates through the drivers to select and return available drivers and drivers who are not driving themselves
+        available_drivers = @drivers.select do |driver|
+          if driver.status == :AVAILABLE && driver.id != passenger_id
+            driver
+          end
+        end
+
+        # iterates through the available_drivers to see if there is a driver that has not given any trips.
+        chosen_driver = available_drivers.find do |driver|
+          driver.driven_trips.empty?
+        end
+
+        # if there hasn't been a driver that hasn't given any trips, then this iterates through available drivers and selects the driver who's trip ended the longest time ago.
+        if chosen_driver.nil?
+          furthest_date = Time.now
+          available_drivers.each do |driver|
+            # This assumes that driven_trips are in chronological order
+            end_time = driver.driven_trips.last.end_time
+            if end_time < furthest_date
+              end_time = furthest_date # sets new end time
+              chosen_driver = driver # assigns that driver as chosen driver
+            end
+          end
+        end
+
+        # if there are no available drivers
+        if chosen_driver.nil?
+          raise ArgumentError, "No drivers available"
+        end
+
+        # if there is an available driver, changes their status
+        chosen_driver.status = :UNAVAILABLE
+        return chosen_driver
+      end
     end
   end
-end

lib/user.rb

@@ -1,3 +1,4 @@
+require 'pry'
 module RideShare
   class User
     attr_reader :id, :name, :phone_number, :trips
@@ -16,5 +17,29 @@ def initialize(input)
     def add_trip(trip)
       @trips << trip
     end
+
+    def net_expenditures
+      cost_array = []
+      @trips.each do |trip|
+        if trip.cost == nil
+          raise ArgumentError, "Trip is in progress, no cost"
+        end
+        cost = trip.cost
+        cost_array << cost
+      end
+      return cost_array.sum
+    end
+
+    def total_time_spent
+      time_array = []
+      @trips.each do |trip|
+        if trip.end_time == nil
+          raise ArgumentError, "Trip is in progress, no end time"
+        end
+        time_per_trip = trip.end_time.to_i - trip.start_time.to_i
+        time_array << time_per_trip
+      end
+      return time_array.sum
+    end
   end
 end