eligible 1.0 → 3.0.0.beta17

data/Rakefile

@@ -1,4 +1,14 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
 require 'rake/testtask'
+require 'rubocop/rake_task'
+require 'rspec/core/rake_task'
 
-Rake::TestTask.new(:test)
+RSpec::Core::RakeTask.new(:spec)
+
+task default: [:spec]
+
+desc 'Runs code coverage'
+task :rcov do
+  ENV['COVERAGE'] = 'true'
+  Rake::Task[:spec].invoke
+end

data/eligible.gemspec

@@ -4,25 +4,23 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'eligible/version'
 
 Gem::Specification.new do |gem|
-  gem.name          = "eligible"
+  gem.name          = 'eligible'
   gem.version       = Eligible::VERSION
-  gem.authors       = ["Andy Brett"]
-  gem.email         = ["andy@andybrett.com"]
-  gem.description   = 'Eligible is a developer-friendly way to process health care eligibility checks. Learn more at https://eligibleapi.com'
+  gem.authors       = ['Katelyn Gleaon', 'Rodrigo Dominguez', 'Aaron Bedra']
+  gem.email         = ['k@eligible.com', 'rod@eligible.com', 'abedra@eligible.com']
+  gem.description   = 'Eligible is a developer-friendly way to process health care eligibility checks. Learn more at https://eligible.com'
   gem.summary       = 'Ruby wrapper for the Eligible API'
-  gem.homepage      = "https://eligibleapi.com/"
-  gem.license       = "MIT"
+  gem.homepage      = 'https://github.com/eligible/eligible-ruby'
+  gem.license       = 'MIT'
 
-  gem.files         = `git ls-files`.split($/)
-  # gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  gem.test_files    = `git ls-files -- test/*`.split("\n")
-  gem.require_paths = ["lib"]
+  gem.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  gem.require_paths = ['lib']
 
-  gem.add_development_dependency('mocha')
-  gem.add_development_dependency('shoulda')
-  gem.add_development_dependency('test-unit')
-  gem.add_development_dependency('rake')
+  gem.add_dependency('rest-client', '~> 2.0.0')
+  gem.add_dependency('multi_json', '~> 1.7')
 
-  gem.add_dependency('rest-client', '~> 1.4')
-  gem.add_dependency('multi_json', '>= 1.0.4', '< 2')
+  gem.add_development_dependency('rake', '~> 12.0')
+  gem.add_development_dependency('rspec', '~> 3.4')
+  gem.add_development_dependency('rspec_junit_formatter', '~> 0.3.0')
+  gem.add_development_dependency('simplecov', '~> 0.11')
 end

data/lib/eligible/api_resource.rb

@@ -1,14 +1,58 @@
 module Eligible
   class APIResource < EligibleObject
     def self.class_name
-      self.name.split('::')[-1]
+      name.split('::').last
     end
 
-    def self.url()
+    def self.api_url(base, params = nil, param_id = nil)
+      if params.nil?
+        "/#{base}"
+      else
+        id = Util.value(params, param_id)
+        "/#{base}/#{id}"
+      end
+    end
+
+    def self.url
       if self == APIResource
-        raise NotImplementedError.new('APIResource is an abstract class.  You should perform actions on its subclasses (Plan, Service, etc.)')
+        fail NotImplementedError, 'APIResource is an abstract class.  You should perform actions on its subclasses (Plan, Service, etc.)'
       end
