smartcar 2.1.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

@@ -1,74 +1,66 @@
+# frozen_string_literal: true
+
 require 'oauth2'
 require 'base64'
 module Smartcar
   # The Base class for all of the other class.
   # Let other classes inherit from here and put common methods here.
   class Base
-    include Utils
+    include Smartcar::Utils
 
     # Error raised when an invalid parameter is passed.
     class InvalidParameterValue < StandardError; end
-    # Constant for Bearer auth type
-    BEARER = 'BEARER'.freeze
     # Constant for Basic auth type
-    BASIC = 'BASIC'.freeze
+    BASIC = 'Basic'
     # Number of seconds to wait for response
     REQUEST_TIMEOUT = 310
 
-    attr_accessor :token, :error, :meta
+    attr_accessor :token, :error, :unit_system, :version, :auth_type
 
-    %i{get post patch put delete}.each do |verb|
+    %i[get post patch put delete].each do |verb|
       # meta programming and define all Restful methods.
       # @param path [String] the path to hit for the request.
       # @param data [Hash] request body if needed.
       #
       # @return [Hash] The response Json parsed as a hash.
-      define_method verb do |path, data=nil|
+      define_method verb do |path, data = nil|
         response = service.send(verb) do |request|
-          request.headers['Authorization'] = "BEARER #{token}"
-          request.headers['Authorization'] = "BASIC #{get_basic_auth}" if data[:auth] == BASIC
-          request.headers['sc-unit-system'] = unit_system
-          request.headers['Content-Type'] = "application/json"
-          complete_path = "/#{API_VERSION}#{path}"
-          if verb==:get
+          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}"
+          if verb == :get
             request.url complete_path, data
           else
             request.url complete_path
             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 = path
-      _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 get_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

@@ -1,44 +1,116 @@
+# frozen_string_literal: true
+
+module Smartcar
   # Utils module , provides utility methods to underlying classes
   module Utils
-  # A constructor to take a hash and assign it to the instance variables
-  # @param options = {} [Hash] Could by any class's hash, but the first level keys should be defined in the class
-  #
-  # @return [Subclass os Base] Returns object of any subclass like Report
-  def initialize(options = {})
-    options.each do |attribute, value|
-      instance_variable_set("@#{attribute}", value)
+    # A constructor to take a hash and assign it to the instance variables
+    # @param options = {} [Hash] Could by any class's hash, but the first level keys should be defined in the class
+    #
+    # @return [Subclass os Base] Returns object of any subclass like Report
+    def initialize(options = {})
+      options.each do |attribute, value|
+        instance_variable_set("@#{attribute}", value)
+      end
     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)
+    # 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)
+      # 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
-  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'
-    raise Smartcar::ConfigNotFound, "Environment variable #{config_name} not found !" unless ENV[config_name]
-    ENV[config_name]
-  end
+    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')
 
-  # Given the response from smartcar API, returns an error object if needed
-  # @param response [Object] response Object with status and body
-  #
-  # @return [Object] nil OR Error object
-  def get_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
-    return Smartcar::ExternalServiceError.new("API error - #{response.body}")
+      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
+    def handle_error(response)
+      status = response.status
+      return nil if [200, 204].include?(status)
+
+      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
+
+    # 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

@@ -1,307 +1,238 @@
+# frozen_string_literal: true
+
 module Smartcar
   # Vehicle class to connect to vehicle basic info,disconnect, lock unlock and get all vehicles API
   # For ease of use, this also has methods define to be able to call other resources on a vehicle object
   # For Ex. Vehicle object will be treate as an entity and doing vehicle_object.
   # Battery should return Battery object.
   #
-  #@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 [String] token Access token used to connect to Smartcar API.
+  # @attr [String] id Smartcar vehicle ID.
+  # @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 Utils
-
-
-    # Path for hitting compatibility end point
-    COMPATIBLITY_PATH = '/compatibility'.freeze
-
-    # Path for hitting vehicle ids end point
-    PATH = Proc.new{|id| "/vehicles/#{id}"}
-
     attr_reader :id
-    attr_accessor :token, :unit_system
 
