davinci_pas_test_kit 0.11.1 → 0.12.1

data/lib/davinci_pas_test_kit/jobs/send_subscription_handshake.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require_relative '../tags'
+require 'subscriptions_test_kit'
+
+module DaVinciPASTestKit
+  module Jobs
+    class SendSubscriptionHandshake
+      include Sidekiq::Job
+      include SubscriptionsTestKit::SubscriptionsR5BackportR4Client::SubscriptionSimulationUtils
+
+      sidekiq_options retry: false
+
+      def perform(test_run_id, test_session_id, result_id, subscription_id, subscription_url, client_endpoint,
+                  bearer_token, notification_json, test_run_identifier, test_suite_base_url)
+        @test_run_id = test_run_id
+        @test_session_id = test_session_id
+        @result_id = result_id
+        @subscription_id = subscription_id
+        @subscription_url = subscription_url
+        @client_endpoint = client_endpoint
+        @bearer_token = bearer_token
+        @notification_json = notification_json.present? ? notification_json : default_notification_base_json
+        @test_run_identifier = test_run_identifier
+        @test_suite_base_url = test_suite_base_url
+
+        await_subscription_creation
+        sleep 1
+        return unless test_still_waiting?
+
+        send_handshake_notification
+        test_suite_connection.get(RESUME_PASS_PATH.delete_prefix('/'), { token: @test_run_identifier })
+      end
+
+      def default_notification_base_json
+        FHIR::Bundle.new(
+          timestamp: Time.now.utc.iso8601,
+          type: 'history',
+          entry: [
+            FHIR::Bundle::Entry.new(fullUrl: "urn:uuid:#{SecureRandom.uuid}",
+                                    resource: FHIR.from_contents(default_handshake_parameters_base_json))
+          ]
+        ).to_json
+      end
+
+      def default_handshake_parameters_base_json
+        '{ "parameter": [ { "name": "subscription", "valueReference": { "reference": "replace_with_subscription_ref" } }, { "name": "topic", "valueCanonical": "replace_with_topic_canonical" }, { "name": "status", "valueCode": "requested" }, { "name": "type", "valueCode": "handshake" }, { "name": "events-since-subscription-start", "valueString": "0" } ], "resourceType": "Parameters" }' # rubocop:disable Layout/LineLength
+      end
+
+      def requests_repo
+        @requests_repo ||= Inferno::Repositories::Requests.new
+      end
+
+      def results_repo
+        @results_repo ||= Inferno::Repositories::Results.new
+      end
+
+      def subscription
+        @subscription ||= find_subscription(@test_session_id)
+      end
+
+      def headers
+        @headers ||= subscription_headers.merge(content_type_header).merge(authorization_header)
+      end
+
+      def rest_hook_connection
+        @rest_hook_connection ||= Faraday.new(url: @client_endpoint, request: { open_timeout: 30 }, headers:)
+      end
+
+      def test_suite_connection
+        @test_suite_connection ||= Faraday.new(@test_suite_base_url)
+      end
+
+      def content_type_header
+        @content_type_header ||= { 'Content-Type' => actual_mime_type(subscription) }
+      end
+
+      def subscription_headers
+        return {} unless subscription.present?
+
+        @subscription_headers ||= subscription.channel&.header&.each_with_object({}) do |header, hash|
+          header_name, header_value = header.split(': ', 2)
+          hash[header_name] = header_value
+        end || {}
+      end
+
+      def subscription_topic
+        @subscription_topic ||= subscription&.criteria
+      end
+
+      def authorization_header
+        @authorization_header ||= @bearer_token.present? ? { 'Authorization' => "Bearer #{@bearer_token}" } : {}
+      end
+
+      def test_still_waiting?
+        results_repo.find_waiting_result(test_run_id: @test_run_id)
+      end
+
+      def await_subscription_creation
+        sleep 0.5 until subscription.present?
+      end
+
+      def send_handshake_notification
+        handshake_json = derive_handshake_notification(@notification_json, @subscription_url,
+                                                       subscription_topic).to_json
+        response = send_notification(handshake_json)
+        persist_notification_request(response, [REST_HOOK_HANDSHAKE_NOTIFICATION_TAG])
+        response
+      end
+
+      def send_notification(request_body)
+        rest_hook_connection.post('', request_body)
+      rescue Faraday::Error => e
+        # Warning: This is a hack. If there is an error with the request such that we never get a response, we have
+        #          no clean way to persist that information for the Inferno test to check later. The solution here
+        #          is to persist the request anyway with a status of nil, using the error message as response body
+        Faraday::Response.new(response_body: e.message, url: rest_hook_connection.url_prefix.to_s)
+      end
+
+      def persist_notification_request(response, tags)
+        inferno_request_headers = headers.map { |name, value| { name:, value: } }
+        inferno_response_headers = response.headers&.map { |name, value| { name:, value: } }
+        requests_repo.create(
+          verb: 'POST',
+          url: response.env.url.to_s,
+          direction: 'outgoing',
+          status: response.status,
+          request_body: response.env.request_body,
+          response_body: response.env.response_body,
+          test_session_id: @test_session_id,
+          result_id: @result_id,
+          request_headers: inferno_request_headers,
+          response_headers: inferno_response_headers,
+          tags:
+        )
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/metadata.rb

