eligible 1.0

data/lib/eligible/demographic.rb

@@ -0,0 +1,40 @@
+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) }
+    end
+
+    def dob
+      keys = COMMON_ATTRIBUTES + DOB_ATTRIBUTES
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+  end
+end

data/lib/eligible/eligible_object.rb

@@ -0,0 +1,121 @@
+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
+
+    def initialize(id=nil, api_key=nil)
+      @api_key = api_key
+      @values = {}
+      # This really belongs in APIResource, but not putting it there allows us
+      # to have a unified inspect method
+      @unsaved_values = Set.new
+      @transient_values = Set.new
+      self.eligible_id = id if id
+    end
+
+    def self.construct_from(values, api_key=nil)
+      obj = self.new(values[:eligible_id], api_key)
+      obj.refresh_from(values, api_key)
+      obj
+    end
+
+    def refresh_from(values, api_key, partial=false)
+      @api_key = api_key
+
+      removed = partial ? Set.new : Set.new(@values.keys - values.keys)
+      added = Set.new(values.keys - @values.keys)
+      # Wipe old state before setting new.  This is useful for e.g. updating a
+      # customer, where there is no persistent card parameter.  Mark those values
+      # which don't persist as transient
+
+      instance_eval do
+        remove_accessors(removed)
+        add_accessors(added)
+      end
+      removed.each do |k|
+        @values.delete(k)
+        @transient_values.add(k)
+        @unsaved_values.delete(k)
+      end
+      values.each do |k, v|
+        @values[k] = v#Util.convert_to_eligible_object(v, api_key)
+        @transient_values.delete(k)
+        @unsaved_values.delete(k)
+      end
+    end
+
+    def [](k)
+      k = k.to_sym if k.kind_of?(String)
+      @values[k]
+    end
+
+    def []=(k, v)
+      send(:"#{k}=", v)
+    end
+
+    def keys
+      @values.keys
+    end
+
+    def values
+      @values.values
+    end
+
+    def to_json(*a)
+      Eligible::JSON.dump(@values)
+    end
+
+    def to_hash
+      @values
+    end
+
+    def each(&blk)
+      @values.each(&blk)
+    end
+
+    def error
+      keys.include?(:error) ? @values[:error] : nil
+    end
+
+    protected
+
+    def metaclass
+      class << self; self; end
+    end    
+
+    def remove_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k)
+          k_eq = :"#{k}="
+          remove_method(k) if method_defined?(k)
+          remove_method(k_eq) if method_defined?(k_eq)
+        end
+      end
+    end
+
+    def add_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k)
+          k_eq = :"#{k}="
+          define_method(k) { @values[k] }
+          define_method(k_eq) do |v|
+            @values[k] = v
+            @unsaved_values.add(k)
+          end
+        end
+      end
+    end    
+  end
+
+end

data/lib/eligible/errors/api_connection_error.rb

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

data/lib/eligible/errors/api_error.rb

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

data/lib/eligible/errors/authentication_error.rb

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

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,39 @@
+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
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+
+    def copayment
+      keys = COMMON_ATTRIBUTES + STATUS_ATTRIBUTES + COPAYMENT_ATTRIBUTES
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+
+    def coinsurance
+      keys = COMMON_ATTRIBUTES + STATUS_ATTRIBUTES + COINSURANCE_ATTRIBUTES
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+
+    def deductible
+      keys = COMMON_ATTRIBUTES + STATUS_ATTRIBUTES + DEDUCTIBLE_ATTRIBUTES
+      error ? nil : to_hash.select { |k, v| keys.include?(k) }
+    end
+  end
+end

data/lib/eligible/util.rb

@@ -0,0 +1,99 @@
+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
+      }
+      case resp
+      when Array
+        resp.map { |i| convert_to_eligible_object(i, api_key) }
+      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]
+        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 = "1.0"
+end

data/test/test_eligible.rb

