smartcar 2.5.0 → 3.0.0

data/lib/smartcar/auth_client.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Smartcar
+  # AuthClient class to take care of the Oauth 2.0 with Smartcar APIs
+  #
+  class AuthClient
+    include Smartcar::Utils
+
+    attr_reader :redirect_uri, :client_id, :client_secret, :scope, :mode, :flags, :origin
+
+    # Constructor for a client object
+    #
+    # @param [Hash] options
+    # @option options[:client_id] [String] - Client ID, if not passed fallsback to ENV['SMARTCAR_CLIENT_ID']
+    # @option options[:client_secret] [String] - Client Secret, if not passed fallsback to ENV['SMARTCAR_CLIENT_SECRET']
+    # @option options[:redirect_uri] [String] - Redirect URI, if not passed fallsback to ENV['SMARTCAR_REDIRECT_URI']
+    # @option options[:test_mode] [Boolean] - Setting this to 'true' runs it in test mode.
+    #
+    # @return [Smartcar::AuthClient] Returns a Smartcar::AuthClient Object that has other methods
+    def initialize(options)
+      options[:redirect_uri] ||= get_config('SMARTCAR_REDIRECT_URI')
+      options[:client_id] ||= get_config('SMARTCAR_CLIENT_ID')
+      options[:client_secret] ||= get_config('SMARTCAR_CLIENT_SECRET')
+      options[:mode] = options[:test_mode].is_a?(TrueClass) ? TEST : LIVE
+      options[:origin] = ENV['SMARTCAR_AUTH_ORIGIN'] || AUTH_ORIGIN
+      super
+    end
+
+    # Generate the OAuth authorization URL.
+    # @param scope [Array<String>] Array of permissions that specify what the user can access
+    #   EXAMPLE : ['read_odometer', 'read_vehicle_info', 'required:read_location']
+    # For further details refer to https://smartcar.com/docs/guides/scope/
+    # @param [Hash] options
+    # @option options[:force_prompt] [Boolean] - Setting `force_prompt` to
+    # `true` will show the permissions approval screen on every authentication
+    # attempt, even if the user has previously consented to the exact scope of
+    # permissions.
+    # @option options[:single_select] [Hash] - An optional object that sets the
+    # behavior of the grant dialog displayed to the user. Object can contain two keys :
+    # - enabled - Boolean value, if set to `true`,
+    #   `single_select` limits the user to selecting only one vehicle.
+    # - vin - String vin, if set, Smartcar will only authorize the vehicle
+    #   with the specified VIN.
+    # See the [Single Select guide](https://smartcar.com/docs/guides/single-select/) for more information.
+    # @option options[:state] [String] - OAuth state parameter passed to the
+    # redirect uri. This parameter may be used for identifying the user who
+    # initiated the request.
+    # @option options[:make_bypass] [String] - `make_bypass' is an optional parameter that allows
+    # users to bypass the car brand selection screen.
+    # For a complete list of supported makes, please see our
+    # [API Reference](https://smartcar.com/docs/api#authorization) documentation.
+    # @option options[:flags] [Hash] - A hash of flag name string as key and a string or boolean value.
+    #
+    # @return [String] Authorization URL string
+    def get_auth_url(scope, options = {})
+      initialize_auth_parameters(scope, options)
+      add_single_select_options(options[:single_select])
+      client.auth_code.authorize_url(@auth_parameters)
+    end
+
+    # Generates the tokens hash using the code returned in oauth process.
+    # @param code [String] This is the code that is returned after user
+    # visits and authorizes on the authorization URL.
+    # @param [Hash] options
+    # @option options[:flags] [Hash] - A hash of flag name string as key and a string or boolean value.
+    #
+    # @return [Hash] Hash of token, refresh token, expiry info and token type
+    def exchange_code(code, options = {})
+      set_token_url(options[:flags])
+
+      token_hash = client.auth_code
+                         .get_token(code, redirect_uri: redirect_uri)
+                         .to_hash
+
+      JSON.parse(token_hash.to_json, object_class: OpenStruct)
+    rescue OAuth2::Error => e
+      raise build_error(e.response.status, e.response.body, e.response.headers)
+    end
+
+    # Refreshing the access token
+    # @param token [String] refresh_token received during token exchange
+    # @param [Hash] options
+    # @option options[:flags] [Hash] - A hash of flag name string as key and a string or boolean value.
+    #
+    # @return [Hash] Hash of token, refresh token, expiry info and token type
+    def exchange_refresh_token(token, options = {})
+      set_token_url(options[:flags])
+
+      token_object = OAuth2::AccessToken.from_hash(client, { refresh_token: token })
+      token_object = token_object.refresh!
+
+      JSON.parse(token_object.to_hash.to_json, object_class: OpenStruct)
+    rescue OAuth2::Error => e
+      raise build_error(e.response.status, e.response.body, e.response.headers)
+    end
+
+    # Checks if token is expired using Oauth2 classes
+    # @param expires_at [Number] expires_at as time since epoch
+    #
+    # @return [Boolean]
+    def expired?(expires_at)
+      OAuth2::AccessToken.from_hash(client, { expires_at: expires_at }).expired?
+    end
+
+    private
+
+    def build_flags(flags)
+      return unless flags
+
+      flags.map { |key, value| "#{key}:#{value}" }.join(' ')
+    end
+
+    def set_token_url(flags)
+      params = {}
+      params[:flags] = build_flags(flags) if flags
+      # Note - The inbuild interface to get the token does not allow any way to pass additional
+      # URL params. Hence building the token URL with the flags and setting it in client.
+      client.options[:token_url] = client.connection.build_url('/oauth/token', params).request_uri
+    end
+
+    def initialize_auth_parameters(scope, options)
+      @auth_parameters = {
+        response_type: CODE,
+        redirect_uri: redirect_uri,
+        mode: mode,
+        scope: scope.join(' ')
+      }
+      @auth_parameters[:approval_prompt] = options[:force_prompt] ? FORCE : AUTO unless options[:force_prompt].nil?
+      @auth_parameters[:state] = options[:state] if options[:state]
+      @auth_parameters[:make] = options[:make_bypass] if options[:make_bypass]
+      @auth_parameters[:flags] = build_flags(options[:flags]) if options[:flags]
+    end
+
+    def add_single_select_options(single_select)
+      return unless single_select
+
+      if single_select[:vin]
+        @auth_parameters[:single_select_vin] = single_select[:vin]
+        @auth_parameters[:single_select] = true
+      elsif !single_select[:enabled].nil?
+        @auth_parameters[:single_select] = single_select[:enabled]
+      end
+    end
+
+    # gets the Oauth Client object
+    #
+    # @return [OAuth2::Client] A Oauth Client object.
+    def client
+      @client ||= OAuth2::Client.new(client_id,
+                                     client_secret,
+                                     site: origin)
+    end
+  end
+end

