eligible 2.3 → 2.4.1

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

@@ -0,0 +1,19 @@
+module Eligible
+  class Medicare < APIResource
+
+    class << self
+
+      def get(params, api_key=nil)
+        response, api_key = Eligible.request(:get, '/medicare/coverage.json', api_key, params)
+        Util.convert_to_eligible_object(response, api_key)
+      end
+
+      def batch_post(params, api_key=nil)
+        response, api_key = Eligible.request(:post, '/medicare/coverage/batch.json', api_key, params)
+        Util.convert_to_eligible_object(response, api_key)
+      end
+
+    end
+
+  end
+end

data/lib/eligible/payment.rb

@@ -1,16 +1,19 @@
 module Eligible
   class Payment < APIResource
 
-    def self.get(params, api_key=nil)
-      response, api_key = Eligible.request(:get, "/payment/status/#{params[:reference_id]}.json", api_key, params)
-      Util.convert_to_eligible_object(response, api_key)
-    end
+    class << self
+
+      def get(params, api_key=nil)
+        response, api_key = Eligible.request(:get, "/payment/status/#{params[:reference_id]}.json", api_key, params)
+        Util.convert_to_eligible_object(response, api_key)
+      end
+
+      def all(api_key=nil)
+        response, api_key = Eligible.request(:get, '/payment/status.json', api_key, {})
+        Util.convert_to_eligible_object(response, api_key)
+      end
 
-    def self.all(api_key=nil)
-      response, api_key = Eligible.request(:get, "/payment/status.json", api_key, {})
-      Util.convert_to_eligible_object(response, api_key)
     end
 
   end
-
 end

data/lib/eligible/ticket.rb

@@ -0,0 +1,40 @@
+module Eligible
+  class Ticket < APIResource
+
+    class << self
+
+      def create(params, api_key=nil)
+        response, api_key = Eligible.request(:post, '/tickets', api_key, params)
+        Util.convert_to_eligible_object(response, api_key)
+      end
+
+      def comments(params, api_key=nil)
+        response, api_key = Eligible.request(:post, "/tickets/#{params[:id]}/comments", api_key, params)
+        Util.convert_to_eligible_object(response, api_key)
+      end
+
+      def all
+        response, api_key = Eligible.request(:get, '/tickets', api_key)
+        Util.convert_to_eligible_object(response, api_key)
+      end
+
+      def get(params, api_key=nil)
+        response, api_key = Eligible.request(:get, "/tickets/#{params[:id]}", api_key, params)
+        Util.convert_to_eligible_object(response, api_key)
+      end
+
+      def delete(params, api_key=nil)
+        response, api_key = Eligible.request(:delete, "/tickets/#{params[:id]}", api_key, params)
+        Util.convert_to_eligible_object(response, api_key)
+      end
+      
+      def update(params, api_key=nil)
+        response, api_key = Eligible.request(:put, "/tickets/#{params[:id]}", api_key, params)
+        Util.convert_to_eligible_object(response, api_key)
+      end 
+
+    end
+
+  end
+end
+

data/lib/eligible/util.rb

@@ -1,75 +1,47 @@
 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
