my_john_deere_api 2.4.1

data/Rakefile

@@ -0,0 +1,9 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/my_john_deere_api.rb

@@ -0,0 +1,17 @@
+require 'oauth'
+require 'uri'
+require 'json'
+
+module MyJohnDeereApi
+  autoload :VERSION,        'my_john_deere_api/version'
+  autoload :Authorize,      'my_john_deere_api/authorize'
+  autoload :Client,         'my_john_deere_api/client'
+  autoload :Consumer,       'my_john_deere_api/consumer'
+  autoload :Request,        'my_john_deere_api/request'
+  autoload :Model,          'my_john_deere_api/model'
+  autoload :Helpers,        'my_john_deere_api/helpers'
+  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

@@ -0,0 +1,69 @@
+module MyJohnDeereApi
+  class Authorize
+    include Helpers::EnvironmentHelper
+
+    attr_reader :api_key, :api_secret,
+      :request_token, :request_secret,
+      :access_token, :access_secret,
+      :environment, :options
+
+    DEFAULTS = {
+      environment: :live
+    }
+
+    ##
+    # Create an Authorize object.
+    #
+    # This is used to obtain authentication an access key/secret
+    # on behalf of a user.
+
+    def initialize(api_key, api_secret, options = {})
+      @options = DEFAULTS.merge(options)
+
+      @api_key = api_key
+      @api_secret = api_secret
+      self.environment = @options[:environment]
+    end
+
+    ##
+    # Url which may be used to obtain a verification
+    # code from the oauth server.
+
+    def authorize_url
+      return @authorize_url if defined?(@authorize_url)
+
+      request_options = options.slice(:oauth_callback)
+
+      requester = consumer.get_request_token(request_options)
+      @request_token = requester.token
+      @request_secret = requester.secret
+
+      @authorize_url = requester.authorize_url(request_options)
+    end
+
+    ##
+    # API consumer that makes non-user-specific GET requests
+
+    def consumer
+      return @consumer if defined?(@consumer)
+      @consumer = MyJohnDeereApi::Consumer.new(@api_key, @api_secret, environment: environment).app_get
+    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
+    end
+  end
+end

data/lib/my_john_deere_api/client.rb

@@ -0,0 +1,151 @@
+module MyJohnDeereApi
+  class Client
+    include Helpers::EnvironmentHelper
+    include Helpers::CaseConversion
+
+    attr_accessor :contribution_definition_id
+    attr_reader :api_key, :api_secret, :access_token, :access_secret, :http_retry_options
+
+    DEFAULTS = {
+      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.
+    #
+    # options:
+    #
+    # [:environment] :sandbox or :live
+    #
+    # [:contribution_definition_id] optional, but needed for some requests
+    #                               like asset create/update.
+    #
+    # [:access] an array with two elements, the access_token
+    #           and the access_secret of the given user
+
+    def initialize(api_key, api_secret, options = {})
+      options = DEFAULTS.merge(options)
+
+      @api_key = api_key
+      @api_secret = api_secret
+
+      if options.has_key?(:access) && options[:access].is_a?(Array)
+        @access_token, @access_secret = options[:access]
+      end
+
+      self.environment = options[:environment]
+      @contribution_definition_id = options[:contribution_definition_id]
+      @http_retry_options = options[:http_retry]
+    end
+
+    ##
+    # Returns an oAuth AccessToken object which can be used to make
+    # user-specific API requests
+
+    def accessor
+      return @accessor if defined?(@accessor)
+
+      @accessor = NetHttpRetry::Decorator.new(
+        OAuth::AccessToken.new(
+          consumer.user_get,
+          access_token,
+          access_secret
+        ),
+        http_retry_options
+      )
+    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)
+
+      JSON.parse(response.body)
+    end
+
+    ##
+    # 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)
+
+      if response.body && response.body.size > 0
+        JSON.parse(response.body)
+      else
+        response
+      end
+    end
+
+    ##
+    # 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)
+
+      if response.body && response.body.size > 0
+        JSON.parse(response.body)
+      else
+        response
+      end
+    end
+
+    ##
+    # 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)
+
+      if response.body && response.body.size > 0
+        JSON.parse(response.body)
+      else
+        response
+      end
+    end
+
+    ##
+    # organizations associated with this access
+
+    def organizations
+      return @organizations if defined?(@organizations)
+      @organizations = MyJohnDeereApi::Request::Collection::Organizations.new(self)
+    end
+
+    ##
+    # contribution products associated with this app (not user-specific)
+
+    def contribution_products
+      return @contribution_products if defined?(@contribution_products)
+      @contribution_products = MyJohnDeereApi::Request::Collection::ContributionProducts.new(self)
+    end
+
+    private
+
+    ##
+    # Returns an oAuth consumer which can be used to build requests
+
+    def consumer
+      return @consumer if defined?(@consumer)
+      @consumer = MyJohnDeereApi::Consumer.new(@api_key, @api_secret, environment: environment)
+    end
+
+    def headers
+      @headers ||= {accept: 'application/vnd.deere.axiom.v3+json'}
+    end
+
+    def post_headers
+      @post_headers ||= headers.merge({'Content-Type' => 'application/vnd.deere.axiom.v3+json'})
+    end
+  end
+end

data/lib/my_john_deere_api/consumer.rb