-      "/#{CGI.escape(class_name.downcase)}/all.json"
+      "/#{CGI.escape(class_name.downcase)}/"
+    end
+
+    def self.endpoint_name
+      self.const_get('ENDPOINT_NAME')
+    end
+
+    def self.require_param(value, name)
+      fail ArgumentError, "#{name} of the #{class_name} is required" if value.nil? || (value.is_a?(String) && value.empty?)
+    end
+
+    def self.required_param_validation(params:, required_params:)
+      return if required_params.nil? || !required_params.is_a?(Array)
+
+      required_params.each do |required_param_name|
+        required_param = Util.value(params, required_param_name)
+        require_param(required_param, required_param_name)
+      end
+    end
+
+    def self.rest_api_params(id_or_params)
+      id_or_params.is_a?(Hash) ? id_or_params : { id: id_or_params }
+    end
+
+    def self.send_request(method, url, params, opts)
+      headers = opts.clone
+      client_secret = headers.delete(:client_secret)
+      api_key = headers.delete(:api_key)
+      api_key = client_secret unless client_secret.nil?
+
+      required_param_validation(params: params, required_params: headers.delete(:required_params))
+
+      # Here rest_api_version is related to New REST API Endpoints
+      params = self.const_defined?(:REST_API_VERSION) ? params.merge(rest_api_version: self::REST_API_VERSION) : params
+      response, api_key = Eligible.request(method, url, api_key, params, headers)
+      Util.convert_to_eligible_object(response, api_key)
     end
   end
-end
+end

data/lib/eligible/calculator_deploy_url.rb

@@ -0,0 +1,7 @@
+module Eligible
+  class CalculatorDeployUrl < APIResource
+    def self.fetch_or_create(params, opts = {})
+      send_request :get, '/calculator_deploy_urls.json', params, opts
+    end
+  end
+end

data/lib/eligible/claim.rb

@@ -1,12 +1,28 @@
 module Eligible
   class Claim < APIResource
-    def self.get(params, api_key=nil)
-      response, api_key = Eligible.request(:get, url, api_key, params)
-      Util.convert_to_eligible_object(response, api_key)
+    def self.ack(params, opts = {})
+      reference_id = Util.value(params, :reference_id)
+      send_request :get, "/claims/#{reference_id}/acknowledgements.json", params, opts.merge(required_params: [:reference_id])
     end
 
-    def status
-      error ? nil : to_hash
+    def self.post(params, opts = {})
+      send_request :post, '/claims.json', params, opts
+    end
+
+    def self.acks(params, opts = {})
+      send_request :get, '/claims/acknowledgements.json', params, opts
+    end
+
+    def self.payment_report(params, opts = {})
+      reference_id = Util.value(params, :reference_id)
+      require_param(reference_id, 'Reference id')
+      id = Util.value(params, :id)
+      url = id.nil? ? "/claims/#{reference_id}/payment_reports" : "/claims/#{reference_id}/payment_reports/#{id}"
+      send_request :get, url, params, opts
+    end
+
+    def self.payment_reports(params, opts = {})
+      send_request :get, '/claims/payment_reports.json', params, opts
     end
   end
-end
+end

data/lib/eligible/coverage.rb

@@ -0,0 +1,19 @@
+module Eligible
+  class Coverage < CoverageResource
+    def self.get_uri
+      return '/coverage/all.json'
+    end
+
+    def self.post_uri
+      return '/coverage/all/batch.json'
+    end
+
+    def self.cost_estimate(params, opts = {})
+      send_request :get, '/coverage/cost_estimates.json', params, opts
+    end
+
+    def self.batch_medicare_post(params, opts = {})
+      send_request :post, '/medicare/coverage/batch.json', params, opts
+    end
+  end
+end

data/lib/eligible/coverage_resource.rb

@@ -0,0 +1,23 @@
+module Eligible
+  class CoverageResource < APIResource
+    def self.get(params, opts = {})
+      send_request :get, get_uri, params, opts
+    end
+
+    def self.post(params, opts = {})
+      send_request :post, post_uri, params, opts
+    end
+
+    def self.get_uri
+      fail NotImplementedError, "Please implement class method #{self}.get_uri"
+    end
+
+    def self.post_uri
+      fail NotImplementedError, "Please implement class method #{self}.post_uri"
+    end
+
+    class << self
+      alias_method :batch_post, :post
+    end
+  end
+end

