candidhealth 0.20.1 → 0.24.0.pre.2a6d412

data/lib/candidhealth/x_12/v_1/types/remittance_advice_remark_code.rb

@@ -1,48 +1,59 @@
 # frozen_string_literal: true
 
 require_relative "rarc"
+require "ostruct"
 require "json"
 
 module CandidApiClient
   module X12
     module V1
-      class RemittanceAdviceRemarkCode
-        attr_reader :reason_code, :additional_properties
+      module Types
+        class RemittanceAdviceRemarkCode
+          # @return [CandidApiClient::X12::V1::Types::Rarc]
+          attr_reader :reason_code
+          # @return [OpenStruct] Additional properties unmapped to the current class definition
+          attr_reader :additional_properties
+          # @return [Object]
+          attr_reader :_field_set
+          protected :_field_set
 
-        # @param reason_code [X12::V1::Rarc]
-        # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
-        # @return [X12::V1::RemittanceAdviceRemarkCode]
-        def initialize(reason_code:, additional_properties: nil)
-          # @type [X12::V1::Rarc]
-          @reason_code = reason_code
-          # @type [OpenStruct] Additional properties unmapped to the current class definition
-          @additional_properties = additional_properties
-        end
+          OMIT = Object.new
 
-        # Deserialize a JSON object to an instance of RemittanceAdviceRemarkCode
-        #
-        # @param json_object [JSON]
-        # @return [X12::V1::RemittanceAdviceRemarkCode]
-        def self.from_json(json_object:)
-          struct = JSON.parse(json_object, object_class: OpenStruct)
-          JSON.parse(json_object)
-          reason_code = struct.reason_code
-          new(reason_code: reason_code, additional_properties: struct)
-        end
+          # @param reason_code [CandidApiClient::X12::V1::Types::Rarc]
+          # @param additional_properties [OpenStruct] Additional properties unmapped to the current class definition
+          # @return [CandidApiClient::X12::V1::Types::RemittanceAdviceRemarkCode]
+          def initialize(reason_code:, additional_properties: nil)
+            @reason_code = reason_code
+            @additional_properties = additional_properties
+            @_field_set = { "reason_code": reason_code }
+          end
 
-        # Serialize an instance of RemittanceAdviceRemarkCode to a JSON object
-        #
-        # @return [JSON]
-        def to_json(*_args)
-          { "reason_code": @reason_code }.to_json
-        end
+          # Deserialize a JSON object to an instance of RemittanceAdviceRemarkCode
+          #
+          # @param json_object [String]
+          # @return [CandidApiClient::X12::V1::Types::RemittanceAdviceRemarkCode]
+          def self.from_json(json_object:)
+            struct = JSON.parse(json_object, object_class: OpenStruct)
+            reason_code = struct["reason_code"]
+            new(reason_code: reason_code, additional_properties: struct)
+          end
+
+          # Serialize an instance of RemittanceAdviceRemarkCode to a JSON object
+          #
+          # @return [String]
+          def to_json(*_args)
+            @_field_set&.to_json
+          end
 
-        # Leveraged for Union-type generation, validate_raw attempts to parse the given hash and check each fields type against the current object's property definitions.
-        #
-        # @param obj [Object]
-        # @return [Void]
-        def self.validate_raw(obj:)
-          obj.reason_code.is_a?(X12::V1::Rarc) != false || raise("Passed value for field obj.reason_code is not the expected type, validation failed.")
+          # Leveraged for Union-type generation, validate_raw attempts to parse the given
+          #  hash and check each fields type against the current object's property
+          #  definitions.
+          #
+          # @param obj [Object]
+          # @return [Void]
+          def self.validate_raw(obj:)
+            obj.reason_code.is_a?(CandidApiClient::X12::V1::Types::Rarc) != false || raise("Passed value for field obj.reason_code is not the expected type, validation failed.")
+          end
         end
       end
     end

data/lib/candidhealth.rb

@@ -2,6 +2,7 @@
 
 require_relative "environment"
 require_relative "types_export"
+require_relative "core/oauth"
 require_relative "requests"
 require_relative "candidhealth/auth/client"
 require_relative "candidhealth/billing_notes/client"