@@ -0,0 +1,279 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'rest-client'
+
+class TestEligible < Test::Unit::TestCase
+  include Mocha
+
+  context "Version" do
+    should "have a version number" do
+      assert_not_nil Eligible::VERSION
+    end
+  end
+
+  context "General API" do
+    setup do
+      Eligible.api_key = "TEST"
+      @mock = mock
+      Eligible.mock_rest_client = @mock
+    end
+
+    teardown do
+      Eligible.mock_rest_client = nil
+      Eligible.api_key = nil
+    end
+
+    should "not specifying api credentials should raise an exception" do
+      Eligible.api_key = nil
+      assert_raises Eligible::AuthenticationError do
+        Eligible::Plan.get({})
+      end
+    end
+
+    should "specifying invalid api credentials should raise an exception" do
+      Eligible.api_key = "invalid"
+      response = test_response(test_invalid_api_key_error, 401)
+      assert_raises Eligible::AuthenticationError do
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+        Eligible::Plan.get({})
+      end
+    end
+  end
+
+  context "Plan" do
+    setup do
+      Eligible.api_key = "TEST"
+      @mock = mock
+      Eligible.mock_rest_client = @mock
+    end
+
+    teardown do
+      Eligible.mock_rest_client = nil
+      Eligible.api_key = nil
+    end
+
+    should "return an error if no params are supplied" do
+      params = {}
+      response = test_response(test_plan_missing_params)
+      @mock.expects(:get).returns(response)
+      plan = Eligible::Plan.get(params)
+      assert_not_nil plan.error
+    end
+
+    should "return plan information if valid params are supplied" do
+      params = {
+        :payer_name => "Aetna",
+        :payer_id   => "000001",
+        :service_provider_last_name => "Last",
+        :service_provider_first_name => "First",
+        :service_provider_NPI => "1928384219",
+        :subscriber_id => "W120923801",
+        :subscriber_last_name => "Austen",
+        :subscriber_first_name => "Jane",
+        :subscriber_dob => "1955-12-14"
+      }
+      response = test_response(test_plan)
+      @mock.expects(:get).returns(response)
+      plan = Eligible::Plan.get(params)
+      assert_nil plan.error
+      assert_not_nil plan.all
+    end
+
+    should "return the right subsets of the data when requested" do
+      params = {
+        :payer_name => "Aetna",
+        :payer_id   => "000001",
+        :service_provider_last_name => "Last",
+        :service_provider_first_name => "First",
+        :service_provider_NPI => "1928384219",
+        :subscriber_id => "W120923801",
+        :subscriber_last_name => "Austen",
+        :subscriber_first_name => "Jane",
+        :subscriber_dob => "1955-12-14"
+      }
+      response = test_response(test_plan)
+      @mock.expects(:get).returns(response)
+      plan = Eligible::Plan.get(params)
+
+      assert_not_nil  plan.all[:primary_insurance]
+      assert_not_nil  plan.status[:coverage_status]
+      assert_nil      plan.status[:deductible_in_network]
+      assert_not_nil  plan.deductible[:deductible_in_network]
+      assert_nil      plan.deductible[:balance]
+      assert_not_nil  plan.dates[:primary_insurance][:plan_begins]
+      assert_nil      plan.dates[:deductible_in_network]
+      assert_not_nil  plan.balance[:balance]
+      assert_nil      plan.balance[:deductible_in_network]
+      assert_not_nil  plan.stop_loss[:stop_loss_in_network]
+      assert_nil      plan.stop_loss[:deductible_in_network]
+    end
+  end
+
+  context "Service" do
+    setup do
+      Eligible.api_key = "TEST"
+      @mock = mock
+      Eligible.mock_rest_client = @mock
+    end
+
+    teardown do
+      Eligible.mock_rest_client = nil
+      Eligible.api_key = nil
+    end
+
+    should "return an error if no params are supplied" do
+      params = {}
+      response = test_response(test_service_missing_params)
+      @mock.expects(:get).returns(response)
+      service = Eligible::Service.get(params)
+      assert_not_nil service.error
+    end
+
+    should "return eligibility information if valid params are supplied" do
+      params = {
+        :payer_name => "Aetna",
+        :payer_id   => "000001",
+        :service_provider_last_name => "Last",
+        :service_provider_first_name => "First",
+        :service_provider_NPI => "1928384219",
+        :subscriber_id => "W120923801",
+        :subscriber_last_name => "Austen",
+        :subscriber_first_name => "Jane",
+        :subscriber_dob => "1955-12-14"
+      }
+      response = test_response(test_service)
+      @mock.expects(:get).returns(response)
+      service = Eligible::Service.get(params)
+      assert_nil service.error
+      assert_not_nil service.all
+    end
+
+    should "return the right subsets of the data when requested" do
+      params = {
+        :payer_name => "Aetna",
+        :payer_id   => "000001",
+        :service_provider_last_name => "Last",
+        :service_provider_first_name => "First",
+        :service_provider_NPI => "1928384219",
+        :subscriber_id => "W120923801",
+        :subscriber_last_name => "Austen",
+        :subscriber_first_name => "Jane",
+        :subscriber_dob => "1955-12-14"
+      }
+      response = test_response(test_service)
+      @mock.expects(:get).returns(response)
+      service = Eligible::Service.get(params)
+
+      assert_not_nil  service.all[:service_begins]
+      assert_not_nil  service.visits[:visits_in_network]
+      assert_nil      service.visits[:copayment_in_network]
+      assert_not_nil  service.copayment[:copayment_in_network]
+      assert_nil      service.copayment[:visits_in_network]
+      assert_not_nil  service.coinsurance[:coinsurance_in_network]
+      assert_nil      service.coinsurance[:visits_in_network]
+      assert_not_nil  service.deductible[:deductible_in_network]
+      assert_nil      service.deductible[:visits_in_network]
+    end
+  end
+
+  context "Demographic" do
+    setup do
+      Eligible.api_key = "TEST"
+      @mock = mock
+      Eligible.mock_rest_client = @mock
+    end
+
+    teardown do
+      Eligible.mock_rest_client = nil
+      Eligible.api_key = nil
+    end
+
+    should "return an error if no params are supplied" do
+      params = {}
+      response = test_response(test_demographic_missing_params)
+      @mock.expects(:get).returns(response)
+      demographic = Eligible::Demographic.get(params)
+      assert_not_nil demographic.error
+    end
+
+    should "return demographic information if valid params are supplied" do
+      params = {
+        :payer_name => "Aetna",
+        :payer_id   => "000001",
+        :service_provider_last_name => "Last",
+        :service_provider_first_name => "First",
+        :service_provider_NPI => "1928384219",
+        :subscriber_id => "W120923801",
+        :subscriber_last_name => "Austen",
+        :subscriber_first_name => "Jane",
+        :subscriber_dob => "1955-12-14"
+      }
+      response = test_response(test_demographic)
+      @mock.expects(:get).returns(response)
+      demographic = Eligible::Demographic.get(params)
+      assert_nil demographic.error
+      assert_not_nil demographic.all
+    end
+
+    should "return the right subsets of the data when requested" do
+      params = {
+        :payer_name => "Aetna",
+        :payer_id   => "000001",
+        :service_provider_last_name => "Last",
+        :service_provider_first_name => "First",
+        :service_provider_NPI => "1928384219",
+        :subscriber_id => "W120923801",
+        :subscriber_last_name => "Austen",
+        :subscriber_first_name => "Jane",
+        :subscriber_dob => "1955-12-14"
+      }
+      response = test_response(test_demographic)
+      @mock.expects(:get).returns(response)
+      demographic = Eligible::Demographic.get(params)
+
+      assert_not_nil  demographic.all[:timestamp]
+      assert_not_nil  demographic.zip[:zip]
+      assert_nil      demographic.zip[:group_id]
+      assert_not_nil  demographic.employer[:group_id]
+      assert_nil      demographic.employer[:zip]
+      assert_not_nil  demographic.address[:address]
+      assert_nil      demographic.address[:group_id]
+      assert_not_nil  demographic.dob[:dob]
+      assert_nil      demographic.dob[:address]
+    end
+  end
+
+  context "Claim" do
+    setup do
+      Eligible.api_key = "TEST"
+      @mock = mock
+      Eligible.mock_rest_client = @mock
+    end
+
+    teardown do
+      Eligible.mock_rest_client = nil
+      Eligible.api_key = nil
+    end
+
+    should "return an error if no params are supplied" do
+      params = {}
+      response = test_response(test_claim_missing_params)
+      @mock.expects(:get).returns(response)
+      claim = Eligible::Claim.get(params)
+      assert_not_nil claim.error
+    end
+
+    should "return claim information if valid params are supplied" do
+      params = {
+        :tbd => true
+      }
+      response = test_response(test_claim)
+      @mock.expects(:get).returns(response)
+      claim = Eligible::Claim.get(params)
+      assert_nil claim.error
+      assert_not_nil claim.status
+    end
+  end
+end