my_john_deere_api 2.5.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba69ef151796a688f69eba0f6a396d277baa893aa9e589922f2f2eac7b4e3a6a
-  data.tar.gz: e0539d88ae84a348113be06e9f81299b64a5c74598428e9d2a33ec00b0b49584
+  metadata.gz: b36f05ba98236dbdddfcab7086fa13c6af8d673dc8c2d2c1f185abcbf0f1ceeb
+  data.tar.gz: d5bda4fae253a293fd58b44045eacf2b7eba8dd142560aa3813da3deb334bc7c
 SHA512:
-  metadata.gz: 9a40c8720b6e44da21bb5c2d0247055cf8b4f7d04e5b6d9e5d6db03778af368e64b5d2ba375aa02aa671aebdbf3d64d87c8090beb958bb7dc83ef5b1da52196e
-  data.tar.gz: 77bac482b0518e59b534d1916b9155c2a59e75308cc71e93354c9a3d071fa10c35362ee836f3eb456b15f612b73d503f06c735d7af942d220415a39c6943c606
+  metadata.gz: 454ac16787a9448ce1fb0d5db1bc4f2b39b9c0c729552fe9c0730093d681dc442fc33b21cdbb8aea79678a1a2e1fd1bdab2ff042b931251818435cbcbd7a54e9
+  data.tar.gz: b90f4aa488daa2e0c99c31ede5045769f6d7cd04fce875d92375b369318845737fc5dbf9d9e4824b048980261e6ccc1880e8b4803a01cd9f0be4299d826cd491

data/lib/my_john_deere_api.rb

@@ -1,4 +1,4 @@
-require 'oauth'
+require 'oauth2'
 require 'uri'
 require 'json'
 

data/lib/my_john_deere_api/authorize.rb

@@ -2,10 +2,7 @@ module MyJohnDeereApi
   class Authorize
     include Helpers::EnvironmentHelper
 