@@ -10,7 +11,10 @@ require_relative "candidhealth/eligibility/client"
 require_relative "candidhealth/encounters/client"
 require_relative "candidhealth/expected_network_status/client"
 require_relative "candidhealth/exports/client"
+require_relative "candidhealth/external_payment_account_config/client"
+require_relative "candidhealth/fee_schedules/client"
 require_relative "candidhealth/guarantor/client"
+require_relative "candidhealth/import_invoice/client"
 require_relative "candidhealth/insurance_adjudications/client"
 require_relative "candidhealth/insurance_payments/client"
 require_relative "candidhealth/insurance_refunds/client"
@@ -22,108 +26,206 @@ require_relative "candidhealth/payers/client"
 require_relative "candidhealth/tasks/client"
 require_relative "candidhealth/write_offs/client"
 require_relative "candidhealth/service_facility/client"
-require_relative "candidhealth/auth/v_2/types/auth_get_token_request"
+require_relative "candidhealth/pre_encounter/client"
 
 module CandidApiClient
   class Client
-    attr_reader :auth, :billing_notes, :contracts, :eligibility, :encounters, :expected_network_status, :exports,
-                :guarantor, :insurance_adjudications, :insurance_payments, :insurance_refunds, :organization_service_facilities, :organization_providers, :patient_payments, :patient_refunds, :payers, :tasks, :write_offs, :service_facility
+    # @return [CandidApiClient::Auth::Client]
+    attr_reader :auth
+    # @return [CandidApiClient::BillingNotes::Client]
+    attr_reader :billing_notes
+    # @return [CandidApiClient::Contracts::Client]
+    attr_reader :contracts
+    # @return [CandidApiClient::Eligibility::Client]
+    attr_reader :eligibility
+    # @return [CandidApiClient::Encounters::Client]
+    attr_reader :encounters
+    # @return [CandidApiClient::ExpectedNetworkStatus::Client]
+    attr_reader :expected_network_status
+    # @return [CandidApiClient::Exports::Client]
+    attr_reader :exports
+    # @return [CandidApiClient::ExternalPaymentAccountConfig::Client]
+    attr_reader :external_payment_account_config
+    # @return [CandidApiClient::FeeSchedules::Client]
+    attr_reader :fee_schedules
+    # @return [CandidApiClient::Guarantor::Client]
+    attr_reader :guarantor
+    # @return [CandidApiClient::ImportInvoice::Client]
+    attr_reader :import_invoice
+    # @return [CandidApiClient::InsuranceAdjudications::Client]
+    attr_reader :insurance_adjudications
+    # @return [CandidApiClient::InsurancePayments::Client]
+    attr_reader :insurance_payments
+    # @return [CandidApiClient::InsuranceRefunds::Client]
+    attr_reader :insurance_refunds
+    # @return [CandidApiClient::OrganizationServiceFacilities::Client]
+    attr_reader :organization_service_facilities
+    # @return [CandidApiClient::OrganizationProviders::Client]
+    attr_reader :organization_providers
+    # @return [CandidApiClient::PatientPayments::Client]
+    attr_reader :patient_payments
+    # @return [CandidApiClient::PatientRefunds::Client]
+    attr_reader :patient_refunds
+    # @return [CandidApiClient::Payers::Client]
+    attr_reader :payers
+    # @return [CandidApiClient::Tasks::Client]
+    attr_reader :tasks
+    # @return [CandidApiClient::WriteOffs::Client]
+    attr_reader :write_offs
+    # @return [CandidApiClient::ServiceFacilityClient]
+    attr_reader :service_facility
+    # @return [CandidApiClient::PreEncounter::Client]
+    attr_reader :pre_encounter
 
-    # @param environment [Environment]
+    # @param base_url [String]
+    # @param environment [CandidApiClient::Environment]
     # @param max_retries [Long] The number of times to retry a failed request, defaults to 2.
     # @param timeout_in_seconds [Long]
