eligible 2.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/CONTRIBUTORS

@@ -0,0 +1 @@
+Andy Brett <andy@andybrett.com>

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in eligible.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Eligible
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,348 @@
+# Eligible
+
+Ruby bindings for the [Eligible API](https://eligibleapi.com/rest-api-v1)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'eligible'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself with:
+
+    $ gem install eligible
+
+## Usage
+
+### Setup
+    require 'eligible'
+    Eligible.api_key = YOUR_KEY
+
+### Format
+
+Include `{ :format => "X12" }` in the params hash to get back the raw X12 response.
+
+### Retrieve Plan object and query it
+
+```ruby
+params = {
+  :payer_name => "Aetna",
+  :payer_id   => "000001",
+  :provider_last_name => "Last",
+  :provider_first_name => "First",
+  :provider_npi => "12345678",
+  :member_id => "12345678",
+  :member_last_name => "Austen",
+  :member_first_name => "Jane",
+  :member_dob => "1955-12-14"
+}
+
+plan = Eligible::Plan.get(params)
+plan.all      # returns all fields on the plan, per the plan/all endpoint
+plan.status   # returns status fields on the plan, per the plan/status endpoint
+## Etc.: plan.deductible, plan.dates, plan.balance, plan.stop_loss 
+```
+
+### Retrieve Service object and query it
+
+```ruby
+params = {
+  :payer_name => "Aetna",
+  :payer_id   => "000001",
+  :provider_last_name => "Last",
+  :provider_first_name => "First",
+  :provider_npi => "12345678",
+  :member_id => "12345678",
+  :member_last_name => "Austen",
+  :member_first_name => "Jane",
+  :member_dob => "1955-12-14"
+}
+
+service = Eligible::Service.get(params)
+service.all     # returns all fields for the service, per service/all
+service.visits  # returns the visits for the service, per service/visits
+## Etc.: service.copayment, service.coinsurance, service.deductible
+
+## The endpoints 'general' and 'list' have a slightly different syntax than the others: 
+json = Eligible::Service.general(params)
+json = Eligible::Service.list(params)
+```
+
+### Retrieve Demographic object and query it
+
+```ruby
+params = {
+  :payer_name => "Aetna",
+  :payer_id   => "000001",
+  :provider_last_name => "Last",
+  :provider_first_name => "First",
+  :provider_npi => "12345678",
+  :member_id => "12345678",
+  :member_last_name => "Austen",
+  :member_first_name => "Jane",
+  :member_dob => "1955-12-14"
+}
+
+demographic = Eligible::Demographic.get(params)
+demographic.all # returns all fields for the demographic, per demographic/all
+demographic.zip # returns the patient's zip code, per demographic/zip
+## Etc.: demographic.employer, demographic.address, demographic.dob
+```
+
+### Retrieve Claim object
+
+```ruby
+params = {
+  :payer_name => "Aetna",
+  :payer_id => "000001",
+  :information_receiver_organization_name => "Organization",
+  :information_receiver_last_name => "Last",
+  :information_receiver_first_name => "First",
+  :information_receiver_etin => "12345678",
+  :provider_organization_name => "Marshall Group",
+  :provider_last_name => "Last",
+  :provider_first_name => "First",
+  :provider_npi => "12345678",
+  :provider_tax_id => "12345678",
+  :member_id => "12345678",
+  :member_last_name => "Last", 
+  :member_first_name => "First",
+  :member_dob => "1955-12-14",
+  :dependent_last_name => "Last",
+  :dependent_first_name => "First",
+  :dependent_dob => "1975-12-14",
+  :dependent_gender => "M",
+  :trace_number => "12345",
+  :claim_control_number => "67890",
+  :claim_charge_amount => "45.00",
+  :claim_start_date => "2013-01-05",
+  :claim_end_date => "2013-01-05"
+}    
+
+claim = Eligible::Claim.get(params)
+claim.status # Returns in real time the status (paid, not paid, rejected, denied, etc) of claim specified.
+```
+
+### Post Enrollment object
+
+```ruby
+params = {
+  "provider_list" => [
+      {
+        "facility_name" => "Quality",
+        "provider_name" => "Jane Austen",
+               "tax_id" => "12345678",
+              "address" => "125 Snow Shoe Road",
+                 "city" => "Sacramento",
+                "state" => "CA",
+                  "zip" => "94107",
+                 "ptan" => "54321",
+                  "npi" => "987654321"
+      },
+      {
+        "facility_name" => "Aetna",
+        "provider_name" => "Jack Austen",
+               "tax_id" => "12345678",
+              "address" => "985 Snow Shoe Road",
+                 "city" => "Menlo Park",
+                "state" => "CA",
+                  "zip" => "94107",
+                 "ptan" => "54321",
+                  "npi" => "987654321"
+      }
+    ],
+    "payer_ids" => [
+      "00431",
+      "00282"
+    ]
+}
+
+Eligible::Enrollment.post(params)
+```
+
+### Retrieve Enrollment object
+
+```ruby
+params = { "enrollment_request_id" => "123" }
+
+enrollment = Eligible::Enrollment.get(params)
+enrollment.status # returns the status of the request to enroll the provider(s)
+```
+
+### Retrieve Coverage object
+
+```ruby
+params = {
+  :service_type => "33",
+  :network => "OUT",
+  :payer_id   => "000001",
+  :provider_last_name => "Last",
+  :provider_first_name => "First",
+  :provider_npi => "12345678",
+  :member_id => "12345678",
+  :member_last_name => "Austen",
+  :member_first_name => "Jane",
+  :member_dob => "1955-12-14"
+}
+
+coverage = Eligible::Coverage.get(params)
+coverage.all # returns all coverage info for the request
+```
+
+### Post Claim object
+
+```ruby
+params = {
+    "api_key": "asdfsdfsd21132ddsfsdfd",
+    "receiver": {
+        "name": "AETNA",
+        "id": "60054"
+    },
+    "billing_provider": {
+        "taxonomy_code": "332B00000X",
+        "practice_name": "Jane Austen Practice",
+        "npi": "1922222222",
+        "address": {
+            "street_line_1": "419 Fulton",
+            "street_line_2": "",
+            "city": "San Francisco",
+            "state": "CA",
+            "zip": "94102"
+        },
+        "tin": "43291023",
+        "insurance_provider_id": "129873210"
+    },
+    "pay_to_provider": {
+        "address": {
+            "street_line_1": "",
+            "street_line_2": "",
+            "city": "",
+            "state": "",
+            "zip": ""
+        }
+    },
+    "subscriber": {
+        "last_name": "Franklin",
+        "first_name": "Benjamin",
+        "member_id": "W2832032427",
+        "group_id": "455716",
+        "group_name": "none",
+        "dob": "1734-05-04",
+        "gender": "M",
+        "address": {
+            "street_line_1": "435 Sugar Lane",
+            "street_line_2": "",
+            "city": "Sweet",
+            "state": "OH",
+            "zip": "436233127"
+        }
+    },
+    "payer": {
+        "name": "AETNA",
+        "id": "60054",
+        "address": {
+            "street_line_1": "Po Box 981106",
+            "street_line_2": "",
+            "city": "El Paso",
+            "state": "TX",
+            "zip": "799981222"
+        }
+    },
+    "dependent": {
+        "relationship": "",
+        "last_name": "",
+        "first_name": "",
+        "dob": "",
+        "gender": "",
+        "address": {
+            "street_line_1": "",
+            "street_line_2": "",
+            "city": "",
+            "state": "",
+            "zip": ""
+        }
+    },
+    "claim": {
+        "claim_number": "412",
+        "total_charge_amount": "275",
+        "claim_frequency": "1",
+        "patient_signature_on_file": "Y",
+        "provider_plan_participation": "A",
+        "direct_payment_authorized": "Y",
+        "release_of_information": "I",
+        "service_lines": [
+            {
+                "line_number": "1",
+                "place_of_service": "11",
+                "charge_amount": "275",
+                "product_service": "99213",
+                "qualifier": "HC",
+                "description": "",
+                "modifier_1": "",
+                "modifier_2": "",
+                "modifier_3": "",
+                "modifier_4": "",
+                "diagnosis_1": "32723",
+                "diagnosis_2": "",
+                "diagnosis_3": "",
+                "diagnosis_4": "",
+                "service_start": "2013-03-07",
+                "service_end": "2013-03-07",
+                "authorization_code": ""
+            }
+        ]
+    }
+}
+
+Eligible::Claim.post(params)
+```
+
+### Retrieve all Claim objects/acknowledgments
+
+```ruby
+claims = Eligible::Claim.all # returns status information for all claims that have been submitted with the API key
+```
+
+### Retrieve individual Claim object/acknowledgment
+
+```ruby
+params = { 
+  :response_id => "12345"
+}
+
+claim = Eligible::Claim.get(params) # returns status information on an individual claim
+```
+
+## Tests
+
+You can run tests with 
+
+```ruby
+rake test
+```
+
+If you do send a pull request, please add passing tests for the new feature/fix.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Run tests (see above)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+
+## Changelog
+
+#### 1.1
+
+- Additional endpoints for service/general and service/list
+- Support x12 format in params
+
+#### 1.0
+
+- Initial release

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new(:test)

data/eligible.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eligible/version'
+
+Gem::Specification.new do |gem|
+  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.summary       = 'Ruby wrapper for the Eligible API'
+  gem.homepage      = "https://eligibleapi.com/"
+  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.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', '~> 1.4')
+  gem.add_dependency('multi_json', '>= 1.0.4', '< 2')
+end

data/lib/eligible/api_resource.rb

@@ -0,0 +1,14 @@
+module Eligible
+  class APIResource < EligibleObject
+    def self.class_name
+      self.name.split('::')[-1]
+    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.)')
+      end
+      "/#{CGI.escape(class_name.downcase)}/all.json"
+    end
+  end
+end