data/lib/smartcar/base.rb

@@ -10,14 +10,12 @@ module Smartcar
 
     # Error raised when an invalid parameter is passed.
     class InvalidParameterValue < StandardError; end
-    # Constant for Bearer auth type
-    BEARER = 'BEARER'
     # Constant for Basic auth type
-    BASIC = 'BASIC'
+    BASIC = 'Basic'
     # Number of seconds to wait for response
     REQUEST_TIMEOUT = 310
 
-    attr_accessor :token, :error, :meta, :unit_system, :version
+    attr_accessor :token, :error, :unit_system, :version, :auth_type
 
     %i[get post patch put delete].each do |verb|
       # meta programming and define all Restful methods.
@@ -27,8 +25,7 @@ module Smartcar
       # @return [Hash] The response Json parsed as a hash.
       define_method verb do |path, data = nil|
         response = service.send(verb) do |request|
-          request.headers['Authorization'] = "BEARER #{token}"
-          request.headers['Authorization'] = "BASIC #{generate_basic_auth}" if data && data[:auth] == BASIC
+          request.headers['Authorization'] = auth_type == BASIC ? "Basic #{token}" : "Bearer #{token}"
           request.headers['sc-unit-system'] = unit_system if unit_system
           request.headers['Content-Type'] = 'application/json'
           complete_path = "/v#{version}#{path}"
@@ -39,38 +36,31 @@ module Smartcar
             request.body = data.to_json if data
           end
         end
-        error = get_error(response)
-        raise error if error
-
-        [JSON.parse(response.body), response.headers]
+        handle_error(response)
+        # required to handle unsubscribe response
+        body = response.body.empty? ? '{}' : response.body
+        [JSON.parse(body), response.headers]
       end
     end
 
     # This requires a proc 'PATH' to be defined in the class
     # @param path [String] resource path