-    # @param options [CandidApiAuthOptions]
-    # @return [Client]
-    def initialize(options: nil, environment: Environment::PRODUCTION, max_retries: nil, timeout_in_seconds: nil)
-      token = options.get_token(environment: environment) unless options.nil?
-
-      @request_client = RequestClient.new(environment: environment, max_retries: max_retries,
-                                          timeout_in_seconds: timeout_in_seconds, token: token)
-      @auth = Auth::Client.new(request_client: @request_client)
-      @billing_notes = BillingNotes::Client.new(request_client: @request_client)
-      @contracts = Contracts::Client.new(request_client: @request_client)
-      @eligibility = Eligibility::Client.new(request_client: @request_client)
-      @encounters = Encounters::Client.new(request_client: @request_client)
-      @expected_network_status = ExpectedNetworkStatus::Client.new(request_client: @request_client)
-      @exports = Exports::Client.new(request_client: @request_client)
-      @guarantor = Guarantor::Client.new(request_client: @request_client)
-      @insurance_adjudications = InsuranceAdjudications::Client.new(request_client: @request_client)
-      @insurance_payments = InsurancePayments::Client.new(request_client: @request_client)
-      @insurance_refunds = InsuranceRefunds::Client.new(request_client: @request_client)
-      @organization_service_facilities = OrganizationServiceFacilities::Client.new(request_client: @request_client)
-      @organization_providers = OrganizationProviders::Client.new(request_client: @request_client)
-      @patient_payments = PatientPayments::Client.new(request_client: @request_client)
-      @patient_refunds = PatientRefunds::Client.new(request_client: @request_client)
-      @payers = Payers::Client.new(request_client: @request_client)
-      @tasks = Tasks::Client.new(request_client: @request_client)
-      @write_offs = WriteOffs::Client.new(request_client: @request_client)
-      @service_facility = ServiceFacilityClient.new(request_client: @request_client)
+    # @param client_id [String]
+    # @param client_secret [String]
+    # @return [CandidApiClient::Client]
+    def initialize(client_id:, client_secret:, base_url: nil, environment: CandidApiClient::Environment::PRODUCTION, max_retries: nil,
+                   timeout_in_seconds: nil)
+      @oauth_provider = CandidApiClient::OauthTokenProvider.new(
+        client_id: client_id,
+        client_secret: client_secret,
+        request_client: CandidApiClient::RequestClient.new(
+          base_url: base_url,
+          environment: environment,
+          max_retries: max_retries,
+          timeout_in_seconds: timeout_in_seconds
+        )
+      )
+      @request_client = CandidApiClient::RequestClient.new(
+        base_url: base_url,
+        environment: environment,
+        max_retries: max_retries,
+        timeout_in_seconds: timeout_in_seconds,
+        token: @oauth_provider.method(:token)
+      )
+      @auth = CandidApiClient::Auth::Client.new(request_client: @request_client)
+      @billing_notes = CandidApiClient::BillingNotes::Client.new(request_client: @request_client)
+      @contracts = CandidApiClient::Contracts::Client.new(request_client: @request_client)
+      @eligibility = CandidApiClient::Eligibility::Client.new(request_client: @request_client)
+      @encounters = CandidApiClient::Encounters::Client.new(request_client: @request_client)
+      @expected_network_status = CandidApiClient::ExpectedNetworkStatus::Client.new(request_client: @request_client)
+      @exports = CandidApiClient::Exports::Client.new(request_client: @request_client)
+      @external_payment_account_config = CandidApiClient::ExternalPaymentAccountConfig::Client.new(request_client: @request_client)
+      @fee_schedules = CandidApiClient::FeeSchedules::Client.new(request_client: @request_client)
+      @guarantor = CandidApiClient::Guarantor::Client.new(request_client: @request_client)
+      @import_invoice = CandidApiClient::ImportInvoice::Client.new(request_client: @request_client)
+      @insurance_adjudications = CandidApiClient::InsuranceAdjudications::Client.new(request_client: @request_client)
+      @insurance_payments = CandidApiClient::InsurancePayments::Client.new(request_client: @request_client)
+      @insurance_refunds = CandidApiClient::InsuranceRefunds::Client.new(request_client: @request_client)
+      @organization_service_facilities = CandidApiClient::OrganizationServiceFacilities::Client.new(request_client: @request_client)
+      @organization_providers = CandidApiClient::OrganizationProviders::Client.new(request_client: @request_client)
+      @patient_payments = CandidApiClient::PatientPayments::Client.new(request_client: @request_client)
+      @patient_refunds = CandidApiClient::PatientRefunds::Client.new(request_client: @request_client)
+      @payers = CandidApiClient::Payers::Client.new(request_client: @request_client)
+      @tasks = CandidApiClient::Tasks::Client.new(request_client: @request_client)
+      @write_offs = CandidApiClient::WriteOffs::Client.new(request_client: @request_client)
+      @service_facility = CandidApiClient::ServiceFacilityClient.new(request_client: @request_client)
+      @pre_encounter = CandidApiClient::PreEncounter::Client.new(request_client: @request_client)
     end
   end
 
   class AsyncClient