data/lib/eligible/customer.rb

@@ -0,0 +1,19 @@
+module Eligible
+  class Customer < APIResource
+    def self.get(params, opts = {})
+      send_request :get, api_url('customers', params, :customer_id), params, opts.merge(required_params: [:customer_id])
+    end
+
+    def self.post(params, opts = {})
+      send_request :post, api_url('customers'), params, opts
+    end
+
+    def self.update(params, opts = {})
+      send_request :put, api_url('customers', params, :customer_id), params, opts.merge(required_params: [:customer_id])
+    end
+
+    def self.all(params, opts = {})
+      send_request :get, api_url('customers'), params, opts
+    end
+  end
+end

data/lib/eligible/demographic.rb

@@ -1,40 +1,11 @@
 module Eligible
-  class Demographic < APIResource
-    COMMON_ATTRIBUTES = [:timestamp, :eligible_id, :mapping_version]
-    ZIP_ATTRIBUTES = [:zip]
-    EMPLOYER_ATTRIBUTES = [:group_id, :group_name]
-    ADDRESS_ATTRIBUTES = [:address]
-    DOB_ATTRIBUTES = [:dob]
-
-    def self.get(params, api_key=nil)
-      response, api_key = Eligible.request(:get, url, api_key, params)
-      Util.convert_to_eligible_object(response, api_key)
-    end
-
-    def all
-      error ? nil : to_hash
-    end
-
-    def zip
-      keys = COMMON_ATTRIBUTES
-      h = to_hash.select { |k, v| keys.include?(k) }
-      h[:zip] = to_hash[:address][:zip]
-      error ? nil : h
-    end
-
-    def employer
-      keys = COMMON_ATTRIBUTES + EMPLOYER_ATTRIBUTES
-      error ? nil : to_hash.select { |k, v| keys.include?(k) }
-    end
-
-    def address
-      keys = COMMON_ATTRIBUTES + ADDRESS_ATTRIBUTES
-      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+  class Demographic < CoverageResource
+    def self.get_uri
+      return '/demographic/all.json'
     end
 
-    def dob
-      keys = COMMON_ATTRIBUTES + DOB_ATTRIBUTES
-      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    def self.post_uri
+      return '/demographic/all/batch.json'
     end
   end
-end
+end

data/lib/eligible/eligible_object.rb

@@ -1,18 +1,16 @@
 module Eligible
-
   class EligibleObject
     include Enumerable
 
     attr_accessor :api_key
     attr_accessor :eligible_id
+
     @@permanent_attributes = Set.new([:api_key, :error, :balance, :address, :dob])
 
     # The default :id method is deprecated and isn't useful to us
-    if method_defined?(:id)
-      undef :id
-    end
+    undef :id if method_defined?(:id)
 
-    def initialize(id=nil, api_key=nil)
+    def initialize(id = nil, api_key = nil)
       @api_key = api_key
       @values = {}
       # This really belongs in APIResource, but not putting it there allows us
@@ -22,13 +20,13 @@ module Eligible
       self.eligible_id = id if id
     end
 
-    def self.construct_from(values, api_key=nil)
-      obj = self.new(values[:eligible_id], api_key)
+    def self.construct_from(values, api_key = nil)
+      obj = new(values[:eligible_id], api_key)
       obj.refresh_from(values, api_key)
       obj
     end
 
-    def refresh_from(values, api_key, partial=false)
+    def refresh_from(values, api_key, partial = false)
       @api_key = api_key
 
       removed = partial ? Set.new : Set.new(@values.keys - values.keys)
@@ -47,14 +45,14 @@ module Eligible
         @unsaved_values.delete(k)
       end
       values.each do |k, v|
-        @values[k] = v#Util.convert_to_eligible_object(v, api_key)
+        @values[k] = v
         @transient_values.delete(k)
         @unsaved_values.delete(k)
       end
     end
 
     def [](k)