-    # @param options [Hash] query params
+    # @param query_params [Hash] query params
     # @param auth [String] type of auth
     #
     # @return [Object]
-    def fetch(path:, options: {}, auth: 'BEARER')
-      path += "?#{URI.encode_www_form(options)}" unless options.empty?
-      get(path, { auth: auth })
+    def fetch(path:, query_params: {})
+      path += "?#{URI.encode_www_form(query_params)}" unless query_params.empty?
+      get(path)
     end
 
     private
 
-    # returns auth token for BASIC auth
-    #
-    # @return [String] Base64 encoding of CLIENT:SECRET
-    def generate_basic_auth
-      Base64.strict_encode64("#{get_config('CLIENT_ID')}:#{get_config('CLIENT_SECRET')}")
-    end
-
     # gets a smartcar API service/client
     #
     # @return [OAuth2::AccessToken] An initialized AccessToken instance that acts as service client
     def service
-      @service ||= Faraday.new(url: SITE, request: { timeout: REQUEST_TIMEOUT })
+      @service ||= Faraday.new(url: ENV['SMARTCAR_API_ORIGIN'] || API_ORIGIN, request: { timeout: REQUEST_TIMEOUT })
     end
   end
 end

data/lib/smartcar/utils.rb

@@ -13,43 +13,104 @@ module Smartcar
       end
     end
 
-    # Utility method to return a hash of the isntance variables
-    #
-    # @return [Hash] hash of all instance variables
-    def to_hash
-      instance_variables.each_with_object({}) do |attribute, hash|
-        hash[attribute.to_s.delete('@').to_sym] = instance_variable_get(attribute)
-      end
-    end
-
     # gets a given env variable, checks for existence and throws exception if not present
     # @param config_name [String] key of the env variable
     #
     # @return [String] value of the env variable
     def get_config(config_name)
-      config_name = "INTEGRATION_#{config_name}" if ENV['MODE'] == 'test'
+      # ENV.MODE is set to test by e2e tests.
+      config_name = "E2E_#{config_name}" if ENV['MODE'] == 'test'
       raise Smartcar::ConfigNotFound, "Environment variable #{config_name} not found !" unless ENV[config_name]
 
       ENV[config_name]
     end
 
-    # Given the response from smartcar API, returns an error object if needed
+    def build_meta(headers)
+      meta_hash = {
+        'sc-data-age' => :data_age,
+        'sc-unit-system' => :unit_system,
+        'sc-request-id' => :request_id
+      }.each_with_object({}) do |(header_name, key), meta|
+        meta[key] = headers[header_name] if headers[header_name]
+      end
+      meta = JSON.parse(meta_hash.to_json, object_class: OpenStruct)
+      meta.data_age &&= DateTime.parse(meta.data_age)
+
+      meta
+    end
+
+    def build_response(body, headers)
+      response = JSON.parse(body.to_json, object_class: OpenStruct)
+      response.meta = build_meta(headers)
+      response
+    end
+
+    def build_aliases(response, aliases)
+      (aliases || []).each do |original_name, alias_name|
+        response.send("#{alias_name}=".to_sym, response.send(original_name.to_sym))
+      end
+
+      response
+    end
+
+    def build_error(status, body_string, headers)
+      content_type = headers['content-type'] || ''
+      return SmartcarError.new(status, body_string, headers) unless content_type.include?('application/json')
+
+      begin
+        parsed_body = JSON.parse(body_string, { symbolize_names: true })
+      rescue StandardError => e
+        return SmartcarError.new(
+          status,
+          {
+            message: e.message,
+            type: 'SDK_ERROR'
+          },
+          headers
+        )
+      end
+
+      return SmartcarError.new(status, parsed_body, headers) if parsed_body[:error] || parsed_body[:type]
+
+      SmartcarError.new(status, parsed_body.merge({ type: 'SDK_ERROR' }), headers)
+    end
+
+    # Given the response from smartcar API, throws an error if needed
     # @param response [Object] response Object with status and body
-    #
-    # @return [Object] nil OR Error object
-    def get_error(response)
+    def handle_error(response)
       status = response.status
       return nil if [200, 204].include?(status)
-      return Smartcar::ServiceUnavailableError.new("Service Unavailable - #{response.body}") if status == 404
-      return Smartcar::BadRequestError.new("Bad Request - #{response.body}") if status == 400
-      return Smartcar::AuthenticationError.new('Authentication error') if status == 401
 