@@ -0,0 +1,90 @@
+module MyJohnDeereApi
+  class Consumer
+    include Helpers::CaseConversion
+    include Helpers::EnvironmentHelper
+
+    attr_reader :api_key, :api_secret, :environment, :base_url
+
+    # valid API urls
+    URLS = {
+      sandbox: 'https://sandboxapi.deere.com',
+      live: 'https://api.soa-proxy.deere.com',
+    }
+
+    DEFAULTS = {
+      environment: :live
+    }
+
+    def initialize(api_key, api_secret, options={})
+      options = DEFAULTS.merge(options)
+
+      @api_key = api_key
+      @api_secret = api_secret
+
+      self.environment = options[:environment]
+      @base_url = options[:base_url] || URLS[@environment]
+    end
+
+    ##
+    # oAuth Consumer which uses just the base url, for
+    # app-wide, non user-specific GET requests.
+
+    def app_get
+      @app_get ||= consumer(base_url)
+    end
+
+    ##
+    # oAuth Consumer which uses the proper url for user-specific GET requests.
+
+    def user_get
+      @user_get ||= consumer("#{base_url}/platform")
+    end
+
+    private
+
+    def consumer(site)
+      OAuth::Consumer.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]
+      )
+    end
+
+    def links
+      return @links if defined?(@links)
+
+      catalog = OAuth::Consumer.new(api_key, api_secret)
+        .request(
+          :get,
+          "#{base_url}/platform/",
+          nil,
+          {},
+          header
+        ).body
+
+        @links = {}
+
+        JSON.parse(catalog)['links'].each do |link|
+          uri = URI.parse(link['uri'])
+          uri.query = nil
+
+          @links[keyify(link['rel'])] = uri.to_s
+        end
+
+        @links
+    end
+
+    def header
+      @header ||= {accept: 'application/vnd.deere.axiom.v3+json'}
+    end
+
+    def keyify key_name
+      underscore(key_name.gsub(/^oauth/, '')).to_sym
+    end
+  end
+end

data/lib/my_john_deere_api/errors.rb

@@ -0,0 +1,7 @@
+module MyJohnDeereApi::Errors
+  require           'my_john_deere_api/errors/invalid_record_error'
+  require           'my_john_deere_api/errors/missing_contribution_definition_id_error'
+  require           'my_john_deere_api/errors/not_yet_implemented_error'
+  require           'my_john_deere_api/errors/type_mismatch_error'
+  require           'my_john_deere_api/errors/unsupported_environment_error'
+end

data/lib/my_john_deere_api/errors/invalid_record_error.rb

@@ -0,0 +1,29 @@
+module MyJohnDeereApi
+  ##
+  # This error is used in a context that will fail in the absence of
+  # a valid oAuth access token. We have classes that may only need 
+  # access tokens for some use cases.
+
+  class InvalidRecordError < StandardError
+
+    ##
+    # argument is a hash of attributes and their error messages,
+    # which will be built into the raised message.
+
+    def initialize(errors = {})
+      message = 'Record is invalid'
+
+      unless errors.empty?
+        attribute_messages = []
+
+        errors.each do |attribute, message|
+          attribute_messages << "#{attribute} #{message}"
+        end
+
+        message = "#{message}: #{attribute_messages.join('; ')}"
+      end
+
+      super(message)
+    end
+  end
+end

data/lib/my_john_deere_api/errors/missing_contribution_definition_id_error.rb

@@ -0,0 +1,12 @@
+module MyJohnDeereApi
+  ##
+  # This error is used in a context that will fail in the absence of
+  # a valid oAuth access token. We have classes that may only need 
+  # access tokens for some use cases.
+
+  class MissingContributionDefinitionIdError < StandardError
+    def initialize(message = "Contribution Definition ID must be set in the client to use this feature.")
+      super
+    end
+  end
+end

data/lib/my_john_deere_api/errors/not_yet_implemented_error.rb

@@ -0,0 +1,12 @@
+module MyJohnDeereApi
+  ##
+  # This error is used in a context that will fail in the absence of
+  # a valid oAuth access token. We have classes that may only need 
+  # access tokens for some use cases.
+
+  class NotYetImplementedError < StandardError
+    def initialize(message = 'This is not yet implemented. View README to help make this gem better!')
+      super
+    end
+  end
+end

data/lib/my_john_deere_api/errors/type_mismatch_error.rb

@@ -0,0 +1,12 @@
+module MyJohnDeereApi
+  ##
+  # This error is used in a context that will fail in the absence of
+  # a valid oAuth access token. We have classes that may only need 
+  # access tokens for some use cases.
+
+  class TypeMismatchError < StandardError
+    def initialize(message = "Record type does not match what was expected")
+      super
+    end
+  end
+end

data/lib/my_john_deere_api/errors/unsupported_environment_error.rb

@@ -0,0 +1,18 @@
+module MyJohnDeereApi
+  ##
+  # This error is used when an unsupported environment has been requested.
+  # Supported environments currently include :sandbox, :live, and :production
+  # as a synonym for :live.
+
+  class UnsupportedEnvironmentError < StandardError
+    def initialize(environment = nil)
+      message = if environment
+        "The #{environment.inspect} environment is not supported."
+      else
+        'This environment is not supported.'
+      end
+
+      super(message)
+    end
+  end
+end

data/lib/my_john_deere_api/helpers.rb

@@ -0,0 +1,6 @@
+module MyJohnDeereApi::Helpers
+  autoload :UriHelpers,        'my_john_deere_api/helpers/uri_helpers'
+  autoload :CaseConversion, 'my_john_deere_api/helpers/case_conversion'
+  autoload :EnvironmentHelper, 'my_john_deere_api/helpers/environment_helper'
+  autoload :ValidateContributionDefinition, 'my_john_deere_api/helpers/validate_contribution_definition'
+end