-      k = k.to_sym if k.kind_of?(String)
+      k = k.to_sym if k.is_a?(String)
       @values[k]
     end
 
@@ -70,7 +68,7 @@ module Eligible
       @values.values
     end
 
-    def to_json(*a)
+    def to_json
       Eligible::JSON.dump(@values)
     end
 
@@ -90,7 +88,7 @@ module Eligible
 
     def metaclass
       class << self; self; end
-    end    
+    end
 
     def remove_accessors(keys)
       metaclass.instance_eval do
@@ -115,7 +113,6 @@ module Eligible
           end
         end
       end
-    end    
+    end
   end
-
-end
+end

data/lib/eligible/encryptor.rb

@@ -0,0 +1,121 @@
+require 'openssl'
+
+module Eligible
+  # A simple wrapper for the standard OpenSSL library
+  module Encryptor
+    extend self
+    # The default options to use when calling the <tt>encrypt</tt> and <tt>decrypt</tt> methods
+    #
+    # Defaults to { algorithm: 'aes-256-gcm',
+    #               auth_data: '',
+    #               insecure_mode: false,
+    #               hmac_iterations: 2000,
+    #               v2_gcm_iv: false }
+    #
+    # Run 'openssl list-cipher-commands' in your terminal to view a list all cipher algorithms that are supported on your platform
+    def default_options
+      @default_options ||= {
+        algorithm: 'aes-256-cbc',
+        auth_data: '',
+        insecure_mode: false,
+        hmac_iterations: 2000,
+        v2_gcm_iv: false
+      }
+    end
+
+    # Encrypts a <tt>:value</tt> with a specified <tt>:key</tt> and <tt>:iv</tt>.
+    #
+    # Optionally accepts <tt>:salt</tt>, <tt>:auth_data</tt>, <tt>:algorithm</tt>, <tt>:hmac_iterations</tt>, and <tt>:insecure_mode</tt> options.
+    #
+    # Example
+    #
+    #   encrypted_value = Encryptor.encrypt(value: 'some string to encrypt', key: 'some secret key', iv: 'some unique value', salt: 'another unique value')
+    #   # or
+    #   encrypted_value = Encryptor.encrypt('some string to encrypt', key: 'some secret key', iv: 'some unique value', salt: 'another unique value')
+    def encrypt(*args, &block)
+      crypt :encrypt, *args, &block
+    end
+
+    # Decrypts a <tt>:value</tt> with a specified <tt>:key</tt> and  <tt>:iv</tt>.
+    #
+    # Optionally accepts <tt>:salt</tt>, <tt>:auth_data</tt>, <tt>:algorithm</tt>, <tt>:hmac_iterations</tt>, and <tt>:insecure_mode</tt> options.
+    #
+    # Example
+    #
+    #   decrypted_value = Encryptor.decrypt(value: 'some encrypted string', key: 'some secret key', iv: 'some unique value', salt: 'another unique value')
+    #   # or
+    #   decrypted_value = Encryptor.decrypt('some encrypted string', key: 'some secret key', iv: 'some unique value', salt: 'another unique value')
+    def decrypt(*args, &block)
+      crypt :decrypt, *args, &block
+    end
+
+    protected
+
+    def crypt(cipher_method, *args) #:nodoc:
+      options = default_options.merge(value: args.first).merge(args.last.is_a?(Hash) ? args.last : {})
+      raise ArgumentError.new('must specify a key') if options[:key].to_s.empty?
+      cipher = OpenSSL::Cipher.new(options[:algorithm])
+      cipher.send(cipher_method)
+
+      unless options[:insecure_mode]
+        raise ArgumentError.new("key must be #{cipher.key_len} bytes or longer") if options[:key].bytesize < cipher.key_len
+        raise ArgumentError.new('must specify an iv') if options[:iv].to_s.empty?
+        raise ArgumentError.new("iv must be #{cipher.iv_len} bytes or longer") if options[:iv].bytesize < cipher.iv_len
+      end
+
+      if options[:iv]
+        # This is here for backwards compatibility for Encryptor v2.0.0.
+        cipher.iv = options[:iv] if options[:v2_gcm_iv]
+        if options[:salt].nil?
+          # Use a non-salted cipher.
+          # This behaviour is retained for backwards compatibility. This mode
+          # is not secure and new deployments should use the :salt options
+          # wherever possible.
+          cipher.key = options[:key]
+        else
+          # Use an explicit salt (which can be persisted into a database on a
+          # per-column basis, for example). This is the preferred (and more
+          # secure) mode of operation.
+          cipher.key = OpenSSL::PKCS5.pbkdf2_hmac_sha1(options[:key], options[:salt], options[:hmac_iterations], cipher.key_len)
+        end
+        cipher.iv = options[:iv] unless options[:v2_gcm_iv]
+      else
+        # This is deprecated and needs to be changed.
+        cipher.pkcs5_keyivgen(options[:key])
+      end
+
+      yield cipher, options if block_given?
+
+      value = options[:value]
+
+      if cipher.authenticated?
+        if encryption?(cipher_method)
+          cipher.auth_data = options[:auth_data]
+        else
+          value = extract_cipher_text(options[:value])
+          cipher.auth_tag = extract_auth_tag(options[:value])
+          # auth_data must be set after auth_tag has been set when decrypting
+          # See http://ruby-doc.org/stdlib-2.0.0/libdoc/openssl/rdoc/OpenSSL/Cipher.html#method-i-auth_data-3D
+          cipher.auth_data = options[:auth_data]
+        end
+      end
+
+      result = cipher.update(value)
+      result << cipher.final
+      result << cipher.auth_tag if cipher.authenticated? && encryption?(cipher_method)
+      result
+    end
+
+    def encryption?(cipher_method)
+      cipher_method == :encrypt
+    end
+
+    def extract_cipher_text(value)
+      value[0..-17]
+    end
+
+    def extract_auth_tag(value)
+      value[-16..-1]
+    end
+  end
+end

