eligible 2.0

data/lib/eligible/errors/eligible_error.rb

@@ -0,0 +1,20 @@
+module Eligible
+  class EligibleError < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+    attr_reader :json_body
+
+    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
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      "#{status_string}#{@message}"
+    end
+  end
+end

data/lib/eligible/json.rb

@@ -0,0 +1,21 @@
+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.load(*args)
+        MultiJson.decode(*args)
+      end
+    end
+  end
+end

data/lib/eligible/plan.rb

@@ -0,0 +1,42 @@
+module Eligible
+  COMMON_ATTRIBUTES = [:timestamp, :eligible_id, :mapping_version, :primary_insurance, :additional_insurance]
+  STATUS_ATTRIBUTES = [:type, :coverage_status]
+  BALANCE_ATTRIBUTES = [:balance, :comments]
+  STOP_LOSS_ATTRIBUTES = [:stop_loss_in_network, :stop_loss_out_network]
+
+  class Plan < 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)
+    end
+
+    def all
+      error ? nil : to_hash
+    end
+
+    def status
+      keys = COMMON_ATTRIBUTES + STATUS_ATTRIBUTES
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+
+    def deductible
+      keys = COMMON_ATTRIBUTES + STATUS_ATTRIBUTES + [:deductible_in_network, :deductible_out_network]
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+
+    def dates
+      keys = COMMON_ATTRIBUTES
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+
+    def balance
+      keys = COMMON_ATTRIBUTES + BALANCE_ATTRIBUTES
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+
+    def stop_loss
+      keys = COMMON_ATTRIBUTES + STOP_LOSS_ATTRIBUTES
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+  end
+end

data/lib/eligible/service.rb

@@ -0,0 +1,59 @@
+module Eligible
+  class Service < APIResource
+    COMMON_ATTRIBUTES = [:timestamp, :eligible_id, :mapping_version, :additional_insurance]
+    STATUS_ATTRIBUTES = [:type, :coverage_status]
+    VISITS_ATTRIBUTES = [:not_covered, :comments, :precertification_needed, :visits_in_network, :visits_out_network]
+    COPAYMENT_ATTRIBUTES = [:copayment_in_network, :copayment_out_network]
+    COINSURANCE_ATTRIBUTES = [:coinsurance_in_network, :coinsurance_out_network]
+    DEDUCTIBLE_ATTRIBUTES = [:deductible_in_network, :deductible_out_network]
+
+    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 visits
+      keys = COMMON_ATTRIBUTES + STATUS_ATTRIBUTES + VISITS_ATTRIBUTES
+      k_to_hash(keys)
+    end
+
+    def copayment
+      keys = COMMON_ATTRIBUTES + STATUS_ATTRIBUTES + COPAYMENT_ATTRIBUTES
+      k_to_hash(keys)
+    end
+
+    def coinsurance
+      keys = COMMON_ATTRIBUTES + STATUS_ATTRIBUTES + COINSURANCE_ATTRIBUTES
+      k_to_hash(keys)
+    end
+
+    def deductible
+      keys = COMMON_ATTRIBUTES + STATUS_ATTRIBUTES + DEDUCTIBLE_ATTRIBUTES
+      k_to_hash(keys)
+    end
+
+    def self.general(params, api_key=nil)
+      response, api_key = Eligible.request(:get, "/service/general.json", api_key, params)
+      response = Util.convert_to_eligible_object(response, api_key)
+      response = response.to_hash if response.is_a? Hash
+      response
+    end
+
+    def self.list(params, api_key=nil)
+      response, api_key = Eligible.request(:get, "/service/list.json", api_key, params)
+      response = Util.convert_to_eligible_object(response, api_key)
+      response = response.to_hash if response.is_a? Hash
+      response
+    end
+
+    private
+
+    def k_to_hash(keys)
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+  end
+end

data/lib/eligible/util.rb

@@ -0,0 +1,109 @@
+module Eligible
+  module Util
+    def self.objects_to_ids(h)
+      case h
+      when APIResource
+        h.id
+      when Hash
+        res = {}
+        h.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
+        res
+      when Array
+        h.map { |v| objects_to_ids(v) }
+      else
+        h
+      end
+    end
+
+    def self.convert_to_eligible_object(resp, api_key)
+      types = {
+        'plan' => Plan,
+        'service' => Service,
+        'demographic' => Demographic,
+        'claim' => Claim,
+        'coverage' => Coverage,
+        'enrollment' => Enrollment
+      }
+      case resp
+      when Array
+        if resp[0] && resp[0][:enrollment_npi]
+          Enrollment.construct_from({ :enrollments => resp }, api_key)
+        else
+          resp.map { |i| convert_to_eligible_object(i, api_key) }
+        end
+      when Hash
+        # Try converting to a known object class.  If none available, fall back to generic APIResource
+        if resp[:mapping_version] && klass_name = resp[:mapping_version].match(/^[^\/]*/)[0]
+          klass = types[klass_name]
+        elsif resp[:enrollment_request]
+          klass = Enrollment
+        elsif resp[:demographics]
+          klass = Coverage
+        end
+        klass ||= EligibleObject
+        klass.construct_from(resp, api_key)
+      else
+        resp
+      end
+    end
+
+    def self.file_readable(file)
+      begin
+        File.open(file) { |f| }
+      rescue
+        false
+      else
+        true
+      end
+    end
+
+    def self.symbolize_names(object)
+      case object
+      when Hash
+        new = {}
+        object.each do |key, value|
+          key = (key.to_sym rescue key) || key
+          new[key] = symbolize_names(value)
+        end
+        new
+      when Array
+        object.map { |value| symbolize_names(value) }
+      else
+        object
+      end
+    end
+
+    def self.url_encode(key)
+      URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+    def self.flatten_params(params, parent_key=nil)
+      result = []
+      params.each do |key, value|
+        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
+        if value.is_a?(Hash)
+          result += flatten_params(value, calculated_key)
+        elsif value.is_a?(Array)
+          result += flatten_params_array(value, calculated_key)
+        else
+          result << [calculated_key, value]
+        end
+      end
+      result
+    end
+
+    def self.flatten_params_array(value, calculated_key)
+      result = []
+      value.each do |elem|
+        if elem.is_a?(Hash)
+          result += flatten_params(elem, calculated_key)
+        elsif elem.is_a?(Array)
+          result += flatten_params_array(elem, calculated_key)
+        else
+          result << ["#{calculated_key}[]", elem]
+        end
+      end
+      result
+    end
+  end
+end