-    attr_reader :auth, :billing_notes, :contracts, :eligibility, :encounters, :expected_network_status, :exports,
-                :guarantor, :insurance_adjudications, :insurance_payments, :insurance_refunds, :organization_service_facilities, :organization_providers, :patient_payments, :patient_refunds, :payers, :tasks, :write_offs, :service_facility
+    # @return [CandidApiClient::Auth::AsyncClient]
+    attr_reader :auth
+    # @return [CandidApiClient::BillingNotes::AsyncClient]
+    attr_reader :billing_notes
+    # @return [CandidApiClient::Contracts::AsyncClient]
+    attr_reader :contracts
+    # @return [CandidApiClient::Eligibility::AsyncClient]
+    attr_reader :eligibility
+    # @return [CandidApiClient::Encounters::AsyncClient]
+    attr_reader :encounters
+    # @return [CandidApiClient::ExpectedNetworkStatus::AsyncClient]
+    attr_reader :expected_network_status
+    # @return [CandidApiClient::Exports::AsyncClient]
+    attr_reader :exports
+    # @return [CandidApiClient::ExternalPaymentAccountConfig::AsyncClient]
+    attr_reader :external_payment_account_config
+    # @return [CandidApiClient::FeeSchedules::AsyncClient]
+    attr_reader :fee_schedules
+    # @return [CandidApiClient::Guarantor::AsyncClient]
+    attr_reader :guarantor
+    # @return [CandidApiClient::ImportInvoice::AsyncClient]
+    attr_reader :import_invoice
+    # @return [CandidApiClient::InsuranceAdjudications::AsyncClient]
+    attr_reader :insurance_adjudications
+    # @return [CandidApiClient::InsurancePayments::AsyncClient]
+    attr_reader :insurance_payments
+    # @return [CandidApiClient::InsuranceRefunds::AsyncClient]
+    attr_reader :insurance_refunds
+    # @return [CandidApiClient::OrganizationServiceFacilities::AsyncClient]
+    attr_reader :organization_service_facilities
+    # @return [CandidApiClient::OrganizationProviders::AsyncClient]
+    attr_reader :organization_providers
+    # @return [CandidApiClient::PatientPayments::AsyncClient]
+    attr_reader :patient_payments
+    # @return [CandidApiClient::PatientRefunds::AsyncClient]
+    attr_reader :patient_refunds
+    # @return [CandidApiClient::Payers::AsyncClient]
+    attr_reader :payers
+    # @return [CandidApiClient::Tasks::AsyncClient]
+    attr_reader :tasks
+    # @return [CandidApiClient::WriteOffs::AsyncClient]
+    attr_reader :write_offs
+    # @return [CandidApiClient::AsyncServiceFacilityClient]
+    attr_reader :service_facility
+    # @return [CandidApiClient::PreEncounter::AsyncClient]
+    attr_reader :pre_encounter
 
-    # @param environment [Environment]
+    # @param base_url [String]
+    # @param environment [CandidApiClient::Environment]
     # @param max_retries [Long] The number of times to retry a failed request, defaults to 2.
     # @param timeout_in_seconds [Long]
