eligible 1.0 → 3.0.0.beta17

data/lib/eligible.rb

@@ -2,34 +2,123 @@ require 'cgi'
 require 'set'
 require 'rubygems'
 require 'openssl'
+require 'net/https'
 
-gem 'rest-client', '~> 1.4'
 require 'rest_client'
 require 'multi_json'
 
 require 'eligible/version'
+require 'eligible/encryptor'
 require 'eligible/util'
 require 'eligible/json'
 require 'eligible/eligible_object'
 require 'eligible/api_resource'
-require 'eligible/plan'
-require 'eligible/service'
+require 'eligible/coverage_resource'
 require 'eligible/demographic'
 require 'eligible/claim'
+require 'eligible/enrollment'
+require 'eligible/coverage'
+require 'eligible/payment'
+require 'eligible/x12'
+require 'eligible/medicare'
+require 'eligible/ticket'
+require 'eligible/customer'
+require 'eligible/ocr'
+require 'eligible/original_signature_pdf'
+require 'eligible/oauth_token'
+require 'eligible/received_pdf'
+require 'eligible/payer'
+require 'eligible/payer_mapping'
+require 'eligible/preauth_resource'
+require 'eligible/precert'
+require 'eligible/referral'
+require 'eligible/public_key'
+require 'eligible/lockbox'
+require 'eligible/session_token'
+require 'eligible/visit_type'
+require 'eligible/provider_model'
+require 'eligible/calculator_deploy_url'
+require 'eligible/risk_assessment'
+require 'eligible/icd'
+
+# New REST API Endpoints
+require 'eligible/v1_0/rest_api_base'
+require 'eligible/v1_0/action'
+require 'eligible/v1_0/attribute'
+require 'eligible/v1_0/charge'
+require 'eligible/v1_0/claim'
+require 'eligible/v1_0/claim_service_line'
+require 'eligible/v1_0/contract'
+require 'eligible/v1_0/device'
+require 'eligible/v1_0/discount'
+require 'eligible/v1_0/enrollment'
+require 'eligible/v1_0/estimate'
+require 'eligible/v1_0/estimate_service_line'
+require 'eligible/v1_0/fee'
+require 'eligible/v1_0/fee_refund'
+require 'eligible/v1_0/file'
+require 'eligible/v1_0/file_link'
+require 'eligible/v1_0/insurance_company'
+require 'eligible/v1_0/insurance_company_alias'
+require 'eligible/v1_0/insurance_policy'
+require 'eligible/v1_0/patient_record'
+require 'eligible/v1_0/patient_statement'
+require 'eligible/v1_0/patient_statement_service_line'
+require 'eligible/v1_0/payment_report'
+require 'eligible/v1_0/patient_question'
+require 'eligible/v1_0/patient_questionnaire'
+require 'eligible/v1_0/product'
+require 'eligible/v1_0/provider'
+require 'eligible/v1_0/remark'
+require 'eligible/v1_0/rule'
+require 'eligible/v1_0/session'
+require 'eligible/v1_0/transaction'
+require 'eligible/v1_0/treatment'
+require 'eligible/v1_0/value_list'
+require 'eligible/v1_0/value_list_item'
+require 'eligible/v1_0/verification'
+require 'eligible/v1_0/reports/accuracy_stats'
+require 'eligible/v1_0/reports/estimate_friction'
+require 'eligible/v1_0/reports/in_scope_distribution'
 
 # Errors
 require 'eligible/errors/eligible_error'
 require 'eligible/errors/api_connection_error'
 require 'eligible/errors/authentication_error'
 require 'eligible/errors/api_error'
+require 'eligible/errors/invalid_request_error'
 
 module Eligible
