Mark Kendall

Gemfile.lock

@@ -29,6 +29,7 @@ GEM
 PLATFORMS
   arm64-darwin-20
   arm64-darwin-21
+  arm64-darwin-23
 
 DEPENDENCIES
   faraday

lib/dmv.rb

@@ -1,4 +1,8 @@
+#Class appears to track DMV facilities and services offered to customers
+require 'pry'
+
 class Dmv
+  attr_reader :facilities
 
   def initialize
     @facilities = []
@@ -9,8 +13,166 @@ def add_facility(facility)
   end
 
   def facilities_offering_service(service)
-    @facilities.find do |facility|
+    @facilities.find_all do |facility|
       facility.services.include?(service)
     end
   end
+
+  #Larger methods below.  For future: could consider classes for DMVs in each state, to better handle
+  #idiosyncracies to procedures and different dataset formats for different states.
+
+  def create_state_facilities(state, facilities_incoming_data)
+    facilities_incoming_data.each do |facility_data|
+      #Construct facility based on state, since dataset must be converted differently due to idiosyncracies in each case
+      if state == "Colorado"
+        new_facility = Facility.new(facility_parameters_co(facility_data))
+      elsif state == "New York"
+        new_facility = Facility.new(facility_parameters_ny(facility_data))
+      elsif state == "Missouri"
+        new_facility = Facility.new(facility_parameters_mo(facility_data))
+      end
+
+      add_facility(new_facility)
+
+      #Add services.  CO specifies some of them, so those must be checked (in furture rewrite, could remake initialize() to deal with this more cleanly too)
+      new_facility.add_service("Written Test")
+      new_facility.add_service("Road Test")
+      if state == "Colorado"
+        new_facility.add_service("New Drivers License") if facility_data[:services_p].include?("registration")
+        new_facility.add_service("Renew Drivers License") if facility_data[:services_p].include?("renew")
+      else
+        new_facility.add_service("New Drivers License")
+        new_facility.add_service("Renew Drivers License")
+      end
+    end
+  end
+
+  def get_ev_registration_analytics(state, specified_year)
+    #Determine most popular make/model registered, the # registered for specified year, and the county with most registered vehicles
+    #NOTE: I kept method naming based on EV vehicles.  However, now that I've extended functionality to allow NY vehicles (later in iteration 4), this method is more general,
+    #and can analyze general NY vehicles.
+
+    vehicle_tally = {}
+    @facilities.each do |facility|
+      if facility.state == state
+        facility.registered_vehicles.each do |vehicle|
+          if vehicle_tally.include?(vehicle.model)      #Assume just 'model' is enough (i.e. its unique and not make + model is needed)
+            vehicle_tally[vehicle.model] += 1
+          else
+            vehicle_tally[vehicle.model] = 1
+          end
+        end
+      end
+    end
+    #Now find the largest count in the hash:
+    most_popular_model = vehicle_tally.key(vehicle_tally.values.max)
+
+    #Count number of occurences of given registration year in vehicle list
+    vehicle_year_total = 0
+    @facilities.each do |facility|
+      if facility.state == state
+        vehicle_year_total += facility.registered_vehicles.count do |vehicle|
+          vehicle.registration_date.year == specified_year
+        end
+      end
+    end
+
+    #Find county which has the most vehicle registrations.  Note high machinery overlap with most popular model...a way to combine?
+    county_tally = {}
+    @facilities.each do |facility|
+      if facility.state == state
+        facility.registered_vehicles.each do |vehicle|
+          if county_tally.include?(vehicle.registration_county)
+            county_tally[vehicle.registration_county] += 1
+          else
+            county_tally[vehicle.registration_county] = 1
+          end
+        end
+      end
+    end
+    most_popular_county = county_tally.key(county_tally.values.max)
+
+    {most_popular_model: most_popular_model, number_registered_for_year: vehicle_year_total, county_most_registered_vehicles: most_popular_county}
+  end
+
+  def facility_parameters_co(facility_co_data)
+    #Try to centralize idiosyncratic aspects of each state's dataset to specific spots in codebase
+    #Alternate: could hosue this in Facility class.  Might try that another time - would require a different format since Facility wouldn't yet be initialized
+    {
+      name: facility_co_data[:dmv_office],
+      address: "#{facility_co_data[:address_li]} #{facility_co_data[:address__1]} #{facility_co_data[:location]} #{facility_co_data[:city]} #{facility_co_data[:state]} #{facility_co_data[:zip]}",
+      phone: facility_co_data[:phone],
+      hours: facility_co_data[:hours]       #Iteration 4: add hours (direct copy for CO)
+    }
+  end
+
+  def facility_parameters_ny(facility_ny_data)
+    #To format name: have to concatenate and then 'fix' capitlization the hard way (since each word is capitalized for a title usually)
+    name_formatted = facility_ny_data[:office_name].split.map { |word| word.capitalize }
+    name_formatted << (facility_ny_data[:office_type].split.map { |word| word.capitalize }).join(" ")
+    name_formatted = name_formatted.join(" ")
+
+    #To format address: lots of overlap here with previous entry.  If I knew how to make a method that accepted varying arguments, I might be able to; don't know this yet...
+    address_formatted = facility_ny_data[:street_address_line_1].split.map { |word| word.capitalize }
+    address_formatted << facility_ny_data[:city].split.map { |word| word.capitalize }
+    address_formatted << facility_ny_data[:state]
+    address_formatted << facility_ny_data[:zip_code]
+    address_formatted = address_formatted.join(" ")
+
+    #Hours are listed for each day by opening and closing.  For now, I'm going to brute-force this,
+    #since no exact format is expected.  This is a mess though:
+    #This is gross...some facilities don't have keys for all M-F.  So I need to run ifs now (otherwise problems with nil)
+    hours_formatted = ""
+    if facility_ny_data.include?(:monday_beginning_hours)
+      hours_formatted = "Monday: " + facility_ny_data[:monday_beginning_hours] + " - " + facility_ny_data[:monday_ending_hours] + "; "
+    end
+    if facility_ny_data.include?(:tuesday_beginning_hours)
+      hours_formatted << "Tuesday: " + facility_ny_data[:tuesday_beginning_hours] + " - " + facility_ny_data[:tuesday_ending_hours] + "; "
+    end
+    if facility_ny_data.include?(:wednesday_beginning_hours)
+      hours_formatted << "Wednesday: " + facility_ny_data[:wednesday_beginning_hours] + " - " + facility_ny_data[:wednesday_ending_hours] + "; "
+    end
+    if facility_ny_data.include?(:thursday_beginning_hours)
+      hours_formatted << "Thursday: " + facility_ny_data[:thursday_beginning_hours] + " - " + facility_ny_data[:thursday_ending_hours] + "; "
+    end
+    if facility_ny_data.include?(:friday_beginning_hours)
+      hours_formatted << "Friday: " + facility_ny_data[:friday_beginning_hours] + " - " + facility_ny_data[:friday_ending_hours]
+    end
+
+    #Some of the office don't seem to have phone numbers...make sure to process 'nil' correctly here
+    phone = facility_ny_data[:public_phone_number]
+    if phone != nil
+      phone_formatted = "(" + phone.slice(0, 3) + ") " + phone.slice(3, 3) + "-" + phone.slice(6, 4)
+    else
+      phone_formatted = "not applicable"
+    end
+
+    {
+      name: name_formatted,
+      address: address_formatted,
+      phone: phone_formatted,
+      hours: hours_formatted
+    }
+  end
+
+  def facility_parameters_mo(facility_mo_data)
+    address_formatted = facility_mo_data[:address1].delete_suffix(",")      #Certain (random?) entries end with it for some reason
+        address_formatted = "#{address_formatted} #{facility_mo_data[:city]} #{facility_mo_data[:state]} #{facility_mo_data[:zipcode]}"
+        hours_formatted = facility_mo_data[:daysopen]
+        if facility_mo_data.include?(:daysclosed)
+          hours_formatted << " except for " + facility_mo_data[:daysclosed]
+        end
+
+        facility_info = {
+          name: facility_mo_data[:name] + " Office",       #To be as consistent with other states as possible
+          address: address_formatted,
+          phone: facility_mo_data[:phone],
+          #Add hours (may need to format a little to be consistent across states)
+          #Add holidays here (since MO provides them)
+          #Need :daysopen, :daysclosed; :holidaysclosed
+          hours: hours_formatted,
+          holidays: facility_mo_data[:holidaysclosed]
+        }
+  end
+
 end