-      Smartcar::ExternalServiceError.new("API error - #{response.body}")
+      raise build_error(response.status, response.body, response.headers)
+    end
+
+    def process_batch_response(response_body, response_headers)
+      response_object = OpenStruct.new
+      response_body['responses'].each do |item|
+        attribute_name = convert_path_to_attribute(item['path'])
+        aliases = Vehicle::METHODS[attribute_name.to_sym][:aliases]
+        # merging the top level request headers and separate headers for each item of batch
+        headers = response_headers.merge(item['headers'])
+        response = if [200, 204].include?(item['code'])
+                     build_aliases(build_response(item['body'], headers), aliases)
+                   else
+                     build_error(item['code'], item['body'].to_json, headers)
+                   end
+        response_object.define_singleton_method attribute_name do
+          raise response if response.is_a?(SmartcarError)
+
+          response
+        end
+      end
+      response_object
     end
 
-    def handle_errors(response)
-      error = get_error(response)
-      raise error if error
+    # takes a path and converts it to the keys we use.
+    # EX - '/charge' -> :charge, '/battery/capacity' -> :battery_capacity
+    def convert_path_to_attribute(path)
+      return :attributes if path == '/'
+
+      path.split('/').reject(&:empty?).join('_').to_sym
     end
   end
 end

data/lib/smartcar/vehicle.rb

@@ -8,74 +8,231 @@ module Smartcar
   #
   # @attr [String] token Access token used to connect to Smartcar API.
   # @attr [String] id Smartcar vehicle ID.
-  # @attr [String] unit_system unit system to represent the data in.
+  # @attr [Hash] options
+  # @attr unit_system [String] Unit system to represent the data in, defaults to Imperial
+  # @attr version [String] API version to be used.
   class Vehicle < Base
-    include VehicleUtils::Data
-    include VehicleUtils::Actions
-    include VehicleUtils::Batch
-    # Path for hitting compatibility end point
-    COMPATIBLITY_PATH = '/compatibility'
-
-    # Path for hitting vehicle ids end point
-    PATH = proc { |id| "/vehicles/#{id}" }
-
     attr_reader :id
 
-    def initialize(token:, id:, unit_system: IMPERIAL, version: Smartcar.get_api_version)
+    # @private
+    METHODS = {
+      permissions: { path: proc { |id| "/vehicles/#{id}/permissions" }, skip: true },
+      attributes: { path: proc { |id| "/vehicles/#{id}" } },
+      battery: {
+        path: proc { |id| "/vehicles/#{id}/battery" },
+        aliases: { 'percentRemaining' => 'percentage_remaining' }
+      },
+      battery_capacity: { path: proc { |id| "/vehicles/#{id}/battery/capacity" } },
+      charge: {
+        path: proc { |id| "/vehicles/#{id}/charge" },
+        aliases: { 'isPluggedIn' => 'is_plugged_in?' }
+      },
+      engine_oil: {
+        path: proc { |id| "/vehicles/#{id}/engine/oil" },
+        aliases: { 'lifeRemaining' => 'life_remaining' }
+      },
+      fuel: {
+        path: proc { |id| "/vehicles/#{id}/fuel" },
+        aliases: {
+          'amountRemaining' => 'amount_remaining',
+          'percentRemaining' => 'percent_remaining'
+        }
+      },
+      location: { path: proc { |id| "/vehicles/#{id}/location" } },
+      odometer: { path: proc { |id| "/vehicles/#{id}/odometer" } },
+      tire_pressure: {
+        path: proc { |id| "/vehicles/#{id}/tires/pressure" },
+        aliases: {
+          'backLeft' => 'back_left',
+          'backRight' => 'back_right',
+          'frontLeft' => 'front_left',
+          'frontRight' => 'front_right'
+        }
+      },
+      vin: { path: proc { |id| "/vehicles/#{id}/vin" } },
+      disconnect!: { type: :delete, path: proc { |id| "/vehicles/#{id}/application" } },
+      lock!: { type: :post, path: proc { |id| "/vehicles/#{id}/security" }, body: { action: 'LOCK' } },
+      unlock!: { type: :post, path: proc { |id| "/vehicles/#{id}/security" }, body: { action: 'UNLOCK' } },
+      start_charge!: { type: :post, path: proc { |id| "/vehicles/#{id}/charge" }, body: { action: 'START' } },
+      stop_charge!: { type: :post, path: proc { |id| "/vehicles/#{id}/charge" }, body: { action: 'STOP' } },
+      subscribe!: {
+        type: :post,
+        path: proc { |id, webhook_id| "/vehicles/#{id}/webhooks/#{webhook_id}" },
+        aliases: {
+          'webhookId' => 'webhook_id',
+          'vehicleId' => 'vehicle_id'
+        },
+        skip: true
+      },
+      unsubscribe!: { type: :post, path: proc { |id, webhook_id|
+                                           "/vehicles/#{id}/webhooks/#{webhook_id}"
+                                         }, skip: true }
+    }.freeze
+
+    def initialize(token:, id:, options: { unit_system: METRIC, version: Smartcar.get_api_version })
       super