-  @@api_key  = nil
-  @@api_base = "https://v1.eligibleapi.net"
-  @@api_version = 1
+  @@api_key = nil
+  @@test = false
+  @@api_version = '1.5'
+  @@api_base = "https://gds.eligibleapi.com/v#{@@api_version}"
+  @@fingerprints = %w(a1cd762a9f4be0f3b6bdd6300e52c6ce8d7d67f5
+                      36d6b6f98a2b9bcdf4321d1978553e23cf044b53
+                      d93b7697100fe978ae0f78fbf2a2443cc1958ca3
+                      896ce24f7a83eb656c040985fdb50ce39f90b813)
+  @@eligible_account = nil
+  @@eligible_account_id = nil
+
+  def self.api_url(url = '', rest_api_version = nil)
+    api_base = rest_api_version ? @@api_base.gsub(/v(\d).(\d)/, "v#{rest_api_version}") : @@api_base
+    api_base + url.to_s
+  end
+
+  def self.eligible_account
+    @@eligible_account
+  end
+
+  def self.eligible_account_id
+    @@eligible_account_id
+  end
 
-  def self.api_url(url='')
-    @@api_base + url
+  def self.eligible_account=(eligible_account)
+    @@eligible_account = eligible_account
+  end
+
+  def self.eligible_account_id=(eligible_account_id)
+    @@eligible_account_id = eligible_account_id
   end
 
   def self.api_key
@@ -40,161 +129,284 @@ module Eligible
     @@api_key = api_key
   end
 
+  def self.api_base
+    @@api_base
+  end
+
+  def self.api_base=(api_base)
+    @@api_base = api_base
+  end
+
+  def self.test
+    @@test ? 'true' : 'false'
+  end
+
+  def self.test=(is_test)
+    @@test = is_test
+  end
+
   def self.api_version=(version)
     @@api_version = version
   end
 
   def self.api_version
     @@api_version
-  end  
-
-  def self.request(method, url, api_key, params={}, headers={})
-    api_key ||= @@api_key
-    raise AuthenticationError.new('No API key provided. (HINT: set your API key using "Eligible.api_key = <API-KEY>".') unless api_key
-
-    # if !verify_ssl_certs
-    #   unless @no_verify
-    #     $stderr.puts "WARNING: Running without SSL cert verification.  Execute 'Eligible.verify_ssl_certs = true' to enable verification."
-    #     @no_verify = true
-    #   end
-    #   ssl_opts = { :verify_ssl => false }
-    # elsif !Util.file_readable(@@ssl_bundle_path)
-    #   unless @no_bundle
-    #     $stderr.puts "WARNING: Running without SSL cert verification because #{@@ssl_bundle_path} isn't readable"
-    #     @no_bundle = true
-    #   end
-    #   ssl_opts = { :verify_ssl => false }
-    # else
-    #   ssl_opts = {
-    #     :verify_ssl => OpenSSL::SSL::VERIFY_PEER,
-    #     :ssl_ca_file => @@ssl_bundle_path
-    #   }
-    # end
-    uname = (@@uname ||= RUBY_PLATFORM =~ /linux|darwin/i ? `uname -a 2>/dev/null`.strip : nil)
-    lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
-    ua = {
-      :bindings_version => Eligible::VERSION,
-      :lang => 'ruby',
-      :lang_version => lang_version,
-      :platform => RUBY_PLATFORM,
-      :publisher => 'eligible',
-      :uname => uname
-    }
+  end
 
-    # params = Util.objects_to_ids(params)
-    url = self.api_url(url)
-    case method.to_s.downcase.to_sym
-    when :get, :head, :delete
-      # Make params into GET parameters
-      url += "?api_key=#{api_key}"
-      if params && params.count > 0
-        query_string = Util.flatten_params(params).collect{|key, value| "#{key}=#{Util.url_encode(value)}"}.join('&')
-        url += "&#{query_string}"
-      end
-      payload = nil
-    else
-      payload = Util.flatten_params(params).collect{|(key, value)| "#{key}=#{Util.url_encode(value)}"}.join('&')
-    end
+  def self.fingerprints
+    @@fingerprints
+  end
 