-    def initialize(token:, id:, unit_system: IMPERIAL)
-      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?
+    # @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
       @token = token
       @id = id
-      @unit_system = unit_system
-    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: {})
-      response, meta = new(token: token, id: 'none').fetch(
-        path: PATH.call(''),
-        options: options
-      )
-      response['vehicles']
-    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')
-      raise InvalidParameterValue.new, "vin is a required field" if vin.nil?
-      raise InvalidParameterValue.new, "scope is a required field" if scope.nil?
-
-      response, meta = new(token: 'none', id: 'none').fetch(path: COMPATIBLITY_PATH,
-        options: {
-          vin: vin,
-          scope: scope.join(' '),
-          country: country
-        },
-        auth: BASIC
-      )
-      response['compatible']
-    end
+      @unit_system = options[:unit_system]
+      @version = options[:version]
 
-    # Method to get batch requests
-    # API - https://smartcar.com/docs/api#post-batch-request
-    # @param attributes [Array] Array of strings or symbols of attributes to be fetched together
-    #
-    # @return [Hash] Hash wth key as requested attribute(symbol) and value as Error OR Object of the requested attribute
-    def batch(attributes = [])
-      raise InvalidParameterValue.new, "vin is a required field" if attributes.nil?
-      request_body = get_batch_request_body(attributes)
-      response, _meta = post(PATH.call(id) + "/batch", request_body)
-      process_batch_response(response)
+      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
 
-    # Fetch the list of permissions that this application has been granted for
-    # this vehicle
-    # EX : Smartcar::Vehicle.new(token: token, id: id).permissions
-    # @param options [Hash] - Optional filter parameters (check documentation)
-    #
-    # @return [Permissions] object
-    def permissions(options: {})
-      get_attribute(Permissions)
-    end
-
-    #  Method Used toRevoke access for the current requesting application
-    # API - https://smartcar.com/docs/api#delete-disconnect
-    #
-    # @return [Boolean] true if success
-    def disconnect!
-      response = delete(PATH.call(id) + "/application")
-      response['status'] == SUCCESS
-    end
-
-    # Methods Used to lock car
-    # API - https://smartcar.com/docs/api#post-security
-    #
-    # @return [Boolean] true if success
-    def lock!
-      lock_or_unlock!(action: Smartcar::LOCK)
-    end
-
-    # Methods Used to unlock car
-    # API - https://smartcar.com/docs/api#post-security
-    #
-    # @return [Boolean] true if success
-    def unlock!
-      lock_or_unlock!(action: Smartcar::UNLOCK)
-    end
-
-    # Method used to start charging a car
+    # @!method attributes()
+    # Returns make model year and id of the vehicle
     #
+    # API Documentation - https://smartcar.com/api#get-vehicle-attributes
     #
-    # @return [Boolean] true if success
-    def start_charge!
-      start_or_stop_charge!(action: Smartcar::START_CHARGE)
-    end
+    # @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 used to stop charging a car
+    # @!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 [Boolean] true if success
-    def stop_charge!
-      start_or_stop_charge!(action: Smartcar::STOP_CHARGE)
-    end
+    # @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.
 
-    # Returns make model year and id of the vehicle
-    # API - https://smartcar.com/api#get-vehicle-attributes
+    # @!method battery_capacity()
+    # Returns the capacity of an electric or plug-in hybrid vehicle's battery.
     #
-    # @return [VehicleAttributes] object
-    def vehicle_attributes
-      get_attribute(VehicleAttributes)
-    end
-
-    # Returns the state of charge (SOC) and remaining range of an electric or
-    # plug-in hybrid vehicle's battery.
-    # API - https://smartcar.com/docs/api#get-ev-battery
-    #
-    # @return [Battery] object
-    def battery
-      get_attribute(Battery)
-    end
-
-    # Returns the capacity of an electric or
-    # plug-in hybrid vehicle's battery.
-    # API - https://smartcar.com/docs/api#get-ev-battery-capacity
+    # API Documentation https://smartcar.com/docs/api#get-ev-battery-capacity
     #
-    # @return [Battery] object
-    def battery_capacity
-      get_attribute(BatteryCapacity)
-    end
+    # @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 - https://smartcar.com/docs/api#get-ev-battery
     #
