au_core_test_kit 0.0.16

data/lib/au_core_test_kit/generator/search_definition_metadata_extractor.rb

@@ -0,0 +1,340 @@
+# frozen_string_literal: true
+
+require_relative 'value_extractor'
+
+module AUCoreTestKit
+  class Generator
+    class SearchDefinitionMetadataExtractor
+      attr_accessor :ig_resources, :name, :profile_elements, :group_metadata
+
+      def initialize(name, ig_resources, profile_elements, group_metadata)
+        self.name = name
+        self.ig_resources = ig_resources
+        self.profile_elements = profile_elements
+        self.group_metadata = group_metadata
+      end
+
+      def search_definition
+        @search_definition ||=
+          {
+            paths:,
+            full_paths:,
+            comparators:,
+            values:,
+            type:,
+            contains_multiple: contains_multiple?,
+            multiple_or: multiple_or_expectation,
+            multiple_and: multiple_and_expectation,
+            chain:,
+            target_resource:
+          }.compact
+      end
+
+      def resource
+        group_metadata[:resource]
+      end
+
+      def param
+        @param ||= ig_resources.search_param_by_resource_and_name(resource, name)
+      end
+
+      def param_hash
+        param.source_hash
+      end
+
+      def target_resource
+        param.target.first
+      end
+
+      def full_paths
+        @full_paths ||=
+          begin
+            full_paths = param.expression.split('|').map do |expr|
+              expr.strip.gsub(/.where\(resolve\((.*)/, '').gsub(/url = '/,
+                                                                'url=\'').gsub(/\.ofType\(([^)]+)\)/) do |_match|
+                type_name = ::Regexp.last_match(1)
+                "#{type_name[0].upcase}#{type_name[1..]}"
+              end
+            end.filter { |path| path.split('.').first == resource }
+
+            full_paths.map do |path|
+              path.scan(/[. ]as[( ]([^)]*)[)]?/).flatten.map do |as_type|
+                path.gsub!(/[. ]as[( ](#{as_type}[^)]*)[)]?/, as_type.upcase_first) if as_type.present?
+              end
+            end
+
+            # path = param.expression.gsub(/.where\(resolve\((.*)/, '').gsub(/url = '/, 'url=\'')
+            # path = path[1..-2] if path.start_with?('(') && path.end_with?(')')
+            # path.scan(/[. ]as[( ]([^)]*)[)]?/).flatten.map do |as_type|
+            #   path.gsub!(/[. ]as[( ](#{as_type}[^)]*)[)]?/, as_type.upcase_first) if as_type.present?
+            # end
+
+            # full_paths = path.split('|')
+            # # There is a problem with whitespaces in paths
+            # full_paths = full_paths.map(&:strip)
+
+            # There is a bug in AU Core 5 asserted-date search parameter. See FHIR-40573
+            remove_additional_extension_from_asserted_date(full_paths) if param.respond_to?(:version) && param.version == '5.0.1' && name == 'asserted-date'
+
+            full_paths
+          end
+      end
+
+      def remove_additional_extension_from_asserted_date(full_paths)
+        full_paths.each do |full_path|
+          next unless full_path.include?('http://hl7.org/fhir/StructureDefinition/condition-assertedDate')
+
+          full_path.gsub!(/\).extension./, ').')
+        end
+      end
+
+      def paths
+        @paths ||= full_paths.map { |a_path| a_path.gsub("#{resource}.", '') }
+      end
+
+      def extensions
+        @extensions ||= full_paths.select { |a_path| a_path.include?('extension.where') }
+                                  .map { |a_path| { url: a_path[/(?<=extension.where\(url=').*(?='\))/] } }
+                                  .presence
+      end
+
+      def profile_element
+        @profile_element ||=
+          profile_elements.find { |element| full_paths.include?(element.id) } ||
+          extension_definition&.differential&.element&.find { |element| element.id == 'Extension.value[x]' }
+      end
+
+      def extension_definition
+        @extension_definition ||=
+          begin
+            ext_definition = nil
+            extensions&.each do |ext_metadata|
+              ext_definition = ig_resources.profile_by_url(ext_metadata[:url])
+              break if ext_definition.present?
+            end
+            ext_definition
+          end
+      end
+
+      def comparator_expectation_extensions
+        @comparator_expectation_extensions ||= param_hash['_comparator'] || []
+      end
+
+      def support_expectation(extension)
+        extension['extension'].first['valueCode']
+      end
+
+      def comparator_expectation(extension)
+        if extension.nil?
+          'MAY'
+        else
+          support_expectation(extension)
+        end
+      end
+
+      def comparators
+        # NOTE: Hard-coded values are used because the comparator expectation
+        # does not exist in the machine-readable files, but it does exist in the narrative.
+        # NOTE: https://github.com/hl7au/au-fhir-core-inferno/issues/48
+        special_cases_resources = %w[Observation Condition Encounter Immunization MedicationRequest Patient Procedure]
+        special_cases_comparators = %w[gt lt ge le]
+        special_cases_param_ids = %w[clinical-date Condition-onset-date clinical-date MedicationRequest-authoredon individual-birthdate]
+
+        {}.tap do |comparators|
+          param.comparator&.each_with_index do |comparator, index|
+            comparators[comparator.to_sym] = if (special_cases_resources.include? group_metadata[:resource]) && (special_cases_comparators.include? comparator) && (special_cases_param_ids.include? param_hash['id'])
+                                               'SHALL'
+                                             else
+                                               comparator_expectation(comparator_expectation_extensions[index])
+                                             end
+          end
+        end
+      end
+
+      def type
+        if profile_element.present?
+          profile_element.type.first.code
+        else
+          # search is a variable type, eg. Condition.onsetDateTime - element
+          # in profile def is Condition.onset[x]
+          param.type
+        end
+      end
+
+      def contains_multiple?
+        if profile_element.present?
+          if profile_element.id.start_with?('Extension') && extension_definition.present?
+            # Find the extension instance in a AU Core profile
+            target_element = profile_elements.find do |element|
+              element.type.any? { |type| type.code == 'Extension' && type.profile.include?(extension_definition.url) }
+            end
+            target_element&.max == '*'
+          else
+            profile_element.max == '*'
+          end
+        else
+          false
+        end
+      end
+
+      def chain_extensions
+        param_hash['_chain']
+      end
+
+      def chain_expectations
+        chain_extensions.map { |extension| support_expectation(extension) }
+      end
+
+      def chain
+        return nil if param.chain.blank?
+
+        target = param.target.first
+        param.chain
+             .zip(chain_expectations)
+             .map { |chain, expectation| { chain:, expectation:, target: } }
+      end
+
+      def multiple_or_expectation
+        # NOTE: Hard-coded values are used because the multipleOr attributes
+        # do not exist in the machine-readable files, but they do exist in the narrative.
+        # NOTE: https://github.com/hl7au/au-fhir-core-inferno/issues/61
+        # NOTE: https://github.com/hl7au/au-fhir-core-inferno/issues/63
+        case group_metadata[:resource]
+        when 'Procedure'
+          return 'SHALL' if param_hash['id'] == 'Procedure-status'
+          return 'SHOULD' if param_hash['id'] == 'clinical-code'
+        when 'Observation'
+          return 'SHALL' if param_hash['id'] == 'Observation-status'
+          return 'SHOULD' if param_hash['id'] == 'clinical-code'
+        when 'MedicationRequest'
+          return 'SHALL' if param_hash['id'] == 'medications-status'
+          return 'SHOULD' if param_hash['id'] == 'MedicationRequest-intent'
+        when 'Immunization'
+          return 'SHOULD' if param_hash['id'] == 'Immunization-vaccine-code'
+        when 'Condition'
+          return 'MAY' if param_hash['id'] == 'clinical-code'
+        when 'Encounter'
+          return 'MAY' if param_hash['id'] == 'Encounter-status'
+        end
+
+        return unless param_hash['_multipleOr']
+
+        param_hash['_multipleOr']['extension'].first['valueCode']
+      end
+
+      def multiple_and_expectation
+        # NOTE: Hard-coded values are used because the multipleAnd attributes
+        # do not exist in the machine-readable files, but they do exist in the narrative.
+        # NOTE: https://github.com/hl7au/au-fhir-core-inferno/issues/62
+        case group_metadata[:resource]
+        when 'Observation'
+          return 'SHOULD' if param_hash['id'] == 'clinical-date'
+        when 'Condition'
+          return 'SHOULD' if param_hash['id'] == 'Condition-onset-date'
+        when 'Encounter'
+          return 'SHOULD' if param_hash['id'] == 'clinical-date'
+        when 'Immunization'
+          return 'SHOULD' if param_hash['id'] == 'clinical-date'
+        when 'MedicationRequest'
+          return 'SHOULD' if param_hash['id'] == 'MedicationRequest-authoredon'
+        when 'Patient'
+          return 'MAY' if param_hash['id'] == 'individual-birthdate'
+        when 'Procedure'
+          return 'MAY' if param_hash['id'] == 'clinical-date'
+        end
+        return unless param_hash['_multipleAnd']
+
+        param_hash['_multipleAnd']['extension'].first['valueCode']
+      end
+
+      def values
+        fixed_diagnostic_result_values = %w[251739003 24701-5]
+        fixed_date_value = %w[ge1950-01-01 le2050-01-01 gt1950-01-01 lt2050-01-01]
+        fixed_datetime_value = %w[ge1950-01-01T00:00:00.000Z le2050-01-01T23:59:59.999Z gt1950-01-01T00:00:00.000Z lt2050-01-01T23:59:59.999Z]
+        # NOTE: In the current step we don't need to check the correct content of the response.
+        # We should care about the correct structure of the request. In this current case we use dates just
+        # to check that server can make a response for the request.
+        case group_metadata[:resource]
+        when 'Observation'
+          return fixed_datetime_value if param_hash['id'] == 'clinical-date'
+          return fixed_diagnostic_result_values if param_hash['id'] =='clinical-code' && group_metadata[:profile_url] == 'http://hl7.org.au/fhir/core/StructureDefinition/au-core-diagnosticresult'
+        when 'Condition'
+          return fixed_datetime_value if param_hash['id'] == 'Condition-onset-date'
+        when 'Encounter'
+          return fixed_datetime_value if param_hash['id'] == 'clinical-date'
+        when 'Immunization'
+          return fixed_datetime_value if param_hash['id'] == 'clinical-date'
+        when 'MedicationRequest'
+          return fixed_datetime_value if param_hash['id'] == 'MedicationRequest-authoredon'
+        when 'Patient'
+          return fixed_date_value if param_hash['id'] == 'individual-birthdate'
+        when 'Procedure'
+          return fixed_datetime_value if param_hash['id'] == 'clinical-date'
+        end
+
+        values_from_fixed_codes = value_extractor.values_from_fixed_codes(profile_element, type).presence
+        values_from_pattern_coding = value_extractor.values_from_pattern_coding(profile_element, type).presence
+        merged_values = Array(values_from_fixed_codes) + Array(values_from_pattern_coding)
+
+        values_from_must_supports(profile_element).presence || merged_values.presence ||
+          # value_extractor.values_from_required_binding(profile_element).presence ||
+          value_extractor.values_from_value_set_binding(profile_element).presence ||
+          values_from_resource_metadata(paths).presence ||
+          []
+      end
+
+      def values_from_must_supports(profile_element)
+        return if profile_element.nil?
+
+        short_path = profile_element.path.split('.', 2)[1]
+
+        values_from_must_support_slices(profile_element, short_path, true).presence ||
+          values_from_must_support_slices(profile_element, short_path, false).presence ||
+          values_from_must_support_elements(short_path).presence ||
+          []
+      end
+
+      def values_from_must_support_slices(profile_element, short_path, mandatory_slice_only)
+        return unless group_metadata[:must_supports][:slices].compact.length.positive?
+
+        group_metadata[:must_supports][:slices]
+          .select { |slice| [short_path, "#{short_path}.coding"].include?(slice[:path]) }
+          .map do |slice|
+            slice_element = profile_elements.find { |element| slice[:slice_id] == element.id }
+            next if profile_element.min.positive? && slice_element.min.zero? && mandatory_slice_only
+
+            case slice[:discriminator][:type]
+            when 'patternCoding', 'patternCodeableConcept'
+              slice[:discriminator][:code]
+            when 'requiredBinding'
+              slice[:discriminator][:values]
+            when 'value'
+              slice[:discriminator][:values]
+                .select { |value| value[:path] == 'coding.code' }
+                .map { |value| value[:value] }
+            end
+          end
+          .compact.flatten
+      end
+
+      def values_from_must_support_elements(short_path)
+        group_metadata[:must_supports][:elements]
+          .select { |element| element[:path] == "#{short_path}.coding.code" }
+          .map { |element| element[:fixed_value] }
+      end
+
+      def values_from_resource_metadata(paths)
+        if multiple_or_expectation == 'SHALL' || paths.any? { |path| path.downcase.include?('status') }
+          value_extractor.values_from_resource_metadata(paths)
+        else
+          []
+        end
+      end
+
+      def value_extractor
+        @value_extractor ||= ValueExactor.new(ig_resources, resource, profile_elements)
+      end
+    end
+  end
+end
+

data/lib/au_core_test_kit/generator/search_metadata_extractor.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative 'search_definition_metadata_extractor'
+
+module AUCoreTestKit
+  class Generator
+    class SearchMetadataExtractor
+      COMBO_EXTENSION_URL =
+        'http://hl7.org/fhir/StructureDefinition/capabilitystatement-search-parameter-combination'
+
+      attr_accessor :resource_capabilities, :ig_resources, :profile_elements, :group_metadata
+
+      def initialize(resource_capabilities, ig_resources, profile_elements, group_metadata)
+        self.resource_capabilities = resource_capabilities
+        self.ig_resources = ig_resources
+        self.profile_elements = profile_elements
+        self.group_metadata = group_metadata
+      end
+
+      def searches
+        @searches ||= basic_searches + combo_searches
+
+        handle_special_cases
+
+        @searches
+      end
+
+      def conformance_expectation(search_param)
+        search_param.extension.first.valueCode # TODO: fix expectation extension finding
+      end
+
+      def no_search_params?
+        resource_capabilities.searchParam.blank?
+      end
+
+      def basic_searches
+        return [] if no_search_params?
+
+        resource_capabilities.searchParam
+                             .select do |search_param|
+          %w[SHALL SHOULD MAY].include? conformance_expectation(search_param)
+        end
+                             .map do |search_param|
+          {
+            names: [search_param.name],
+            expectation: conformance_expectation(search_param)
+          }
+        end
+      end
+
+      def search_extensions
+        resource_capabilities.extension
+      end
+
+      def combo_searches
+        return [] if search_extensions.blank?
+
+        search_extensions
+          .select { |extension| extension.url == COMBO_EXTENSION_URL }
+          .select { |extension| %w[SHALL SHOULD MAY].include? conformance_expectation(extension) }
+          .map do |extension|
+            names = extension.extension.select { |param| param.valueString.present? }.map(&:valueString)
+            {
+              expectation: conformance_expectation(extension),
+              names:
+            }
+          end
+      end
+
+      def search_param_names
+        searches.flat_map { |search| search[:names] }.uniq
+      end
+
+      def search_definitions
+        search_param_names.each_with_object({}) do |name, definitions|
+          definitions[name.to_sym] =
+            SearchDefinitionMetadataExtractor.new(name, ig_resources, profile_elements,
+                                                  group_metadata).search_definition
+        end
+      end
+
+      def handle_special_cases
+        # NOTE: https://github.com/hl7au/au-fhir-core-inferno/issues/57
+        profile_url = group_metadata[:profile_url]
+        if profile_url == 'http://hl7.org.au/fhir/core/StructureDefinition/au-core-medicationrequest'
+          @searches.map do |search|
+            if search[:names] == ["patient", "intent", "authoredon"] && search[:expectation] == "SHALL"
+              search[:expectation] = "SHOULD"
+            end
+          end
+        end
+      end
+    end
+  end
+end