-    attr_reader :api_key, :api_secret,
-      :request_token, :request_secret,
-      :access_token, :access_secret,
-      :environment, :options
+    attr_reader :api_key, :api_secret, :environment, :options, :token_hash
 
     DEFAULTS = {
       environment: :live
@@ -23,6 +20,9 @@ module MyJohnDeereApi
       @api_key = api_key
       @api_secret = api_secret
       self.environment = @options[:environment]
+
+      # This is only set upon verification
+      @token_hash = nil
     end
 
     ##
@@ -32,38 +32,47 @@ module MyJohnDeereApi
     def authorize_url
       return @authorize_url if defined?(@authorize_url)
 
-      request_options = options.slice(:oauth_callback)
+      request_options = options.slice(:redirect_uri, :state, :scope)
+
+      if options.key?(:scopes)
+        options[:scopes] << 'offline_access' unless options[:scopes].include?('offline_access')
+        request_options[:scope] = options[:scopes].join(' ')
+      end
 
-      requester = consumer.get_request_token(request_options)
-      @request_token = requester.token
-      @request_secret = requester.secret
+      # generate a default unique-ish "state" key if not provided
+      unless request_options.key?(:state)
+        request_options[:state] = (rand(8000) + 1000).to_s
+      end
 
-      @authorize_url = requester.authorize_url(request_options)
+      @authorize_url = oauth_client.auth_code.authorize_url(request_options)
     end
 
     ##
-    # API consumer that makes non-user-specific GET requests
+    # API client that makes authentication requests
 
-    def consumer
-      return @consumer if defined?(@consumer)
-      @consumer = MyJohnDeereApi::Consumer.new(@api_key, @api_secret, environment: environment).app_get
+    def oauth_client
+      return @oauth_client if defined?(@oauth_client)
+      @oauth_client = MyJohnDeereApi::Consumer.new(@api_key, @api_secret, environment: environment).auth_client
     end
 
     ##
-    # Turn a verification code into access tokens. If this is
-    # run from a separate process than the one that created
-    # the initial RequestToken, the request token/secret
-    # can be passed in.
-
-    def verify(code, token=nil, secret=nil)
-      token ||= request_token
-      secret ||= request_secret
-
-      requester = OAuth::RequestToken.new(consumer, token, secret)
-      access_object = requester.get_access_token(oauth_verifier: code)
-      @access_token = access_object.token
-      @access_secret = access_object.secret
-      nil
+    # Turn a verification code into access token.
+
+    def verify(code)
+      token = oauth_client.auth_code.get_token(code, redirect_uri: options[:redirect_uri])
+
+      # normalize hash
+      @token_hash = JSON.parse(token.to_hash.to_json)
+    end
+
+    ##
+    # Use an old token hash to generate a new token hash.
+
+    def refresh_from_hash(old_token_hash)
+      old_token = OAuth2::AccessToken.from_hash(oauth_client, old_token_hash)
+      new_token = old_token.refresh!
+
+      new_token.to_hash
     end
   end
 end

data/lib/my_john_deere_api/client.rb

@@ -4,7 +4,7 @@ module MyJohnDeereApi
     include Helpers::CaseConversion
 
     attr_accessor :contribution_definition_id
-    attr_reader :api_key, :api_secret, :access_token, :access_secret, :http_retry_options
+    attr_reader :api_key, :api_secret, :token_hash, :http_retry_options
 
     DEFAULTS = {
       environment: :live,
@@ -13,18 +13,17 @@ module MyJohnDeereApi
 
     ##
     # Creates the client with everything it needs to perform API requests.
-    # User-specific credentials are optional, but user-specific API
-    # requests are only possible if they are supplied.
+    # User-specific token_hash is optional, but user-specific API
+    # requests are only possible if it is supplied.
     #
     # options:
     #
     # [:environment] :sandbox or :live
     #
     # [:contribution_definition_id] optional, but needed for some requests
-    #                               like asset create/update.
+    #                               like asset create/update
     #
-    # [:access] an array with two elements, the access_token
-    #           and the access_secret of the given user
+    # [:token_hash] a hash used to re-create the access token
 
     def initialize(api_key, api_secret, options = {})
       options = DEFAULTS.merge(options)
@@ -32,8 +31,8 @@ module MyJohnDeereApi
       @api_key = api_key
       @api_secret = api_secret
 
-      if options.has_key?(:access) && options[:access].is_a?(Array)
-        @access_token, @access_secret = options[:access]
+      if options.has_key?(:token_hash) && options[:token_hash].is_a?(Hash)
+        @token_hash = options[:token_hash]
       end
 
       self.environment = options[:environment]
@@ -49,22 +48,38 @@ module MyJohnDeereApi
       return @accessor if defined?(@accessor)
 
       @accessor = NetHttpRetry::Decorator.new(
-        OAuth::AccessToken.new(
-          consumer.user_get,
-          access_token,
-          access_secret
-        ),
+        OAuth2::AccessToken.from_hash(oauth_client, token_hash),
         http_retry_options
       )
     end
 
+    ##
+    # Returns the URI for the Contribution Definiton ID, if provided
+
+    def contribution_definition_uri
+      return @contribution_definition_uri if defined?(@contribution_definition_uri)
+
+      @contribution_definition_uri =
+        if contribution_definition_id
+          "#{site}/contributionDefinitions/#{contribution_definition_id}"
+        else
+          nil
+        end
+    end
+
+    ##
+    # Returns the base url for requests
+
+    def site
+      return @site if defined?(@site)
+      @site = accessor.client.site
+    end
+
     ##
     # generic user-specific GET request method that returns JSON
 
     def get resource
-      resource = resource.to_s
-      resource = "/#{resource}" unless resource =~ /^\//
-      response = accessor.get(resource, headers)
+      response = accessor.get(resource, headers: headers)
 
       JSON.parse(response.body)
     end
@@ -73,9 +88,7 @@ module MyJohnDeereApi
     # generic user-specific POST request method that returns JSON or response
 
     def post resource, body
-      resource = resource.to_s
-      resource = "/#{resource}" unless resource =~ /^\//
-      response = accessor.post(resource, camelize(body).to_json, post_headers)
+      response = accessor.post(resource, body: camelize(body).to_json, headers: post_headers)
 
       if response.body && response.body.size > 0
         JSON.parse(response.body)
@@ -88,9 +101,7 @@ module MyJohnDeereApi
     # generic user-specific PUT request method that returns JSON or response
 
     def put resource, body
-      resource = resource.to_s
-      resource = "/#{resource}" unless resource =~ /^\//
-      response = accessor.put(resource, camelize(body).to_json, post_headers)
+      response = accessor.put(resource, body: camelize(body).to_json, headers: post_headers)
 
       if response.body && response.body.size > 0
         JSON.parse(response.body)
@@ -103,9 +114,7 @@ module MyJohnDeereApi
     # generic user-specific DELETE request method that returns JSON or response
 
     def delete resource
-      resource = resource.to_s
-      resource = "/#{resource}" unless resource =~ /^\//
-      response = accessor.delete(resource, headers)
+      response = accessor.delete(resource, headers: headers)
 
       if response.body && response.body.size > 0
         JSON.parse(response.body)
@@ -133,11 +142,11 @@ module MyJohnDeereApi
     private
 
     ##
-    # Returns an oAuth consumer which can be used to build requests
+    # Returns an oAuth client which can be used to build requests
 
-    def consumer
-      return @consumer if defined?(@consumer)
-      @consumer = MyJohnDeereApi::Consumer.new(@api_key, @api_secret, environment: environment)
+    def oauth_client
+      return @oauth_client if defined?(@oauth_client)
+      @oauth_client = MyJohnDeereApi::Consumer.new(@api_key, @api_secret, environment: environment).platform_client
     end
 
     def headers

data/lib/my_john_deere_api/consumer.rb

@@ -3,12 +3,12 @@ module MyJohnDeereApi
     include Helpers::CaseConversion
     include Helpers::EnvironmentHelper
 
-    attr_reader :api_key, :api_secret, :environment, :base_url
+    attr_reader :api_key, :api_secret, :environment, :site
 
     # valid API urls
     URLS = {
       sandbox: 'https://sandboxapi.deere.com',
-      live: 'https://api.soa-proxy.deere.com',
+      live: 'https://partnerapi.deere.com',
     }
 
     DEFAULTS = {
@@ -22,65 +22,76 @@ module MyJohnDeereApi
       @api_secret = api_secret
 
       self.environment = options[:environment]
-      @base_url = options[:base_url] || URLS[@environment]
+      @site = options[:site] || URLS[@environment]
     end
 
     ##
-    # oAuth Consumer which uses just the base url, for
-    # app-wide, non user-specific GET requests.
+    # oAuth client for platform requests
 
-    def app_get
-      @app_get ||= consumer(base_url)
+    def platform_client
+      return @platform_client if defined?(@platform_client)
+
+      @platform_client = OAuth2::Client.new(
+        api_key,
+        api_secret,
+        site: site,
+        headers: headers,
+        raise_errors: false,
+      )
     end
 
     ##
-    # oAuth Consumer which uses the proper url for user-specific GET requests.
+    # oAuth client for user authentication
 
-    def user_get
-      @user_get ||= consumer("#{base_url}/platform")
-    end
+    def auth_client
+      return @auth_client if defined?(@auth_client)
 
-    private
+      # We build this without the `client` method because the authorization links
+      # require an extra API call to JD that is only needed for authorization.
 
-    def consumer(site)
-      OAuth::Consumer.new(
+      @auth_client = OAuth2::Client.new(
         api_key,
         api_secret,
         site: site,
-        header: header,
-        http_method: :get,
-        request_token_url: links[:request_token],
-        access_token_url: links[:access_token],
-        authorize_url: links[:authorize_request_token]
+        authorize_url: authorization_links[:authorization],
+        token_url: authorization_links[:token],
+        raise_errors: false,
       )
     end
 
-    def links
-      return @links if defined?(@links)
+    private
+
+    def authorization
+      return @authorization if defined?(@authorization)
 
-      catalog = OAuth::Consumer.new(api_key, api_secret)
+      json = OAuth2::Client.new(api_key, api_secret)
         .request(
           :get,
-          "#{base_url}/platform/",
-          nil,
-          {},
-          header
+          'https://signin.johndeere.com/oauth2/aus78tnlaysMraFhC1t7/.well-known/oauth-authorization-server',
+          headers: headers,
+          raise_errors: false,
         ).body
 
-        @links = {}
+      @authorization = JSON.parse(json)
+    end
 
-        JSON.parse(catalog)['links'].each do |link|
-          uri = URI.parse(link['uri'])
-          uri.query = nil
+    def authorization_links
+      return @authorization_links if defined?(@authorization_links)
 
-          @links[keyify(link['rel'])] = uri.to_s
-        end
+      @authorization_links = {
+        authorization: authorization['authorization_endpoint'],
+        token: authorization['token_endpoint'],
+        organizations: "https://connections.deere.com/connections/#{api_key}/select-organizations",
+      }
+    end
 
-        @links
+    def scopes
+      return @scopes if defined?(@scopes)
+      @scopes = authorization['scopes_supported']
     end
 
-    def header
-      @header ||= {accept: 'application/vnd.deere.axiom.v3+json'}
+    def headers
+      @headers ||= {accept: 'application/vnd.deere.axiom.v3+json'}
     end
 
     def keyify key_name

data/lib/my_john_deere_api/helpers/case_conversion.rb

@@ -22,7 +22,8 @@ module MyJohnDeereApi::Helpers::CaseConversion
   def camelize(something)
     something = something.to_s if something.is_a?(Symbol)
 
-    if something.is_a?(String)
+    case something
+    when String
       list = something.strip.split(/[_\s]+/)
 
       # preserve case of the first element
@@ -30,8 +31,10 @@ module MyJohnDeereApi::Helpers::CaseConversion
       new_list += list.map(&:capitalize)
 
       new_list.join('')
-    elsif something.is_a?(Hash)
+    when Hash
       something.transform_keys{ |key| camelize(key) }
+    when Array
+      something.map{|element| camelize(element)}
     end
   end
 end

data/lib/my_john_deere_api/helpers/uri_helpers.rb

@@ -6,7 +6,7 @@ module MyJohnDeereApi::Helpers::UriHelpers
   ##
   # extract just the path from the uri, excluding the platform prefix
   def uri_path(uri)
-    URI.parse(uri).path.gsub(/^\/platform/, '')
+    URI.parse(uri).path
   end
 
   ##

data/lib/my_john_deere_api/model/contribution_definition.rb

@@ -5,7 +5,7 @@ module MyJohnDeereApi
     private
 
     def map_attributes(record)
-      @name     = record['name']
+      @name = record['name']
     end
 
     def expected_record_type

data/lib/my_john_deere_api/net_http_retry/decorator.rb

@@ -7,41 +7,40 @@ module MyJohnDeereApi
         request_methods:      [:get, :post, :put, :delete],
         retry_delay_exponent: 2,
         max_retries: 12,
-        retry_codes: ['429', '503'],
-        valid_codes: ['200', '201', '204'],
+        retry_codes: [429, 503],
+        valid_codes: [200, 201, 204],
       }
 
       def initialize(object, options={})
         @object = object
 
-        # defaults that can be used as-is
-        [:request_methods, :retry_delay_exponent, :max_retries].each do |option|
+        # options that can be used as-is
+        [:request_methods, :retry_delay_exponent, :max_retries, :retry_codes, :valid_codes].each do |option|
           instance_variable_set(:"@#{option}", options[option] || DEFAULTS[option])
         end
 
-        # defaults that require casting as string arrays
+        # options that require casting as integer arrays
         [:retry_codes, :valid_codes].each do |option|
-          instance_variable_set(:"@#{option}", (options[option] || DEFAULTS[option]).map(&:to_s))
+          instance_variable_set(:"@#{option}", (options[option] || DEFAULTS[option]).map(&:to_i))
         end
       end
 
       def request(method_name, *args)
         retries = 0
         result = object.send(method_name, *args)
-
-        while retry_codes.include?(result.code)
+        while retry_codes.include?(result.status)
           if retries >= max_retries
-            raise MaxRetriesExceededError.new(method_name, "#{result.code} #{result.message}")
+            raise MaxRetriesExceededError.new(method_name, "#{result.status} #{result.response.reason_phrase}")
           end
 
-          delay = [result['retry-after'].to_i, retry_delay_exponent ** retries].max
+          delay = [result.headers['retry-after'].to_i, retry_delay_exponent ** retries].max
           sleep(delay)
 
           result = object.send(method_name, *args)
           retries += 1
         end
 
-        unless valid_codes.include?(result.code)
+        unless valid_codes.include?(result.status)
           raise InvalidResponseError.new(result)
         end