my_john_deere_api 2.3.5 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d94f50a7c306efa861fb855b0c8a90d1b070c8ad230e05fc0ba298118b5d91c4
-  data.tar.gz: f105e3d4c42cc755db700ce5ceeaecd2a9edf2292b8ddb4ff4e559913a68fd89
+  metadata.gz: b36f05ba98236dbdddfcab7086fa13c6af8d673dc8c2d2c1f185abcbf0f1ceeb
+  data.tar.gz: d5bda4fae253a293fd58b44045eacf2b7eba8dd142560aa3813da3deb334bc7c
 SHA512:
-  metadata.gz: d35cdcecd45fef14e1e78f454846a115c29b2c8e20543407540ca5ebd44f82e76a796e01b14fe4c02b70a725b9fad726d97d06f938dd6f00da5dcd5a779d5fe3
-  data.tar.gz: 8b33a28e57f5e0d08bc71d975be12e7c0fc71fa596a1cceb4b2fe611c31d3a1422ac2d2b7e314a6f6bc692ef5c2a268dbb8c00158daa9eff37893cc4e24233a0
+  metadata.gz: 454ac16787a9448ce1fb0d5db1bc4f2b39b9c0c729552fe9c0730093d681dc442fc33b21cdbb8aea79678a1a2e1fd1bdab2ff042b931251818435cbcbd7a54e9
+  data.tar.gz: b90f4aa488daa2e0c99c31ede5045769f6d7cd04fce875d92375b369318845737fc5dbf9d9e4824b048980261e6ccc1880e8b4803a01cd9f0be4299d826cd491

data/README.md

@@ -600,13 +600,74 @@ field.archived?
 # => false
 
 field.links
-# => a hash of API urls related to this asset
+# => a hash of API urls related to this field
 
 field.flags
 # => collection of flags belonging to this field
 ```
 
 
+### [Flags](https://developer.deere.com/#!documentation&doc=.%2Fmyjohndeere%2Fflags.htm)
+
+Handles a field's flags. Flag collections support the following methods. Note, John Deere does not provide an endpoint to retrieve a specific flag by id:
+
+* all
+* count
+* first
+
+An individual flag supports the following methods and associations:
+
+* id
+* notes
+* geometry
+* archived?
+* proximity\_alert\_enabled?
+* links
+
+The `count` method only requires loading the first page of results, so it's a relatively cheap call. On the other hand,
+`all` forces the entire collection to be loaded from John Deere's API, so use with caution. Flags can be
+created via the API, but there is no `create` method on this collection yet.
+
+```ruby
+field.flags
+# => collection of flags under this field
+
+field.flags.count
+# => 15
+
+flag = field.flags.first
+# => an individual flag object
+
+flag.notes
+# => 'A big rock on the left after entering the field'
+
+flag.geometry
+# =>  a GeoJSON formatted hash, for example:
+#     {
+#       "type"=>"Feature",
+#       "geometry"=>{
+#         "geometries"=>[
+#             {
+#               "coordinates"=>[-95.123456, 40.123456], 
+#               "type"=>"Point"
+#             }
+#           ],
+#         "type"=>"GeometryCollection"
+#       }
+#     }
+
+
+field.archived?
+# => false
+
+field.proximity_alert_enabled?
+# => true
+
+field.links
+# => a hash of API urls related to this flag
+```
+
+
 ## Direct API Requests
 
 While the goal of the client is to eliminate the need to make/interpret calls to the John Deere API, it's important

data/lib/my_john_deere_api.rb

@@ -1,4 +1,4 @@
-require 'oauth'
+require 'oauth2'
 require 'uri'
 require 'json'
 
@@ -13,4 +13,5 @@ module MyJohnDeereApi
   autoload :Validators,     'my_john_deere_api/validators'
 
   require 'my_john_deere_api/errors'
+  require 'my_john_deere_api/net_http_retry'
 end

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,26 +4,26 @@ module MyJohnDeereApi
     include Helpers::CaseConversion
 
     attr_accessor :contribution_definition_id
-    attr_reader :api_key, :api_secret, :access_token, :access_secret
+    attr_reader :api_key, :api_secret, :token_hash, :http_retry_options
 
     DEFAULTS = {
-      environment: :live
+      environment: :live,
+      http_retry: {}
     }
 
     ##
     # 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)
@@ -31,12 +31,13 @@ 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]
       @contribution_definition_id = options[:contribution_definition_id]
+      @http_retry_options = options[:http_retry]
     end
 
     ##
@@ -45,16 +46,40 @@ module MyJohnDeereApi
 
     def accessor
       return @accessor if defined?(@accessor)
-      @accessor = OAuth::AccessToken.new(consumer.user_get, access_token, access_secret)
+
+      @accessor = NetHttpRetry::Decorator.new(
+        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
@@ -63,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)
@@ -78,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)
@@ -93,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)
@@ -123,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