-      raise InvalidParameterValue.new, "Invalid Units provided : #{unit_system}" unless UNITS.include?(unit_system)
+      @token = token
+      @id = id
+      @unit_system = options[:unit_system]
+      @version = options[:version]
+
+      raise InvalidParameterValue.new, "Invalid Units provided : #{@unit_system}" unless UNITS.include?(@unit_system)
       raise InvalidParameterValue.new, 'Vehicle ID (id) is a required field' if id.nil?
       raise InvalidParameterValue.new, 'Access Token(token) is a required field' if token.nil?
+    end
 
-      @token = token
-      @id = id
-      @unit_system = unit_system
-      @version = version
+    # @!method attributes()
+    # Returns make model year and id of the vehicle
+    #
+    # API Documentation - https://smartcar.com/api#get-vehicle-attributes
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/api#get-vehicle-attributes
+    #  and a meta attribute with the relevant items from response headers.
+
+    # @!method battery()
+    # Returns the state of charge (SOC) and remaining range of an electric or plug-in hybrid vehicle's battery.
+    #
+    # API Documentation https://smartcar.com/docs/api#get-ev-battery
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/docs/api#get-ev-battery
+    #  and a meta attribute with the relevant items from response headers.
+
+    # @!method battery_capacity()
+    # Returns the capacity of an electric or plug-in hybrid vehicle's battery.
+    #
+    # API Documentation https://smartcar.com/docs/api#get-ev-battery-capacity
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/docs/api#get-ev-battery-capacity
+    #  and a meta attribute with the relevant items from response headers.
+
+    # @!method charge()
+    # Returns the current charge status of the vehicle.
+    #
+    # API Documentation https://smartcar.com/docs/api#get-ev-battery
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/docs/api#get-ev-battery
+    #  and a meta attribute with the relevant items from response headers.
+
+    # @!method engine_oil()
+    # Returns the remaining life span of a vehicle's engine oil
+    #
+    # API Documentation https://smartcar.com/docs/api#get-engine-oil-life
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/docs/api#get-engine-oil-life
+    #  and a meta attribute with the relevant items from response headers.
+
+    # @!method fuel()
+    # Returns the status of the fuel remaining in the vehicle's gas tank.
+    #
+    # API Documentation https://smartcar.com/docs/api#get-fuel-tank
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/docs/api#get-fuel-tank
+    #  and a meta attribute with the relevant items from response headers.
+
+    # @!method location()
+    # Returns the last known location of the vehicle in geographic coordinates.
+    #
+    # API Documentation https://smartcar.com/docs/api#get-location
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/docs/api#get-location
+    #  and a meta attribute with the relevant items from response headers.
+
+    # @!method odometer()
+    # Returns the vehicle's last known odometer reading.
+    #
+    # API Documentation https://smartcar.com/docs/api#get-odometer
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/docs/api#get-odometer
+    #  and a meta attribute with the relevant items from response headers.
+
+    # @!method tire_pressure()
+    # Returns the air pressure of each of the vehicle's tires.
+    #
+    # API Documentation https://smartcar.com/docs/api#get-tire-pressure
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/docs/api#get-tire-pressure
+    #  and a meta attribute with the relevant items from response headers.
+
+    # @!method vin()
+    # Returns the vehicle's manufacturer identifier (VIN).
+    #
+    # API Documentation https://smartcar.com/docs/api#get-vin
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/docs/api#get-vin
+    #  and a meta attribute with the relevant items from response headers.
+
+    # NOTES :
+    # - We only generate the methods where there is no query string or additional options considering thats
+    #   the majority, for all the ones that require parameters, write them separately.
+    #   Ex. permissions, subscribe, unsubscribe
+    # - The following snippet generates methods dynamically , but if we are adding a new item,
+    #   make sure we also add the doc for it.
+    METHODS.each do |method, item|
+      # We add these to the METHODS object to keep it in one place, but mark them to be skipped
+      # for dynamic generation
+      next if item[:skip]
+
+      define_method method do
+        body, headers = case item[:type]
+                        when :post
+                          post(item[:path].call(id), item[:body])
+                        when :delete
+                          delete(item[:path].call(id))
+                        else
+                          fetch(path: item[:path].call(id))
+                        end
+        build_aliases(build_response(body, headers), item[:aliases])
+      end
     end
 