+          '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)
+        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
+          if resp[:enrollment_request]
+            klass = Enrollment
+          elsif resp[:demographics]
+            klass = Coverage
+          elsif resp[:subscriber] && resp[:dependent]
+            klass = Demographic
+          end
+          klass ||= EligibleObject
+          klass.construct_from(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
+          resp
       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
+        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
 

data/lib/eligible/version.rb

@@ -1,3 +1,3 @@
 module Eligible
-    VERSION = '2.3'
+  VERSION = '2.4.1'
 end

data/lib/eligible/x12.rb

@@ -2,18 +2,9 @@ module Eligible
   class X12 < APIResource
 
     def self.post(params, api_key=nil)
-      require 'net/http'
-      require 'net/https'
-      require 'uri'
-      uri = URI.parse("https://gds.eligibleapi.com")
-
-      post_args = "x12=#{params}&api_key=#{Eligible.api_key}&test=#{Eligible.test}"
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      path = "/v1.1/x12"
-      response = http.post(path, post_args)
-      Util.convert_to_eligible_object(response, Eligible.api_key)
+      response, api_key = Eligible.request(:post, '/x12', api_key, params)
+      Util.convert_to_eligible_object(response, api_key)
     end
+
   end
 end

data/test/test_eligible.rb

@@ -13,22 +13,19 @@ class TestEligible < Test::Unit::TestCase
     end
   end
 
-  context' "General API"' do
+  context '"General API"' do
     setup do
-      Eligible.api_key = 'TEST'
-      @mock = mock
-      Eligible.mock_rest_client = @mock
+      Eligible.mock_rest_client = @mock = mock
     end
 
     teardown do
-      Eligible.mock_rest_client = nil
-      Eligible.api_key = nil
+      Eligible.mock_rest_client = 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({})
+        Eligible::Coverage.get({})
       end
     end
 
@@ -37,147 +34,11 @@ class TestEligible < Test::Unit::TestCase
       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({})
+        Eligible::Coverage.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",
-        :provider_last_name => "Last",
-        :provider_first_name => "First",
-        :provider_npi => "1028384219",
-        :member_id => "W120923801",
-        :member_last_name => "Austen",
-        :member_first_name => "Jane",
-        :member_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",
-        :provider_last_name => "Last",
-        :provider_first_name => "First",
-        :provider_npi => "1028384219",
-        :member_id => "W120923801",
-        :member_last_name => "Austen",
-        :member_first_name => "Jane",
-        :member_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",
-        :provider_last_name => "Last",
-        :provider_first_name => "First",
-        :provider_npi => "1028384219",
-        :member_id => "W120923801",
-        :member_last_name => "Austen",
-        :member_first_name => "Jane",
-        :member_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",
-        :provider_last_name => "Last",
-        :provider_first_name => "First",
-        :provider_npi => "1028384219",
-        :member_id => "W120923801",
-        :member_last_name => "Austen",
-        :member_first_name => "Jane",
-        :member_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'
@@ -201,7 +62,7 @@ class TestEligible < Test::Unit::TestCase
     should 'return demographic information if valid params are supplied' do
       params = {
         :payer_name => "Aetna",
-        :payer_id   => "000001",
+        :payer_id => "000001",
         :provider_last_name => "Last",
         :provider_first_name => "First",
         :provider_npi => "1028384219",
@@ -214,34 +75,7 @@ class TestEligible < Test::Unit::TestCase
       @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",
-        :provider_last_name => "Last",
-        :provider_first_name => "First",
-        :provider_npi => "1028384219",
-        :member_id => "W120923801",
-        :member_last_name => "Austen",
-        :member_first_name => "Jane",
-        :member_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]
+      assert_not_nil demographic.to_hash
     end
   end
 
@@ -266,7 +100,7 @@ class TestEligible < Test::Unit::TestCase
     end
 
     should 'post a claim' do
-      params = {"api_key"=>"asdfsdfsd21132ddsfsdfd", "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"=>{"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", "service_start"=>"2013-03-07", "service_end"=>"2013-03-07", "authorization_code"=>"", "place_of_service"=>"11", "charge_amount"=>"275", "product_service"=>"99213", "qualifier"=>"HC", "description"=>"", "modifier_1"=>"", "diagnosis_1"=>"32723"}]}}
+      params = { "api_key" => "asdfsdfsd21132ddsfsdfd", "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" => { "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", "service_start" => "2013-03-07", "service_end" => "2013-03-07", "authorization_code" => "", "place_of_service" => "11", "charge_amount" => "275", "product_service" => "99213", "qualifier" => "HC", "description" => "", "modifier_1" => "", "diagnosis_1" => "32723" }] } }
       response = test_response(test_post_claim)
     end
   end
@@ -294,7 +128,7 @@ class TestEligible < Test::Unit::TestCase
     should 'return coverage information if valid params are supplied' do
       params = {
         :payer_name => "Aetna",
-        :payer_id   => "000001",
+        :payer_id => "000001",
         :provider_last_name => "Last",
         :provider_first_name => "First",
         :provider_npi => "1028384219",
@@ -307,7 +141,7 @@ class TestEligible < Test::Unit::TestCase
       @mock.expects(:get).returns(response)
       coverage = Eligible::Coverage.get(params)
 
-      assert_not_nil coverage.all[:eligible_id]
+      assert_not_nil coverage.to_hash[:eligible_id]
     end
   end
 
@@ -324,13 +158,13 @@ class TestEligible < Test::Unit::TestCase
     end
 
     should 'post an enrollment request' do
-      params = {"service_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"]}
+      params = { "service_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"] }
       response = test_response(test_post_enrollment)
 
       @mock.expects(:post).returns(response)
       enrollment = Eligible::Enrollment.post(params)
 
-      assert_not_nil enrollment.all[:enrollment_request]
+      assert_not_nil enrollment.to_hash[:enrollment_request]
     end
 
     should 'get the status of an enrollment request' do
@@ -338,7 +172,7 @@ class TestEligible < Test::Unit::TestCase
       response = test_response(test_get_enrollment)
       @mock.expects(:get).returns(response)
       enrollment = Eligible::Enrollment.get(params)
-      assert_not_nil enrollment.all[:enrollments]
+      assert_not_nil enrollment.to_hash[:enrollments]
     end
   end
 end