lib/dmv_data_service.rb

@@ -1,6 +1,8 @@
 require 'faraday'
 require 'json'
 
+#NOTE: I see that for the vehicle data loading, it only pulls 1000 vehicles for both WA and NY.  No way that is coincidence...where is the '1000' constraint present?
+
 class DmvDataService
   def load_data(source)
     response = Faraday.get(source)
@@ -11,6 +13,11 @@ def wa_ev_registrations
     @wa_ev_registrations ||= load_data('https://data.wa.gov/resource/rpr4-cgyd.json')
   end
 
+  def ny_vehicle_registrations
+    #Iteration 4 - based on dataset URL provided.  Should have same structure as other entries:
+    @ny_vehicle_registrations ||= load_data('https://data.ny.gov/resource/w4pv-hbkt.json')
+  end
+
   def co_dmv_office_locations
     @co_dmv_office_locations ||= load_data('https://data.colorado.gov/resource/dsw3-mrn4.json')
   end

lib/facility.rb

@@ -1,14 +1,66 @@
+#This tracks a specific DMV facility's core information and serviced rendered (or perhaps I should say """"""services""""""", given that it's the DMV)
+
 class Facility
-  attr_reader :name, :address, :phone, :services
+  attr_reader :name, :address, :phone, :services, :collected_fees, :registered_vehicles, :state, :hours, :holidays
+  @@fee_chart = {ev: 200, antique: 25, regular: 100}      #Fun new thing.  Can use again and again (class var, not instance var)
 