@@ -0,0 +1,87 @@
+require_relative 'version'
+
+module DaVinciPASTestKit
+  class Metadata < Inferno::TestKit
+    id :davinci_pas_test_kit
+    title 'Da Vinci Prior Authorization Support (PAS) Test Kit'
+    description <<~DESCRIPTION
+      The Da Vinci Prior Authorization Support (PAS) Test Kit validates
+      the conformance of both PAS client and server implementations to
+      [version 2.0.1 of the Da Vinci PAS Implementation
+      Guide](https://hl7.org/fhir/us/davinci-pas/STU2/).
+
+      <!-- break -->
+
+      To validate the behavior of a system Inferno will act as the partner to the
+      system under test:
+      - **When testing a client**: Inferno will act as a server, awaiting requests
+        from the client under test, returning appropriate responses, and validating
+        the conformance of the client's requests and its ability to handle the
+        responses appropriately.
+      - **When testing a server**: Inferno will act as a client, making requests
+        against the server under test and validating the conformance and
+        appropriateness of the server's responses.
+
+      The test suites for both PAS clients and servers follow the same basic outline,
+      each testing:
+
+      - The implementation's ability to use PAS-defined APIs to participate in the
+        submission of and decision on a prior authorization request, including:
+        - Approval of a prior authorization request.
+        - Denial of a prior authorization request.
+        - Pending of a prior authorization request and a subsequent final decision.
+      - The implementation ability to provide and handle data covering the full scope
+        of PAS must support requirements on:
+        - Prior authorization submissions.
+        - Prior authorization inquiries.
+
+      The Da Vinci PAS Test Kit is built using the [Inferno
+      Framework](https://inferno-framework.github.io/). The Inferno Framework is
+      designed for reuse and aims to make it easier to build test kits for any
+      FHIR-based data exchange.
+
+      ## Known Limitations
+
+      The following areas of the IG are not fully tested in this draft version of the test kit:
+
+      - Private X12 details including value set expansions
+      - The use of Subscriptions to alert clients of updates to pended requests
+      - Prior Authorization update workflows
+      - Requests for additional information handled through the CDex framework
+      - PDF, CDA, and JPG attachments
+      - US Core profile support for supporting information
+      - Server inquiry matching and subsetting logic
+      - Server inquiry requests from non-submitting systems
+      - Server collection of metrics
+      - Client handling of responses containing all PAS-defined profiles and must support elements
+      - Client handling of situations that requiring manual review of the client system,
+        e.g., the requirement that clinicians can update details of the prior authorization
+        request before submitting them
+
+      For additional details on these and other areas where the tests may not align with
+      the IGs requirements, see documentation in the test kit source code ([client](https://github.com/inferno-framework/davinci-pas-test-kit/blob/main/lib/davinci_pas_test_kit/docs/client_suite_description_v201.md#testing-limitations), [server](https://github.com/inferno-framework/davinci-pas-test-kit/blob/main/lib/davinci_pas_test_kit/docs/server_suite_description_v201.md#testing-limitations)), and [this requirements analysis
+      spreadsheet](https://github.com/inferno-framework/davinci-pas-test-kit/blob/main/lib/davinci_pas_test_kit/docs/PAS%20Requirements%20Interpretation.xlsx).
+
+      ### Known IG Issues
+
+      Through testing with this test kit, issues have been identified in the version of the PAS
+      specification that this test kit tests against which cause false failures. The full list
+      of known issues can be found on the [repository's issues page with the 'source ig issue'
+      lable](https://github.com/inferno-framework/davinci-pas-test-kit/labels/source%20ig%20issue).
+
+      ## Reporting Issues
+
+      Please report any issues with this set of tests in the [GitHub
+      Issues](https://github.com/inferno-framework/davinci-pas-test-kit/issues)
+      section of the
+      [open source code repository](https://github.com/inferno-framework/davinci-pas-test-kit).
+    DESCRIPTION
+    suite_ids [:davinci_pas_server_suite_v201, :davinci_pas_client_suite_v201]
+    tags ['Da Vinci', 'PAS']
+    last_updated LAST_UPDATED
+    version VERSION
+    maturity 'Low'
+    authors ['Inferno Team']
+    repo 'https://github.com/inferno-framework/davinci-pas-test-kit'
+  end
+end

data/lib/davinci_pas_test_kit/pas_bundle_validation.rb

@@ -171,7 +171,7 @@ module DaVinciPASTestKit
       bundle_entry = bundle.entry
 
       root_entry = bundle_entry.find do |entry|
-        entry.resource.resourceType == 'Claim' || entry.resource.resourceType == 'ClaimResponse'
+        ['Claim', 'ClaimResponse'].include?(entry.resource.resourceType)
       end
 
       if root_entry.present?
@@ -331,7 +331,9 @@ module DaVinciPASTestKit
     # @param bundle_entry [Array] The bundle.entry contents.
     # @param version [String] The IG version.
     def add_declared_profiles(instance, bundle_entry, version)
-      instance.resource&.meta&.profile&.each do |url|
+      return unless instance.resource.present?
+
+      instance.resource.meta&.profile&.each do |url|
         next if bundle_resources_target_profile_map[instance.fullUrl][:profile_urls].include?(url)
 
         bundle_resources_target_profile_map[instance.fullUrl][:profile_urls] << url
@@ -462,11 +464,10 @@ module DaVinciPASTestKit
         return if ref.blank?
 
         absolute_ref = absolute_url(ref, base_url)
-        resource_type, resource_id = ref.split('/')
         matching_resources = resources_to_match.find_all { |res| res.fullUrl == absolute_ref }
 
         if matching_resources.length != 1
-          validation_error_messages << resource_shall_appear_once_message(resource_type, resource_id,
+          validation_error_messages << resource_shall_appear_once_message(absolute_ref,
                                                                           matching_resources.length)
         end
 
@@ -525,10 +526,10 @@ module DaVinciPASTestKit
     #
     # This method generates an error message when a referenced resource appears more than once
     # in a FHIR bundle, which is not allowed.
-    def resource_shall_appear_once_message(reference_resource_type, reference_resource_id, total_matches)
+    def resource_shall_appear_once_message(absolute_ref, total_matches)
       "
-        The referenced #{reference_resource_type}/#{reference_resource_id} resource
-        SHALL only appear once in the Bundle, but found #{total_matches}.
+        The referenced #{absolute_ref} resource
+        SHALL appear exactly once in the Bundle, but found #{total_matches}.
       "
     end
 

data/lib/davinci_pas_test_kit/response_generator.rb

@@ -0,0 +1,397 @@
+module DaVinciPASTestKit
+  module ResponseGenerator
+    def mock_id_only_notification_bundle(submit_response, subscription_reference, subscription_topic)
+      notification_timestamp = Time.now.utc
+      mock_notification_bundle = build_mock_notification_bundle(notification_timestamp, subscription_reference,
+                                                                subscription_topic, submit_response, 'id-only', nil)
+      mock_notification_bundle.to_json
+    end
+
+    def mock_full_resource_notification_bundle(submit_response, subscription_reference, subscription_topic, decision)
+      notification_timestamp = Time.now.utc
+      mock_notification_bundle = build_mock_notification_bundle(notification_timestamp, subscription_reference,
+                                                                subscription_topic, submit_response, 'full-resource',
+                                                                decision)
+      mock_notification_bundle.to_json
+    end
+
+    def mock_response_bundle(request_bundle, operation, decision, claim_response_uuid = nil)
+      mocked_timestamp = Time.now.utc
+      build_mock_response_bundle(request_bundle, operation, decision, mocked_timestamp, claim_response_uuid)&.to_json
+    end
+
+    # update things that tester cannot get right themselves
+    # - timestamps on the Bundle and ClaimResponse (can't predict the processing time)
+    # - reference to the submitted Claim (may not have control of created id). NOTE: this is likely
+    #   incomplete - when the Claim is included, there are other things that
+    #   need to be in the Bundle that may also not be controlled
+    def update_tester_provided_response(user_inputted_response, claim_full_url)
+      response_bundle = FHIR.from_contents(user_inputted_response)
+      return user_inputted_response unless response_bundle.present?
+
+      now = Time.now.utc
+      response_bundle.timestamp = now.iso8601 if response_bundle&.timestamp.present?
+      claim_response_entry = response_bundle&.entry&.find { |e| e&.resource&.resourceType == 'ClaimResponse' }
+      if claim_response_entry.present?
+        claim_response_entry.resource.created = now.iso8601 if claim_response_entry.resource.created
+        if claim_response_entry.resource.request.present? && claim_full_url.present?
+          claim_response_entry.resource.request.reference = claim_full_url
+        end
+      end
+      response_bundle.to_json
+    end
+
+    # update things that tester cannot get right themselves
+    # - reference to the ClaimResponse in the case that it is generated by Inferno.
+    #   If the tester provided the ClaimResponse, they are responsible for aligning
+    #   the notification with it.
+    # - notification timestamps
+    def update_tester_provided_notification(user_inputted_notification, generated_claim_response_uuid)
+      now = Time.now.utc
+
+      notification_bundle = FHIR.from_contents(user_inputted_notification)
+      subscription_status_entry = notification_bundle&.entry&.find { |e| e.resource&.resourceType == 'Parameters' }
+      subscription_status_resource = subscription_status_entry&.resource
+      event_parameter = subscription_status_resource&.parameter&.find { |p| p.name == 'notification-event' }
+
+      if generated_claim_response_uuid.present?
+        claim_response_full_url = "urn:uuid:#{generated_claim_response_uuid}"
+        focus_part = event_parameter&.part&.find { |pt| pt.name == 'focus' }
+        if focus_part.present?
+          existing_claim_response_reference = focus_part.valueReference&.reference
+          focus_part.valueReference.reference = claim_response_full_url
+          update_tester_provided_notification_claim_response_entry(notification_bundle,
+                                                                   generated_claim_response_uuid,
+                                                                   claim_response_full_url,
+                                                                   existing_claim_response_reference)
+
+        end
+      end
+
+      timestamp_part = event_parameter&.part&.find { |pt| pt.name == 'timestamp' }
+      timestamp_part.valueInstant = now.iso8601 if timestamp_part.present?
+      notification_bundle.timestamp = now.iso8601 if notification_bundle.timestamp.present?
+
+      notification_bundle.to_json
+    end
+
+    private
+
+    # if there's a ClaimResponse entry (full-resource or id-only without the resource contents)
+    # then update the fullUrl and id
+    def update_tester_provided_notification_claim_response_entry(notification_bundle, claim_response_id,
+                                                                 claim_response_full_url,
+                                                                 existing_claim_response_reference)
+      claim_response_entry = notification_bundle&.entry&.find { |e| e.resource&.resourceType == 'ClaimResponse' }
+      if claim_response_entry.blank? && existing_claim_response_reference.present?
+        claim_response_entry = notification_bundle&.entry&.find { |e| e.fullUrl == existing_claim_response_reference }
+      end
+      return unless claim_response_entry.present?
+
+      claim_response_entry.fullUrl = claim_response_full_url
+      return unless claim_response_entry.resource.present?
+
+      claim_response_entry.resource.id = claim_response_id
+    end
+
+    def build_mock_notification_bundle(notification_timestamp, subscription_reference, subscription_topic,
+                                       submit_response, type, decision)
+      submit_bundle = FHIR.from_contents(submit_response)
+      claim_response_full_url = claim_response_full_url_from_submit_response_bundle(submit_bundle)
+      mock_notification_bundle = FHIR::Bundle.new(
+        id: SecureRandom.uuid,
+        timestamp: notification_timestamp.iso8601,
+        type: 'history'
+      )
+
+      additional_context_references =
+        if type == 'full-resource' && submit_bundle.present? && submit_bundle.is_a?(FHIR::Bundle)
+          submit_bundle.entry.reject { |entry| entry.resource&.resourceType == 'ClaimResponse' }.map(&:fullUrl).compact
+        else
+          []
+        end
+      mock_notification_status = build_mock_notification_status(notification_timestamp, subscription_reference,
+                                                                subscription_topic, claim_response_full_url,
+                                                                additional_context_references)
+      mock_notification_bundle.entry << build_mock_notification_status_entry(mock_notification_status,
+                                                                             subscription_reference)
+      if type == 'full-resource' && submit_bundle.present? && submit_bundle.is_a?(FHIR::Bundle)
+        fhir_base_url = extract_fhir_base_url(subscription_reference)
+        submit_bundle.entry.each do |entry|
+          update_claim_response_decisions(entry.resource, decision) if entry.resource.resourceType == 'ClaimResponse'
+          entry.request = FHIR::Bundle::Entry::Request.new(
+            method: 'POST',
+            url: "#{fhir_base_url}/#{entry.resource.resourceType}"
+          )
+          entry.response = FHIR::Bundle::Entry::Response.new(
+            status: '201'
+          )
+          mock_notification_bundle.entry << entry
+        end
+      end
+
+      mock_notification_bundle
+    end
+
+    def update_claim_response_decisions(claim_response, decision)
+      claim_response&.item&.each do |item|
+        item.adjudication.each do |adjudication|
+          review_action_extension = adjudication.extension.find do |ext|
+            ext.url == 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-reviewAction'
+          end
+          review_code_extension = review_action_extension&.extension&.find do |ext|
+            ext.url == 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-reviewActionCode'
+          end
+          next unless review_code_extension.present?
+
+          review_code_extension.valueCodeableConcept = FHIR::CodeableConcept.new(
+            coding: [
+              get_review_action_code(decision)
+            ]
+          )
+        end
+      end
+    end
+
+    def build_mock_response_bundle(request_bundle, operation, decision, timestamp, claim_response_uuid = nil)
+      claim_entry = request_bundle&.entry&.find { |e| e&.resource&.resourceType == 'Claim' }
+      claim_full_url = claim_entry&.fullUrl
+      return nil if claim_entry.blank? || claim_full_url.blank?
+
+      root_url = extract_fhir_base_url(claim_full_url)
+      mocked_claim_response = build_mock_claim_response(claim_entry.resource, request_bundle, root_url, operation,
+                                                        decision, timestamp, claim_response_uuid)
+      build_mock_bundle(mocked_claim_response, request_bundle, root_url, operation, timestamp)
+    end
+
+    # Note that references from the claim to other resources in the bundle need to be changed to absolute URLs
+    # if they are relative, because the ClaimResponse's fullUrl is a urn:uuid
+    #
+    # @private
+    def build_mock_claim_response(claim, request_bundle, root_url, operation, decision, timestamp,
+                                  claim_response_uuid = nil)
+      claim_response_uuid = SecureRandom.uuid if claim_response_uuid.blank?
+      return FHIR::ClaimResponse.new(id: claim_response_uuid) if claim.blank?
+
+      FHIR::ClaimResponse.new(
+        id: claim_response_uuid,
+        meta: FHIR::Meta.new(profile: if operation == 'submit'
+                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-claimresponse'
+                                      else
+                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-claiminquiryresponse'
+                                      end),
+        identifier: claim.identifier,
+        type: claim.type,
+        status: claim.status,
+        use: claim.use,
+        patient: absolute_reference(claim.patient, request_bundle.entry, root_url),
+        created: timestamp.iso8601,
+        insurer: absolute_reference(claim.insurer, request_bundle.entry, root_url),
+        requestor: absolute_reference(claim.provider, request_bundle.entry, root_url),
+        outcome: 'complete',
+        item: claim.item.map do |item|
+          FHIR::ClaimResponse::Item.new(
+            extension: [
+              FHIR::Extension.new(
+                url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-itemPreAuthIssueDate',
+                valueDate: timestamp.strftime('%Y-%m-%d')
+              ),
+              FHIR::Extension.new(
+                url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-itemPreAuthPeriod',
+                valuePeriod: FHIR::Period.new(start: timestamp.strftime('%Y-%m-%d'),
+                                              end: (timestamp + 1.month).strftime('%Y-%m-%d'))
+              )
+            ],
+            itemSequence: item.sequence,
+            adjudication: [
+              FHIR::ClaimResponse::Item::Adjudication.new(
+                extension: [
+                  FHIR::Extension.new(
+                    url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-reviewAction',
+                    extension: [
+                      FHIR::Extension.new(
+                        url: 'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/extension-reviewActionCode',
+                        valueCodeableConcept: FHIR::CodeableConcept.new(
+                          coding: [
+                            get_review_action_code(decision)
+                          ]
+                        )
+                      )
+                    ]
+                  )
+                ],
+                category: FHIR::CodeableConcept.new(
+                  coding: [
+                    FHIR::Coding.new(system: 'http://terminology.hl7.org/CodeSystem/adjudication', code: 'submitted')
+                  ]
+                )
+              )
+            ]
+          )
+        end
+      )
+    end
+
+    def build_mock_bundle(claim_response, request_bundle, root_url, operation, timestamp)
+      response_bundle = FHIR::Bundle.new(
+        id: SecureRandom.uuid,
+        meta: FHIR::Meta.new(profile: if operation == 'submit'
+                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-response-bundle'
+                                      else
+                                        'http://hl7.org/fhir/us/davinci-pas/StructureDefinition/profile-pas-inquiry-response-bundle'
+                                      end),
+        timestamp: timestamp.iso8601,
+        type: 'collection',
+        entry: [
+          FHIR::Bundle::Entry.new(fullUrl: "urn:uuid:#{claim_response.id}",
+                                  resource: claim_response)
+        ]
+      )
+      response_bundle.entry.concat(referenced_entities(claim_response, request_bundle.entry, root_url))
+      response_bundle
+    end
+
+    def build_mock_notification_status_entry(status_parameters, subscription_reference)
+      FHIR::Bundle::Entry.new(fullUrl: "urn:uuid:#{SecureRandom.uuid}",
+                              resource: status_parameters,
+                              request: FHIR::Bundle::Entry::Request.new(
+                                method: 'GET',
+                                url: "#{subscription_reference}/$status"
+                              ),
+                              response: FHIR::Bundle::Entry::Response.new(
+                                status: '200'
+                              ))
+    end
+
+    def build_mock_notification_status(timestamp, subscription_reference, subscription_topic, claim_response_reference,
+                                       additional_context_references)
+      status_parameters = FHIR::Parameters.new
+      status_parameters.parameter << FHIR::Parameters::Parameter.new(
+        name: 'subscription',
+        valueReference: FHIR::Reference.new(
+          reference: subscription_reference
+        )
+      )
+      status_parameters.parameter << FHIR::Parameters::Parameter.new(
+        name: 'topic',
+        valueCanonical: subscription_topic
+      )
+      status_parameters.parameter << FHIR::Parameters::Parameter.new(
+        name: 'status',
+        valueCode: 'active'
+      )
+      status_parameters.parameter << FHIR::Parameters::Parameter.new(
+        name: 'type',
+        valueCode: 'event-notification'
+      )
+      status_parameters.parameter << FHIR::Parameters::Parameter.new(
+        name: 'events-since-subscription-start',
+        valueString: '1'
+      )
+      if claim_response_reference.present?
+        event = FHIR::Parameters::Parameter.new(
+          name: 'notification-event'
+        )
+        status_parameters.parameter << event
+        event.part << FHIR::Parameters::Parameter.new(
+          name: 'event-number',
+          valueString: '1'
+        )
+        event.part << FHIR::Parameters::Parameter.new(
+          name: 'timestamp',
+          valueInstant: timestamp.iso8601
+        )
+        event.part << FHIR::Parameters::Parameter.new(
+          name: 'focus',
+          valueReference: FHIR::Reference.new(
+            reference: claim_response_reference
+          )
+        )
+        additional_context_references&.each do |reference|
+          event.part << FHIR::Parameters::Parameter.new(
+            name: 'additional-context',
+            valueReference: FHIR::Reference.new(
+              reference:
+            )
+          )
+        end
+      end
+      status_parameters
+    end
+
+    def get_review_action_code(decision)
+      case decision
+      when :denial
+        code = 'A3'
+        display = 'Not Certified'
+      when :pended
+        code = 'A4'
+        display = 'Pending'
+      else # approval or no workflow
+        code = 'A1'
+        display = 'Certified in total'
+      end
+      FHIR::Coding.new(
+        system: 'https://codesystem.x12.org/005010/306',
+        code:,
+        display:
+      )
+    end
+
+    def absolute_reference(ref, entries, root_url)
+      url = find_matching_entry(ref&.reference, entries, root_url)&.fullUrl
+      ref.reference = url if url
+      ref
+    end
+
+    def referenced_entities(resource, entries, root_url)
+      matches = []
+      attributes = resource&.source_hash&.keys
+      attributes.each do |attr|
+        value = resource.send(attr.to_sym)
+        if value.is_a?(FHIR::Reference) && value.reference.present?
+          match = find_matching_entry(value.reference, entries, root_url)
+          if match.present? && matches.none?(match)
+            value.reference = match.fullUrl
+            matches.concat([match], referenced_entities(match.resource, entries, root_url))
+          end
+        elsif value.is_a?(Array) && value.all? { |elmt| elmt.is_a?(FHIR::Model) }
+          value.each { |val| matches.concat(referenced_entities(val, entries, root_url)) }
+        end
+      end
+
+      matches
+    end
+
+    def find_matching_entry(ref, entries, root_url = '')
+      ref = "#{root_url}/#{ref}" if relative_reference?(ref) && root_url&.present?
+
+      entries&.find { |entry| entry&.fullUrl == ref }
+    end
+
+    def relative_reference?(ref)
+      ref&.count('/') == 1
+    end
+
+    # Drop the last two segments of a URL, i.e. the resource type and ID of a FHIR resource
+    # e.g. http://example.org/fhir/Patient/123 -> http://example.org/fhir
+    def extract_fhir_base_url(url)
+      return unless url&.start_with?('http://', 'https://')
+
+      # Drop everything after the second to last '/', ignoring a trailing slash
+      url.sub(%r{/[^/]*/[^/]*(/)?\z}, '')
+    end
+
+    def claim_response_full_url_from_submit_response_bundle(submit_bundle)
+      claim_response_entry = submit_bundle&.entry&.find { |e| e&.resource&.resourceType == 'ClaimResponse' }
+
+      if claim_response_entry.present?
+        return claim_response_entry.fullUrl unless claim_response_entry.fullUrl.blank?
+        unless claim_response_entry.resource.blank? || claim_response_entry.resource.id.blank?
+          return claim_response_entry.resource.id
+        end
+      end
+      "urn:uuid:#{SecureRandom.uuid}"
+    end
+  end
+end