-    begin
-      headers = { :x_eligible_client_user_agent => Eligible::JSON.dump(ua) }.merge(headers)
-    rescue => e
-      headers = {
-        :x_eligible_client_raw_user_agent => ua.inspect,
-        :error => "#{e} (#{e.class})"
-      }.merge(headers)
-    end
+  def self.add_fingerprint(digest)
+    $stderr.puts 'The embedded certificate fingerprint was modified. This should only be done if instructed to by eligible support staff'
+    @@fingerprints << digest
+  end
 
-    headers = {
-      :user_agent => "Eligible/v1 RubyBindings/#{Eligible::VERSION}",
-      :authorization => "Bearer #{api_key}",
-      :content_type => 'application/x-www-form-urlencoded'
-    }.merge(headers)
+  def self.direct_response?(params)
+    params[:format].is_a?(String) && params[:format].downcase == 'x12'
+  end
 
-    if self.api_version
-      headers[:eligible_version] = self.api_version
-    end
+  def self.test_key?(params)
+    Util.key?(params, :test)
+  end
+
+  def self.api_key?(params)
+    Util.key?(params, :api_key)
+  end
+
+  def self.rest_api_version?(params)
+    Util.key?(params, :rest_api_version)
+  end
+
+  def self.request(method, url, api_key, params = {}, headers = {})
+    session_token = Util.value(params, :session_token)
+    api_key ||= @@api_key unless session_token
+    test = self.test
+    api_key = Util.value(params, :api_key) if api_key?(params)
+    test = Util.value(params, :test) if test_key?(params)
+    rest_api_version = Util.value(params, :rest_api_version) if rest_api_version?(params)
+    basic_auth = true if rest_api_version?(params)
+
+    fail AuthenticationError, 'No API key provided. (HINT: set your API key using "Eligible.api_key = <API-KEY>".' unless api_key || session_token
+
+    lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+    debug_info = {
+      bindings_version: Eligible::VERSION,
+      lang: 'ruby',
+      lang_version: lang_version,
+      platform: RUBY_PLATFORM,
+      publisher: 'eligible',
+      uname: uname
+    }
+
+    # Set request URL and Payload based on new and old endpoints version
+    url, payload = generate_request_url_and_payload(
+      method, url, params, { test: test, rest_api_version: rest_api_version, api_key: api_key, basic_auth: basic_auth },
+    )
+
+    # Set request Headers and Authorization based on new and old endpoints version
+    headers = generate_request_headers(headers, debug_info, basic_auth, { api_key: api_key, session_token: session_token })
 
     opts = {
-      :method => method,
-      :url => url,
-      :headers => headers,
-      :open_timeout => 30,
-      :payload => payload,
-      :timeout => 80
-    }#.merge(ssl_opts)
-    
+      method: method,
+      url: url,
+      headers: headers,
+      open_timeout: 30,
+      payload: payload,
+      timeout: 80,
+      ssl_verify_callback: verify_certificate,
+      ssl_verify_callback_warnings: false
+    }
+
     begin
       response = execute_request(opts)
+
     rescue SocketError => e
-      self.handle_restclient_error(e)
+      handle_restclient_error(e)
+
     rescue NoMethodError => e
       # Work around RestClient bug
-      if e.message =~ /\WRequestFailed\W/
-        e = APIConnectionError.new('Unexpected HTTP response code')
-        self.handle_restclient_error(e)
-      else
-        raise
-      end
+      raise unless e.message =~ /\WRequestFailed\W/
+
+      e = APIConnectionError.new('Unexpected HTTP response code')
+      handle_restclient_error(e)
+
     rescue RestClient::ExceptionWithResponse => e
-      if rcode = e.http_code and rbody = e.http_body
-        self.handle_api_error(rcode, rbody)
+      err_rcode = e.http_code
+      err_rbody = e.http_body
+
+      if err_rcode && err_rbody
+        handle_api_error(err_rcode, err_rbody)
       else
-        self.handle_restclient_error(e)
+        handle_restclient_error(e)
       end