-    # Class method Used to get all the vehicles in the app. This only returns
-    # API - https://smartcar.com/docs/api#get-all-vehicles
-    # @param token [String] - Access token
-    # @param options [Hash] - Optional filter parameters (check documentation)
-    #
-    # @return [Array] of vehicle IDs(Strings)
-    def self.all_vehicle_ids(token:, options: {}, version: Smartcar.get_api_version)
-      response, = new(token: token, id: 'none', version: version).fetch(
-        path: PATH.call(''),
-        options: options
-      )
-      response['vehicles']
+    # Method to fetch the list of permissions that this application has been granted for this vehicle.
+    # API - https://smartcar.com/docs/api#get-application-permissions
+    #
+    # @param paging [Hash] Optional filter parameters (check documentation)
+    #
+    # @return [OpenStruct] And object representing the JSON response mentioned in https://smartcar.com/docs/api#get-application-permissions
+    #  and a meta attribute with the relevant items from response headers.
+    def permissions(paging = {})
+      response, headers = fetch(path: METHODS.dig(:permissions, :path).call(id), query_params: paging)
+      build_response(response, headers)
     end
 
-    # Class method Used to check compatiblity for VIN and scope
-    # API - https://smartcar.com/docs/api#connect-compatibility
-    # @param vin [String] VIN of the vehicle to be checked
-    # @param scope [Array of Strings] - array of scopes
-    # @param country [String] An optional country code according to
-    # [ISO 3166-1 alpha-2](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2).
-    # Defaults to US.
-    #
-    # @return [Boolean] true or false
-    def self.compatible?(vin:, scope:, country: 'US', version: Smartcar.get_api_version)
-      raise InvalidParameterValue.new, 'vin is a required field' if vin.nil?
-      raise InvalidParameterValue.new, 'scope is a required field' if scope.nil?
-
-      response, = new(token: 'none', id: 'none', version: version).fetch(
-        path: COMPATIBLITY_PATH,
-        options: {
-          vin: vin,
-          scope: scope.join(' '),
-          country: country
-        },
-        auth: BASIC
-      )
-      response['compatible']
+    # Subscribe the vehicle to given webhook Id.
+    #
+    # @param webhook_id [String] Webhook id to subscribe to
+    #
+    # @return [OpenStruct] And object representing the JSON response and a meta attribute
+    #   with the relevant items from response headers.
+    def subscribe!(webhook_id)
+      response, headers = post(METHODS.dig(:subscribe!, :path).call(id, webhook_id), {})
+      build_aliases(build_response(response, headers), METHODS.dig(:subscribe!, :aliases))
     end
 
-    private
+    # Unubscribe the vehicle from given webhook Id.
+    #
+    # @param amt [String] Application management token
+    # @param webhook_id [String] Webhook id to subscribe to
+    #
+    # @return [OpenStruct] Meta attribute with the relevant items from response headers.
+    def unsubscribe!(amt, webhook_id)
+      # swapping off the token with amt for unsubscribe.
+      access_token = token
+      self.token = amt
+      response, headers = delete(METHODS.dig(:unsubscribe!, :path).call(id, webhook_id))
+      self.token = access_token
+      build_response(response, headers)
+    end
 
-    def get_object(klass, data)
-      klass.new(data)
+    # Method to get batch requests.
+    # API - https://smartcar.com/docs/api#post-batch-request
+    # @param paths [Array] Array of paths as strings. Ex ['/battery', '/odometer']
+    #
+    # @return [OpenStruct] Object with one attribute per requested path that returns
+    #  an OpenStruct object of the requested attribute or taises if it is an error.
+    def batch(paths)
+      request_body = { requests: paths.map { |path| { path: path } } }
+      response, headers = post("/vehicles/#{id}/batch", request_body)
+      process_batch_response(response, headers)
     end
   end
 end