data/lib/eligible/enrollment.rb

@@ -0,0 +1,23 @@
+module Eligible
+  class Enrollment < APIResource
+    def self.get(params, opts = {})
+      send_request :get, api_url('enrollment_npis', params, :enrollment_npi_id), params, opts.merge(required_params: [:enrollment_npi_id])
+    end
+
+    def self.list(params, opts = {})
+      send_request :get, api_url('enrollment_npis'), params, opts
+    end
+
+    def self.post(params, opts = {})
+      send_request :post, api_url('enrollment_npis'), params, opts
+    end
+
+    def self.update(params, opts = {})
+      send_request :put, api_url('enrollment_npis', params, :enrollment_npi_id), params, opts.merge(required_params: [:enrollment_npi_id])
+    end
+
+    def enrollment_npis
+      values.first[:enrollment_npis]
+    end
+  end
+end

data/lib/eligible/errors/eligible_error.rb

@@ -4,17 +4,20 @@ module Eligible
     attr_reader :http_status
     attr_reader :http_body
     attr_reader :json_body
+    attr_reader :errors
 
-    def initialize(message=nil, http_status=nil, http_body=nil, json_body=nil)
+    def initialize(message = nil, http_status = nil, http_body = nil, json_body = nil)
       @message = message
       @http_status = http_status
       @http_body = http_body
       @json_body = json_body
+      @errors = (@json_body || {}).fetch(:errors, [])
     end
 
     def to_s
-      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
-      "#{status_string}#{@message}"
+      status_string = @http_status.nil? ? '' : "(Status #{@http_status}) "
+      json_errors = errors.presence || (json_body&.key?(:error) ? [json_body] : [])
+      "#{status_string}#{@message}: #{json_errors.to_json}"
     end
   end
 end

data/lib/eligible/errors/invalid_request_error.rb