+
     rescue RestClient::Exception, Errno::ECONNREFUSED => e
-      self.handle_restclient_error(e)
+      handle_restclient_error(e)
     end
 
     rbody = response.body
     rcode = response.code
+
     begin
       # Would use :symbolize_names => true, but apparently there is
       # some library out there that makes symbolize_names not work.
-      resp = Eligible::JSON.load(rbody)
+      resp = direct_response?(params) ? rbody : Eligible::JSON.load(rbody)
     rescue MultiJson::DecodeError
       raise APIError.new("Invalid response object from API: #{rbody.inspect} (HTTP response code was #{rcode})", rcode, rbody)
     end
 
     resp = Util.symbolize_names(resp)
-    [resp, api_key]
+    return [ resp, api_key ]
+  end
+
+  def self.generate_request_url_and_payload(method, url, params, options)
+    # GET requests, parameters on the query string
+    # POST requests, parameters as json in the body
+    url = api_url(url, options[:rest_api_version])
+    # Used rest_api_version param only to identify new REST API version, and is not required to make calls for new REST api endpoints
+    params.delete(:rest_api_version)
+    case method.to_s.downcase.to_sym
+    when :get, :head, :delete
+      url = fetch_url_with_query_string(params, url, options)
+      payload = nil
+    else
+      payload = request_payload(options, params)
+    end
+
+    [url, payload]
+  end
+
+  def self.fetch_url_with_query_string(params, url, options)
+    url += options_query_string(options)
+    return url unless params || params.count == 0
+
+    query_string = params_query_string(params)
+    url += options[:basic_auth] ? "?#{query_string}" : "&#{query_string}"
+    url
+  end
+
+  def self.options_query_string(options)
+    options[:basic_auth] ? '' : "?test=#{options[:test]}&api_key=#{options[:api_key]}"
+  end
+
+  def self.params_query_string(params)
+    Util.flatten_params(params).collect { |key, value| "#{key}=#{Util.url_encode(value)}" }.join('&')
+  end
+
+  def self.request_payload(options, params)
+    params.merge!('test' => options[:test], 'api_key' => options[:api_key]) unless options[:basic_auth]
+    Util.key?(params, :file) ? params : Eligible::JSON.dump(params)
+  end
+
+  def self.generate_request_headers(headers, debug_info, basic_auth, auth_options)
+    begin
+      headers = { x_eligible_debuginfo: Eligible::JSON.dump(debug_info) }.merge(headers)
+    rescue => e
+      headers = {
+        x_eligible_client_raw_user_agent: debug_info.inspect,
+        error: "#{e} (#{e.class})"
+      }.merge(headers)
+    end
+
+    headers = {
+      user_agent: "eligible-ruby/#{Eligible::VERSION}",
+      content_type: 'application/json'
+    }.merge(headers)
+
+    headers[:authorization] = authorization_header(basic_auth, auth_options)
+    headers[:eligible_version] = api_version if api_version
+    headers[:eligible_account] = eligible_account if eligible_account
+    headers[:eligible_account_id] = eligible_account_id if eligible_account_id
+    headers
+  end
+
+  def self.authorization_header(basic_auth, auth_options)
+    # Using Bearer scheme for Session Token Auth for new REST API endpoints (v1.0)
+    return "Bearer #{auth_options[:session_token]}" if basic_auth && auth_options[:session_token]
+
+    # Using Basic Auth for new REST API endpoints (v1.0)
+    basic_auth_token = Base64.strict_encode64("#{auth_options[:api_key]}:")
+    "Basic #{basic_auth_token}" if basic_auth
+  end
+
+  def self.verify_certificate
+    lambda do |preverify_ok, certificate_store|
+      return true if test == 'true'
+      return false unless preverify_ok
+      received = certificate_store.chain.first
+      return true unless received.to_der == certificate_store.current_cert.to_der
+      valid_fingerprint?(received)
+    end
+  end
+
+  def self.valid_fingerprint?(received)
+    fingerprints.include?(OpenSSL::Digest::SHA1.hexdigest(received.to_der))
   end
 
   private
 
