oo-ride-share - Liz and Hannah

.gitignore

@@ -1,2 +1,3 @@
 /coverage/
 .DS_Store
+.idea

lib/driver.rb

@@ -0,0 +1,70 @@
+require 'pry'#driver class
+module RideShare
+  class Driver < User
+    attr_reader :vehicle_id, :status, :driven_trips
+
+    def initialize(input, status=:UNAVAILABLE)
+      super(input)
+
+      if input[:id].nil? || input[:id] <= 0
+        raise ArgumentError, 'ID cannot be blank or less than zero.'
+      end
+
+      @vehicle_id = input[:vehicle_id].to_s      # binding.pry
+        if @vehicle_id.length != 17 || @vehicle_id.empty?
+          raise ArgumentError, 'Invalid VIN'
+        end
+      @status = (input[:status]).to_sym
+        unless @status == :UNAVAILABLE || @status == :AVAILABLE
+          raise ArgumentError, "invalid status"
+        end
+      @driven_trips = []
+    end
+
+    def average_rating
+      completed_trips = @driven_trips.find_all { |trip| trip.end_time != nil }
+
+      return 0 if completed_trips.empty?
+
+      total = 0
+      completed_trips.each do |trip|
+        total += trip.rating
+      end
+
+      average = total.to_f / completed_trips.length
+      return average
+    end
+
+    def add_driven_trip(trip)
+      unless trip.instance_of? Trip
+        raise ArgumentError, 'invalid trip data'
+      end
+      @driven_trips << trip
+    end
+
+    def add_trip_in_progress(trip)
+      @status = :UNAVAILABLE
+      @driven_trips << trip
+    end
+
+    def total_revenue
+      completed_trips = @driven_trips.find_all { |trip| trip.end_time != nil }
+      total = 0
+      completed_trips.each do |trip|
+        total += (trip.cost - 1.65) * 0.80
+      end
+      return total
+    end
+
+    def net_expenditures
+      return (super - total_revenue)
+    end
+
+# latest drive developed for wave 4
+    def latest_drive
+      latest = @driven_trips.max_by {|trip| trip.end_time }.end_time
+      return latest
+    end
+
+  end
+end

lib/trip.rb

@@ -2,18 +2,25 @@
 
 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]
-
-      if @rating > 5 || @rating < 1
-        raise ArgumentError.new("Invalid rating #{@rating}")
+      @cost = input[:cost] ? input[:cost].to_f : nil
+      @rating = input[:rating] ? input[:rating].to_i : nil
+      @driver = input[:driver]
+      unless @end_time == nil
+        if @rating > 5 || @rating < 1
+          raise ArgumentError.new("Invalid rating #{@rating}")
+        end
+      end
+      unless @end_time == nil
+        if @start_time > @end_time
+          raise ArgumentError, "Invalid input. Start time must be before end time."
+        end
       end
     end
 
@@ -22,5 +29,9 @@ def inspect
       "ID=#{id.inspect} " +
       "PassengerID=#{passenger&.id.inspect}>"
     end
+
+    def time_duration
+      return @end_time - @start_time
+    end
   end
 end

lib/trip_dispatcher.rb

@@ -1,17 +1,23 @@
 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
 
     def load_users(filename)
@@ -25,33 +31,35 @@ def load_users(filename)
 
         users << User.new(input_data)
       end
-
       return users
     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)
+        driver = find_driver(raw_trip[:driver_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],
+          driver: driver,
+          # Modify load_trips to store the start_time and end_time
+          start_time: Time.parse(raw_trip[:start_time]),
+          end_time: Time.parse(raw_trip[:end_time]),
           cost: raw_trip[:cost].to_f,
           rating: raw_trip[:rating].to_i
         }
 
         trip = Trip.new(parsed_trip)
+        driver.add_trip(trip)
+        driver.add_driven_trip(trip)
         passenger.add_trip(trip)
         trips << trip
       end
-
       return trips
     end
 
@@ -67,6 +75,63 @@ def inspect
               #{passengers.count} passengers>"
     end
 
+    # Load the Drivers from the support/drivers.csv file and
+    # return a collection of Driver instances, note that drivers
+    # can be passengers too! Replace the instance of User in the
+    # passengers array with a corresponding instance of Driver
+    def load_drivers(filename)
+      # initialize drivers
+      drivers = []
+      # parse csv for drivers
+       CSV.open(filename, 'r', headers: true).map do |line|
+        id = line[0].to_i
+        passenger = find_passenger(line[0].to_i)
+        line[1].length
+
+        driver_data = Driver.new({id: line[0].to_i,
+          name: passenger.name,
+          phone_number: passenger.phone_number,
+          trips: passenger.trips,
+          vehicle_id: line[1],
+          status: line[2]})
+          drivers << driver_data
+      end
+      return drivers
+    end
+
+    def find_driver(id)
+      check_id(id)
+      return @drivers.find { |driver| driver.id == id }
+    end
+
+    def request_trip(user_id)
+      passenger = find_passenger(user_id)
+
+      available_drivers = @drivers.find_all { |driver| driver.status == :AVAILABLE && driver.id != user_id}
+         raise ArgumentError, 'No available drivers' if available_drivers == []
+
+      driver = available_drivers.find { |driver| driver.driven_trips.empty? } # of .empty?
+        if driver.nil?
+          driver = available_drivers.min_by { |driver| driver.latest_drive }
+        end
+
+      parsed_trip = {
+        id: "id",
+        passenger: user_id,
+        driver: driver.id,
+        start_time: Time.now,
+        end_time: nil,
+        cost: nil,
+        rating: nil
+      }
+
+      trip = Trip.new(parsed_trip)
+      driver.add_trip_in_progress(trip)
+      passenger.add_trip(trip)
+      @trips << trip
+      return trip
+    end
+
     private
 
     def check_id(id)

lib/user.rb

@@ -16,5 +16,27 @@ def initialize(input)
     def add_trip(trip)
       @trips << trip
     end
+    # Add an instance method, net_expenditures, to User that will return
+    # the total amount of money that user has spent on their trips
+    def net_expenditures
+
+      total = 0
+      @trips.each do |trip_inst|
+        total += trip_inst.cost
+      end
+      return total
+    end
+
+    # Add an instance method, total_time_spent to User that will return
+    # the total amount of time that user has spent on their trips
+    def total_time_spent
+      completed_trips = @trips.find_all { |trip| trip.end_time != nil }
+
+      total_time = 0
+      completed_trips.each do |trip_inst|
+        total_time += (trip_inst.end_time - trip_inst.start_time)
+      end
+      return total_time
+    end
   end
 end