data/lib/eligible/claim.rb

@@ -0,0 +1,22 @@
+module Eligible
+  class Claim < APIResource
+    def self.get(params, api_key=nil)
+      response, api_key = Eligible.request(:get, "/claims/acknowledgements/#{params[:reference_id]}.json", 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, "/claims.json", api_key, params)
+      Util.convert_to_eligible_object(response, api_key)
+    end
+
+    def self.all(api_key=nil)
+      response, api_key = Eligible.request(:get, "/claims/acknowledgements.json", api_key)
+      Util.convert_to_eligible_object(response, api_key)
+    end
+
+    def status
+      error ? nil : to_hash
+    end
+  end
+end

data/lib/eligible/coverage.rb

@@ -0,0 +1,16 @@
+module Eligible
+
+  class Coverage < 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
+
+  end
+
+end

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/enrollment.rb

@@ -0,0 +1,20 @@
+module Eligible
+
+  class Enrollment < APIResource
+
+    def self.get(params, api_key=nil)
+      response, api_key = Eligible.request(:get, "/enrollment.json", api_key, params)
+      Util.convert_to_eligible_object(response, api_key)
+    end
+
+    def self.post(params, api_key=nil)
+      response, api_key = Eligible.request(:post, "/enrollment.json", api_key, params)
+      Util.convert_to_eligible_object(response, api_key)
+    end
+
+    def all
+      error ? nil : to_hash
+    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