@@ -0,0 +1,4 @@
+module Eligible
+  class InvalidRequestError < EligibleError
+  end
+end

data/lib/eligible/icd.rb

@@ -0,0 +1,16 @@
+module Eligible
+  class Icd < APIResource
+
+    def self.list(params, opts = {})
+      send_request :get, "/icds/#{Util.value(params, :type)}", params, opts
+    end
+
+    def self.describe(params, opts = {})
+      send_request :get, "/icds/#{Util.value(params, :type)}/describe/#{Util.value(params, :code)}", params, opts
+    end
+
+    def self.crosswalk(params, opts = {})
+      send_request :get, "/icds/#{Util.value(params, :type)}/crosswalk/#{Util.value(params, :code)}", params, opts
+    end
+  end
+end

data/lib/eligible/json.rb

@@ -1,21 +1,11 @@
 module Eligible
   module JSON
-    if MultiJson.respond_to?(:dump)
-      def self.dump(*args)
-        MultiJson.dump(*args)
-      end
-
-      def self.load(*args)
-        MultiJson.load(*args)
-      end
-    else
-      def self.dump(*args)
-        MultiJson.encode(*args)
-      end
+    def self.dump(*args)
+      MultiJson.dump(*args)
+    end
 
-      def self.load(*args)
-        MultiJson.decode(*args)
-      end
+    def self.load(*args)
+      MultiJson.load(*args)
     end
   end
 end

data/lib/eligible/lockbox.rb

@@ -0,0 +1,39 @@
+require 'openssl'
+require 'base64'
+
+module Eligible
+  class Lockbox < APIResource
+    def self.get(params, opts = {})
+      send_request :get, api_url('lockboxes', params, :lockbox_id), params, opts.merge(required_params: [:lockbox_id])
+    end
+
+    def self.all(params, opts = {})
+      send_request :get, api_url('lockboxes'), params, opts
+    end
+
+    def self.extract_private_key(params)
+      private_key = Util.value(params, :private_key)
+      fail ArgumentError, "Private key is required for decryption" if private_key.nil?
+      private_key
+    end
+
+    def self.delete_private_key!(params)
+      params.delete('private_key')
+      params.delete(:private_key)
+    end
+
+    def self.decrypt_data(data, encrypted_data_key, private_key)
+      pkey = OpenSSL::PKey::RSA.new(private_key)
+      aes_key = pkey.private_decrypt(Base64.decode64(encrypted_data_key))
+      sha_key = Digest::SHA256.hexdigest(aes_key)
+      Encryptor.decrypt(value: Base64.decode64(data), key: sha_key, insecure_mode: true)
+    end
+
+    def self.get_and_decrypt_from_lockbox(params, opts = {})
+      private_key = extract_private_key(params)
+      delete_private_key!(params)
+      req = get(params, opts).to_hash
+      decrypt_data(req[:encrypted_data], req[:encrypted_key], private_key)
+    end
+  end
+end

data/lib/eligible/medicare.rb

@@ -0,0 +1,11 @@
+module Eligible
+  class Medicare < CoverageResource
+    def self.get_uri
+      return '/medicare/coverage.json'
+    end
+
+    def self.post_uri
+      return '/medicare/coverage/batch.json'
+    end
+  end
+end

data/lib/eligible/oauth_token.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Eligible
+  class OauthToken < APIResource
+    def self.post(params, opts = {})
+      send_request :post, '/oauth/token', params, opts
+    end
+  end
+end

data/lib/eligible/ocr.rb

@@ -0,0 +1,15 @@
+module Eligible
+  class Ocr < APIResource
+    def self.setup_file(params)
+      file = Util.value(params, :file)
+      params[:file] = File.new(file, 'rb') if file.is_a?(String)
+    end
+
+    def self.post(params, opts = {})
+      setup_file(params)
+      send_request :post, '/card_scans.json', params, opts
+    end
+
+    private_class_method :setup_file
+  end
+end