-    # @param options [CandidApiAuthOptions]
-    # @return [AsyncClient]
-    def initialize(options: nil, environment: Environment::PRODUCTION, max_retries: nil, timeout_in_seconds: nil)
-      token = options.get_token(environment: environment) unless options.nil?
-
-      @async_request_client = AsyncRequestClient.new(environment: environment, max_retries: max_retries,
-                                                     timeout_in_seconds: timeout_in_seconds, token: token)
-      @auth = Auth::AsyncClient.new(request_client: @async_request_client)
-      @billing_notes = BillingNotes::AsyncClient.new(request_client: @async_request_client)
-      @contracts = Contracts::AsyncClient.new(request_client: @async_request_client)
-      @eligibility = Eligibility::AsyncClient.new(request_client: @async_request_client)
-      @encounters = Encounters::AsyncClient.new(request_client: @async_request_client)
-      @expected_network_status = ExpectedNetworkStatus::AsyncClient.new(request_client: @async_request_client)
-      @exports = Exports::AsyncClient.new(request_client: @async_request_client)
-      @guarantor = Guarantor::AsyncClient.new(request_client: @async_request_client)
-      @insurance_adjudications = InsuranceAdjudications::AsyncClient.new(request_client: @async_request_client)
-      @insurance_payments = InsurancePayments::AsyncClient.new(request_client: @async_request_client)
-      @insurance_refunds = InsuranceRefunds::AsyncClient.new(request_client: @async_request_client)
-      @organization_service_facilities = OrganizationServiceFacilities::AsyncClient.new(request_client: @async_request_client)
-      @organization_providers = OrganizationProviders::AsyncClient.new(request_client: @async_request_client)
-      @patient_payments = PatientPayments::AsyncClient.new(request_client: @async_request_client)
-      @patient_refunds = PatientRefunds::AsyncClient.new(request_client: @async_request_client)
-      @payers = Payers::AsyncClient.new(request_client: @async_request_client)
-      @tasks = Tasks::AsyncClient.new(request_client: @async_request_client)
-      @write_offs = WriteOffs::AsyncClient.new(request_client: @async_request_client)
-      @service_facility = AsyncServiceFacilityClient.new(request_client: @async_request_client)
-    end
-  end
-
-  class CandidApiAuthOptions
-    attr_reader :token, :client_id, :client_secret
-
-    # @param token [String]
     # @param client_id [String]
     # @param client_secret [String]
-    # @return [CandidApiAuthOptions]
-    def initialize(token: nil, client_id: nil, client_secret: nil)
-       # @type [String]
-       @token = token
-       # @type [string]
-       @client_id = client_id
-       # @type [string]
-       @client_secret = client_secret
-     end
-
-
-    # @param environment [Environment]
-    def get_token(environment:)
-      unless @token.nil?
-        return @token
-      end
-
-      unauthed_client = Client.new(environment:environment)
-      response = unauthed_client.auth.v_2.get_token(request: {client_id: @client_id, client_secret: @client_secret})
-      return response.access_token
+    # @return [CandidApiClient::AsyncClient]
+    def initialize(client_id:, client_secret:, base_url: nil, environment: CandidApiClient::Environment::PRODUCTION, max_retries: nil,
+                   timeout_in_seconds: nil)
+      @oauth_provider = CandidApiClient::OauthTokenProvider.new(
+        client_id: client_id,
+        client_secret: client_secret,
+        request_client: CandidApiClient::RequestClient.new(
+          base_url: base_url,
+          environment: environment,
+          max_retries: max_retries,
+          timeout_in_seconds: timeout_in_seconds
+        )
+      )
+      @async_request_client = CandidApiClient::AsyncRequestClient.new(
+        base_url: base_url,
+        environment: environment,
+        max_retries: max_retries,
+        timeout_in_seconds: timeout_in_seconds,
+        token: token
+      )
+      @auth = CandidApiClient::Auth::AsyncClient.new(request_client: @async_request_client)
+      @billing_notes = CandidApiClient::BillingNotes::AsyncClient.new(request_client: @async_request_client)
+      @contracts = CandidApiClient::Contracts::AsyncClient.new(request_client: @async_request_client)
+      @eligibility = CandidApiClient::Eligibility::AsyncClient.new(request_client: @async_request_client)
+      @encounters = CandidApiClient::Encounters::AsyncClient.new(request_client: @async_request_client)
+      @expected_network_status = CandidApiClient::ExpectedNetworkStatus::AsyncClient.new(request_client: @async_request_client)
+      @exports = CandidApiClient::Exports::AsyncClient.new(request_client: @async_request_client)
+      @external_payment_account_config = CandidApiClient::ExternalPaymentAccountConfig::AsyncClient.new(request_client: @async_request_client)
+      @fee_schedules = CandidApiClient::FeeSchedules::AsyncClient.new(request_client: @async_request_client)
+      @guarantor = CandidApiClient::Guarantor::AsyncClient.new(request_client: @async_request_client)
+      @import_invoice = CandidApiClient::ImportInvoice::AsyncClient.new(request_client: @async_request_client)
+      @insurance_adjudications = CandidApiClient::InsuranceAdjudications::AsyncClient.new(request_client: @async_request_client)
+      @insurance_payments = CandidApiClient::InsurancePayments::AsyncClient.new(request_client: @async_request_client)
+      @insurance_refunds = CandidApiClient::InsuranceRefunds::AsyncClient.new(request_client: @async_request_client)
+      @organization_service_facilities = CandidApiClient::OrganizationServiceFacilities::AsyncClient.new(request_client: @async_request_client)
+      @organization_providers = CandidApiClient::OrganizationProviders::AsyncClient.new(request_client: @async_request_client)
+      @patient_payments = CandidApiClient::PatientPayments::AsyncClient.new(request_client: @async_request_client)
+      @patient_refunds = CandidApiClient::PatientRefunds::AsyncClient.new(request_client: @async_request_client)
+      @payers = CandidApiClient::Payers::AsyncClient.new(request_client: @async_request_client)
+      @tasks = CandidApiClient::Tasks::AsyncClient.new(request_client: @async_request_client)
+      @write_offs = CandidApiClient::WriteOffs::AsyncClient.new(request_client: @async_request_client)
+      @service_facility = CandidApiClient::AsyncServiceFacilityClient.new(request_client: @async_request_client)
+      @pre_encounter = CandidApiClient::PreEncounter::AsyncClient.new(request_client: @async_request_client)
     end
   end