-    # @return [Charge] object
-    def charge
-      get_attribute(Charge)
-    end
+    # 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 - https://smartcar.com/docs/api#get-engine-oil-life
     #
-    # @return [EngineOil] object
-    def engine_oil
-      get_attribute(EngineOil)
-    end
+    # 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 - https://smartcar.com/docs/api#get-fuel-tank
     #
-    # @return [Fuel] object
-    def fuel
-      get_attribute(Fuel)
-    end
+    # 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 - https://smartcar.com/docs/api#get-location
     #
-    # @return [Location] object
-    def location
-      get_attribute(Location)
-    end
+    # 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 - https://smartcar.com/docs/api#get-odometer
     #
-    # @return [Odometer] object
-    def odometer
-      get_attribute(Odometer)
-    end
+    # 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 - https://smartcar.com/docs/api#get-tire-pressure
     #
-    # @return [TirePressure] object
-    def tire_pressure
-      get_attribute(TirePressure)
-    end
+    # 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 - https://smartcar.com/docs/api#get-vin
     #
-    # @return [String] Vin of the vehicle.
-    def vin
-      _object = get_attribute(Vin)
-      @vin ||= _object.vin
-    end
-
-    private
-
-    def allowed_attributes
-      @allowed_attributes ||= {
-        battery: get_path(Battery),
-        charge: get_path(Charge),
-        engine_oil: get_path(EngineOil),
-        fuel: get_path(Fuel),
-        location: get_path(Location),
-        odometer: get_path(Odometer),
-        permissions: get_path(Permissions),
-        tire_pressure: get_path(TirePressure),
-        vin: get_path(Vin),
-      }
-    end
-
-    def path_to_class
-      @path_to_class ||= {
-        get_path(Battery) => Battery,
-        get_path(Charge) => Charge,
-        get_path(EngineOil) => EngineOil,
-        get_path(Fuel) => Fuel,
-        get_path(Location) => Location,
-        get_path(Odometer) => Odometer,
-        get_path(Permissions) => Permissions,
-        get_path(TirePressure) => TirePressure,
-        get_path(Vin) => Vin,
-      }
-    end
-
-    # @private
-    BatchItemResponse = Struct.new(:body, :status, :headers) do
-      def body_with_meta
-        body.merge(meta: headers)
-      end
-    end
-
-    def get_batch_request_body(attributes)
-      attributes = validated_attributes(attributes)
-      requests = attributes.each_with_object([]) do |item, requests|
-        requests << { path: allowed_attributes[item] }
-      end
-      { requests: requests }
-    end
-
-    def process_batch_response(responses)
-      inverted_map = allowed_attributes.invert
-      responses["responses"].each_with_object({}) do |response, result|
-        item_response = BatchItemResponse.new(response["body"], response["code"], response["headers"])
-        error = get_error(item_response)
-        path = response["path"]
-        result[inverted_map[path]] = error || get_object(path_to_class[path], item_response.body_with_meta)
-      end
-    end
-
-    def validated_attributes(attributes)
-      attributes.map!(&:to_sym)
-      unsupported_attributes = (attributes - allowed_attributes.keys) || []
-      unless unsupported_attributes.empty?
-        message = "Unsupported attribute(s) requested in batch  - #{unsupported_attributes.join(',')}"
-        raise InvalidParameterValue.new, message
+    # 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
-      attributes
     end
 
-    def get_attribute(klass)
-      body, meta =  fetch(
-        path: klass::PATH.call(id)
-      )
-      get_object(klass, body.merge(meta: meta))
-    end
-
-    def get_object(klass, data)
-      klass.new(data)
+    # 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
 
-    def get_path(klass)
-      path = klass::PATH.call(id)
-      path.split("/vehicles/#{id}").last
+    # 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
 
-    def lock_or_unlock!(action:)
-      response, meta = post(PATH.call(id) + "/security", { action: action })
-      response['status'] == SUCCESS
+    # 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 start_or_stop_charge!(action:)
-      response, meta = post(PATH.call(id) + "/charge", { action: action })
-      response['status'] == SUCCESS
+    # 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