-  def initialize(name, address, phone)
-    @name = name
-    @address = address
-    @phone = phone
+  def initialize(facility_info)
+    @name = facility_info[:name]
+    @address = facility_info[:address]
+    @phone = facility_info[:phone]
     @services = []
+    @collected_fees = 0
+    @registered_vehicles = []
+    #Added in iteration 4 (for by-state searching).  Default is nil, if not specified (backwards compatible methinks)
+    @state = facility_info[:state]
+    @hours = facility_info[:hours]
+    @holidays = facility_info[:holidays]
   end
 
-  def add_services(service)
+  def add_service(service)
     @services << service
   end
+
+  def include?(service_specified)
+    #NOTE: find must return 'false' if nothing found to play nice with methods accessing it
+    @services.find(proc {false}) { |service| service == service_specified }
+  end
+
+  #Facility services
+
+  def register_vehicle(vehicle)
+    #Only register the vehicle if this facility offers the service!  Otherwise don't waste time with processing.
+    return nil if !include?("Vehicle Registration")
+
+    vehicle.registration_date = Date.today
+
+    #Determine plate type and collect fees (this of course assumes the registrant has/will pay)
+    if vehicle.electric_vehicle?()
+      vehicle.plate_type = :ev
+      @collected_fees += @@fee_chart[:ev]
+    elsif vehicle.antique?()
+      vehicle.plate_type = :antique
+      @collected_fees += @@fee_chart[:antique]
+    else
+      vehicle.plate_type = :regular
+      @collected_fees += @@fee_chart[:regular]
+    end
+
+    @registered_vehicles << vehicle
+  end
+
+  def administer_written_test(registrant)
+    #ALL conditions must be met.  Pretty compact!
+    registrant.license_data[:written] = include?("New Drivers License") && registrant.age >= 16 && registrant.permit?()
+  end
+
+  def administer_road_test(registrant)
+    #Of course, this assumes the registrant actually passes the test (happy path)
+    registrant.license_data[:license] = include?("Road Test") && registrant.license_data[:written] == true
+  end
+
+  def renew_drivers_license(registrant)
+    registrant.license_data[:renewed] = include?("Renew License") && registrant.license_data[:license] == true
+  end
+
 end