+  def self.uname
+    @@uname ||= RUBY_PLATFORM =~ /linux|darwin/i ? `uname -a 2>/dev/null`.strip : nil
+  end
+
   def self.execute_request(opts)
     RestClient::Request.execute(opts)
   end
 
+  def self.error_message(error, errors)
+    message = compose_message_from_errors(errors)
+    return message if message
+
+    return compose_message_from_error(error)
+  end
+
+  def self.compose_message_from_errors(errors)
+    return unless errors.is_a?(Array)
+
+    return errors.first[:message] if errors.size == 1
+    return errors.each_with_index.map { |error, index| "#{index + 1}. #{error[:message]}" }.join("\n")
+  end
+
+  def self.compose_message_from_error(error)
+    return error.to_s unless error.is_a?(Hash)
+    result = error[:details] || error[:reject_reason_description] || error
+    return result.to_s
+  end
+
   def self.handle_api_error(rcode, rbody)
     begin
-      error_obj = Eligible::JSON.load(rbody)
-      error_obj = Util.symbolize_names(error_obj)
-      error = error_obj[:error] or raise EligibleError.new # escape from parsing
+      error_obj = Util.symbolize_names(Eligible::JSON.load(rbody))
+      fail EligibleError unless error_obj.keys.any? { |k| [:error, :errors].include? k }
+      error = error_obj[:error]
+      errors = error_obj[:errors]
+
     rescue MultiJson::DecodeError, EligibleError
       raise APIError.new("Invalid response object from API: #{rbody.inspect} (HTTP response code was #{rcode})", rcode, rbody)
     end
 
+    error_msg = error_message(error, errors)
+
     case rcode
     when 400, 404 then
-      raise invalid_request_error(error, rcode, rbody, error_obj)
+      raise invalid_request_error(error_msg, rcode, rbody, error_obj)
     when 401
-      raise authentication_error(error, rcode, rbody, error_obj)
+      raise authentication_error(error_msg, rcode, rbody, error_obj)
     else
-      raise api_error(error, rcode, rbody, error_obj)
+      raise api_error(error_msg, rcode, rbody, error_obj)
     end
   end
 
-  def self.invalid_request_error(error, rcode, rbody, error_obj)
-    InvalidRequestError.new(error[0][:message], error[:param], rcode, rbody, error_obj)
+  def self.invalid_request_error(error_msg, rcode, rbody, error_obj)
+    InvalidRequestError.new(error_msg, rcode, rbody, error_obj)
   end
 
-  def self.authentication_error(error, rcode, rbody, error_obj)
-    AuthenticationError.new(error[0][:message], rcode, rbody, error_obj)
+  def self.authentication_error(error_msg, rcode, rbody, error_obj)
+    AuthenticationError.new(error_msg, rcode, rbody, error_obj)
   end
 
-  def self.api_error(error, rcode, rbody, error_obj)
-    APIError.new(error[0][:message], rcode, rbody, error_obj)
+  def self.api_error(error_msg, rcode, rbody, error_obj)
+    APIError.new(error_msg, rcode, rbody, error_obj)
   end
 
   def self.handle_restclient_error(e)
@@ -204,12 +416,10 @@ module Eligible
     when RestClient::SSLCertificateNotVerified
       message = "Could not verify Eligible's SSL certificate."
     when SocketError
-      message = "Unexpected error communicating when trying to connect to Eligible."
+      message = 'Unexpected error communicating when trying to connect to Eligible.'
     else
-      message = "Unexpected error communicating with Eligible. If this problem persists, let us know at support@eligible.com."
+      message = 'Unexpected error communicating with Eligible. If this problem persists, let us know at support@eligible.com.'
     end
-    message += "\n\n(Network error: #{e.message})"
-    raise APIConnectionError.new(message)
+    fail APIConnectionError, "#{message}\n\n(Network error: #{e.message})"
   end
-
 end