data/lib/eligible/version.rb

@@ -0,0 +1,3 @@
+module Eligible
+    VERSION = "2.0"
+end

data/lib/eligible/webhook.rb

@@ -0,0 +1,16 @@
+module Eligible
+  class Webhook < APIResource
+
+    def self.all(api_key=nil)
+      response, api_key = Eligible.request(:get, url, api_key, params)
+      Util.convert_to_eligible_object(response, api_key)
+    end
+
+    def self.post(params, api_key=nil)
+      response, api_key = Eligible.request(:get, url, api_key, params)
+      Util.convert_to_eligible_object(response, api_key)
+    end
+
+  end
+
+end

data/lib/eligible.rb

@@ -0,0 +1,218 @@
+require 'cgi'
+require 'set'
+require 'rubygems'
+require 'openssl'
+require 'json' 
+
+gem 'rest-client', '~> 1.4'
+require 'rest_client'
+require 'multi_json'
+
+require 'eligible/version'
+require 'eligible/util'
+require 'eligible/json'
+require 'eligible/eligible_object'
+require 'eligible/api_resource'
+require 'eligible/plan'
+require 'eligible/service'
+require 'eligible/demographic'
+require 'eligible/claim'
+require 'eligible/enrollment'
+require 'eligible/coverage'
+
+# Errors
+require 'eligible/errors/eligible_error'
+require 'eligible/errors/api_connection_error'
+require 'eligible/errors/authentication_error'
+require 'eligible/errors/api_error'
+
+module Eligible
+  @@api_key  = nil
+  @@api_base = "https://gds.eligibleapi.com/v1.1"
+  @@api_version = 1.1
+
+  def self.api_url(url='')
+    @@api_base + url
+  end
+
+  def self.api_key
+    @@api_key
+  end
+
+  def self.api_key=(api_key)
+    @@api_key = api_key
+  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
+    }
+
+    # 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 = params.merge!({"api_key" => api_key }).to_json #Util.flatten_params(params).collect{|(key, value)| "#{key}=#{Util.url_encode(value)}"}.join('&')
+    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
+
+    headers = {
+      :user_agent => "Eligible/v1 RubyBindings/#{Eligible::VERSION}",
+      :authorization => "Bearer #{api_key}",
+      :content_type => 'application/x-www-form-urlencoded'
+    }.merge(headers)
+
+    if self.api_version
+      headers[:eligible_version] = self.api_version
+    end
+
+    opts = {
+      :method => method,
+      :url => url,
+      :headers => headers,
+      :open_timeout => 30,
+      :payload => payload,
+      :timeout => 80
+    }#.merge(ssl_opts)
+    
+    begin
+      response = execute_request(opts)
+    rescue SocketError => e
+      self.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
+    rescue RestClient::ExceptionWithResponse => e
+      if rcode = e.http_code and rbody = e.http_body
+        self.handle_api_error(rcode, rbody)
+      else
+        self.handle_restclient_error(e)
+      end
+    rescue RestClient::Exception, Errno::ECONNREFUSED => e
+      self.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 = params[:format] && params[:format].match(/x12/i) ? 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]
+  end
+
+  private
+
+  def self.execute_request(opts)
+    RestClient::Request.execute(opts)
+  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
+    rescue MultiJson::DecodeError, EligibleError
+      raise APIError.new("Invalid response object from API: #{rbody.inspect} (HTTP response code was #{rcode})", rcode, rbody)
+    end
+
+    case rcode
+    when 400, 404 then
+      raise invalid_request_error(error, rcode, rbody, error_obj)
+    when 401
+      raise authentication_error(error, rcode, rbody, error_obj)
+    else
+      raise api_error(error, 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)
+  end
+
+  def self.authentication_error(error, rcode, rbody, error_obj)
+    AuthenticationError.new(error[0][:message], rcode, rbody, error_obj)
+  end
+
+  def self.api_error(error, rcode, rbody, error_obj)
+    APIError.new(error[0][:message], rcode, rbody, error_obj)
+  end
+
+  def self.handle_restclient_error(e)
+    case e
+    when RestClient::ServerBrokeConnection, RestClient::RequestTimeout
+      message = "Could not connect to Eligible (#{@@api_base}).  Please check your internet connection and try again."
+    when RestClient::SSLCertificateNotVerified
+      message = "Could not verify Eligible's SSL certificate."
+    when SocketError
+      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."
+    end
+    message += "\n\n(Network error: #{e.message})"
+    raise APIConnectionError.new(message)
+  end
+
+end