-
 end

data/lib/core/oauth.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../requests"
+require_relative "../candidhealth/auth/v_2/client"
+require_relative "oauth"
+
+module CandidApiClient
+  class AccessToken
+    # @return [String]
+    attr_reader :access_token
+    # @return [Time]
+    attr_reader :expires_at
+
+    # @param access_token [String]
+    # @param expires_at [Time]
+    # @return [CandidApiClient::AccessToken]
+    def initialize(access_token:, expires_at: nil)
+      @access_token = access_token
+      @expires_at = expires_at
+    end
+  end
+
+  # Utility class for managing token refresh.
+  class OauthTokenProvider
+    # @return [String]
+    attr_reader :client_id
+    # @return [String]
+    attr_reader :client_secret
+    # @return [String]
+    attr_reader :auth_client
+
+    EXPIRY_BUFFER_MINUTES = 2
+
+    # @param client_id [String]
+    # @param client_secret [String]
+    # @param request_client [CandidApiClient::RequestClient]
+    # @return [CandidApiClient::OauthTokenProvider]
+    def initialize(client_id:, client_secret:, request_client:)
+      @client_id = client_id
+      @client_secret = client_secret
+      @auth_client = CandidApiClient::Auth::V2::V2Client.new(request_client: request_client)
+    end
+
+    # Returns a cached access token retrieved from the provided client credentials,
+    #  refreshing if necessary.
+    #
+    # @return [String]
+    def token
+      return @token.access_token if !@token.nil? && (@token.expires_at.nil? || @token.expires_at > Time.now)
+
+      @token = refresh_token
+      @token.access_token
+    end
+
+    # @return [CandidApiClient::AccessToken]
+    def refresh_token
+      token_response = @auth_client.get_token(client_id: @client_id, client_secret: @client_secret)
+      CandidApiClient::AccessToken.new(access_token: token_response.access_token,
+                                       expires_at: Time.now + token_response.expires_in - (EXPIRY_BUFFER_MINUTES * 60))
+    end
+  end
+end

data/lib/environment.rb

@@ -2,7 +2,13 @@
 
 module CandidApiClient
   class Environment
-    PRODUCTION = "https://api.joincandidhealth.com"
-    STAGING = "https://api-staging.joincandidhealth.com"
+    PRODUCTION = {
+      CandidApi: "https://api.joincandidhealth.com",
+      PreEncounter: "https://pre-api.joincandidhealth.com"
+    }.freeze
+    STAGING = {
+      CandidApi: "https://api-staging.joincandidhealth.com",
+      PreEncounter: "https://pre-api-staging.joincandidhealth.com"
+    }.freeze
   end
 end