lib/registrant.rb

@@ -0,0 +1,18 @@
+class Registrant
+    attr_reader :name, :age, :license_data
+
+    def initialize(name, age, permit = false)
+        @name = name
+        @age = age
+        @permit = permit
+        @license_data = {:written => false, :license => false, :renewed => false}
+    end
+
+    def permit?()
+        @permit
+    end
+
+    def earn_permit()
+        @permit = true
+    end
+end

lib/vehicle.rb

@@ -5,14 +5,21 @@ class Vehicle
               :year,
               :make,
               :model,
-              :engine
+              :engine,
+              :registration_county
+  attr_accessor :registration_date, :plate_type
 
   def initialize(vehicle_details)
     @vin = vehicle_details[:vin]
-    @year = vehicle_details[:year]
+    @year = vehicle_details[:year].to_i   #Need to_i to permit proper function of antique?() method
     @make = vehicle_details[:make]
     @model = vehicle_details[:model]
     @engine = vehicle_details[:engine]
+    @registration_date = nil
+
+    #Could make a registration_data hash for compactness, but will keep vars separate to mimic interaction pattern
+    @plate_type = nil
+    @registration_county = vehicle_details[:county]     #This could either be set based on where car is built, OR where it's registered
   end
 
   def antique?

lib/vehicle_factory.rb

@@ -0,0 +1,55 @@
+#This 'manufactures' cars.  Kinda a misnomer, since it just takes existing registration data from API
+#(doesn't really build them), but I see why we could do this to 'help' the Vehicle class along.
+
+class VehicleFactory
+  attr_reader :vehicles_manufactured
+
+  def initialize()
+    @vehicles_manufactured = []
+  end
+
+  def create_vehicles(vehicle_registration_list, state)
+    #Different states produce different datasets, so need to switch based on this.
+
+    vehicle_registration_list.each do |vehicle|
+      if state == "Washington"
+        vehicle_data = {
+          vin: vehicle[:vin_1_10],
+          make: vehicle[:make],
+          model: vehicle[:model],
+          year: vehicle[:model_year],
+          #Assume the engine is always ev here in WA (though not generally true - happy path for now)
+          engine: :ev,
+          county: vehicle[:county]
+        }
+      elsif state == "New York"
+        #Engine type isn't specified in dataset.  Let's not get too fancy here, so just provide three options: :ev, :ice, or :other
+        case vehicle[:fuel_type]
+        when "ELECTRIC"
+          engine_type = :ev
+        when "GAS" || "DIESEL" || "PROPANE" || "FLEX"      #There are several fossil-fuel types...these are the only ones I'm pretty confident about
+          engine_type = :ice
+        else
+          engine_type = :other
+        end
+
+        vehicle_data = {
+          vin: vehicle[:vin],
+          make: vehicle[:make],
+          model: "data not available",      #Not provided in NY dataset, hence this value given
+          year: vehicle[:model_year],
+          engine: engine_type,
+          county: vehicle[:county].capitalize     #Be consistent between states
+        }
+      else
+        puts "Error: state invalid / not recognized.  Cannot build vehicles from registry."
+        return []                     #To be consistent with typical return type
+      end
+
+      @vehicles_manufactured << Vehicle.new(vehicle_data)
+    end
+
+    return @vehicles_manufactured
+  end
+
+end