us_quality_core_test_kit 0.1.1 → 0.2.0

data/lib/us_quality_core_test_kit/generator/ig_metadata_extractor.rb

@@ -1,21 +1,40 @@
 # frozen_string_literal: true
 
-require 'us_core_test_kit/generator/ig_metadata_extractor'
-
 require_relative 'ig_metadata'
 require_relative 'group_metadata_extractor'
 require_relative 'special_cases'
 
 module USQualityCoreTestKit
   class Generator
-    class IGMetadataExtractor < USCoreTestKit::Generator::IGMetadataExtractor
-      def initialize(ig_resources)
-        super
+    class IGMetadataExtractor
+      attr_accessor :ig_resources, :metadata
 
+      def initialize(ig_resources)
+        self.ig_resources = ig_resources
+        remove_version_from_supported_profiles
+        remove_extra_supported_profiles
         self.metadata = IGMetadata.new
       end
 
-      def add_missing_supported_profiles; end
+      def extract
+        add_metadata_from_ig
+        add_metadata_from_resources
+        metadata
+      end
+
+      def add_metadata_from_ig
+        metadata.ig_version = "v#{ig_resources.ig.version}"
+      end
+
+      def resources_in_capability_statement
+        ig_resources.capability_statement.rest.first.resource
+      end
+
+      def remove_version_from_supported_profiles
+        resources_in_capability_statement.each do |resource|
+          resource.supportedProfile.map! { |profile_url| profile_url.split('|').first }
+        end
+      end
 
       def remove_extra_supported_profiles
         resources_in_capability_statement.each do |resource|

data/lib/us_quality_core_test_kit/generator/ig_resources.rb

@@ -1,10 +1,28 @@
 # frozen_string_literal: true
 
-require 'us_core_test_kit/generator/ig_resources'
-
 module USQualityCoreTestKit
   class Generator
-    class IGResources < USCoreTestKit::Generator::IGResources
+    class IGResources
+      def add(resource)
+        resources_by_type[resource.resourceType] << resource
+      end
+
+      def ig
+        resources_by_type['ImplementationGuide'].first
+      end
+
+      def inspect
+        'IGResources'
+      end
+
+      def value_set_by_url(url)
+        resources_by_type['ValueSet'].find { |profile| profile.url == url }
+      end
+
+      def code_system_by_url(url)
+        resources_by_type['CodeSystem'].find { |system| system.url == url }
+      end
+
       def capability_statement(mode = 'server')
         resources_by_type['CapabilityStatement'].reverse.find do |capability_statement_resource|
           capability_statement_resource.rest.any? { |r| r.mode == mode }
@@ -56,6 +74,12 @@ module USQualityCoreTestKit
 
         candidates.first
       end
+
+      private
+
+      def resources_by_type
+        @resources_by_type ||= Hash.new { |hash, key| hash[key] = [] }
+      end
     end
   end
 end

data/lib/us_quality_core_test_kit/generator/interpreter_required_extension_test_generator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module USQualityCoreTestKit
+  class Generator
+    class InterpreterRequiredExtensionTestGenerator
+      class << self
+        def generate(ig_metadata, base_output_dir)
+          ig_metadata.groups
+                     .select { |group| group.resource == 'Encounter' }
+                     .each { |group| new(group, base_output_dir).generate }
+        end
+      end
+
+      attr_accessor :group_metadata, :base_output_dir
+
+      def initialize(group_metadata, base_output_dir)
+        self.group_metadata = group_metadata
+        self.base_output_dir = base_output_dir
+      end
+
+      def template
+        @template ||= File.read(File.join(__dir__, 'templates', 'interpreter_required_extension_test.rb.erb'))
+      end
+
+      def output
+        @output ||= ERB.new(template, trim_mode: '-').result(binding)
+      end
+
+      def base_output_file_name
+        "#{class_name.underscore}.rb"
+      end
+
+      def output_file_directory
+        File.join(base_output_dir, profile_identifier)
+      end
+
+      def output_file_name
+        File.join(output_file_directory, base_output_file_name)
+      end
+
+      def profile_identifier
+        Naming.snake_case_for_profile(group_metadata)
+      end
+
+      def test_id
+        "us_quality_core_#{group_metadata.reformatted_version}_interpreter_required_extension_test"
+      end
+
+      def class_name
+        'InterpreterRequiredExtensionTest'
+      end
+
+      def module_name
+        "USQualityCore#{group_metadata.reformatted_version.upcase}"
+      end
+
+      def generate
+        FileUtils.mkdir_p(output_file_directory)
+        File.write(output_file_name, output)
+
+        group_metadata.add_test(
+          id: test_id,
+          file_name: base_output_file_name
+        )
+      end
+    end
+  end
+end

data/lib/us_quality_core_test_kit/generator/must_support_metadata_extractor.rb

@@ -1,63 +1,432 @@
 # frozen_string_literal: true
 
 require_relative 'value_extractor'
-
-require 'us_core_test_kit/generator/must_support_metadata_extractor'
+require_relative 'must_support_metadata_extractor_v1'
 
 module USQualityCoreTestKit
   class Generator
-    class MustSupportMetadataExtractor < USCoreTestKit::Generator::MustSupportMetadataExtractor
-      def uscdi_plus_quality_element?(element)
-        !element.mustSupport && element.extension.any? do |extension|
-          extension.url.downcase.ends_with? 'uscdiplusquality'
+    class MustSupportMetadataExtractor
+      attr_accessor :profile_elements, :profile, :resource, :ig_resources
+
+      def initialize(profile_elements, profile, resource, ig_resources)
+        self.profile_elements = profile_elements
+        self.profile = profile
+        self.resource = resource
+        self.ig_resources = ig_resources
+      end
+
+      def must_supports
+        @must_supports = {
+          extensions: must_support_extensions,
+          slices: must_support_slices,
+          elements: must_support_elements
+        }
+
+        handle_special_cases
+
+        @must_supports
+      end
+
+      def uscdi_requirement_element?(element)
+        element.extension.any? do |extension|
+          extension.url == 'http://hl7.org/fhir/us/core/StructureDefinition/uscdi-requirement' &&
+            extension.valueBoolean
+        end && !element.mustSupport
+      end
+
+      def must_support_extension_elements
+        all_must_support_elements.select { |element| extension_element?(element) }
+      end
+
+      def must_support_slice_elements
+        all_must_support_elements.select { |element| !extension_element?(element) && element.sliceName.present? }
+      end
+
+      def extension_element?(element)
+        element.type.any? { |type| type.code == 'Extension' }
+      end
+
+      def sliced_element(slice)
+        profile_elements.find { |element| element.id == slice.path || element.id == slice.id.sub(":#{slice.sliceName}", '') }
+      end
+
+      def discriminators(slice)
+        slice.slicing.discriminator
+      end
+
+      def must_support_type_slice_elements
+        must_support_slice_elements.select do |element|
+          discriminators(sliced_element(element)).first.type == 'type'
+        end
+      end
+
+      def type_slices
+        must_support_type_slice_elements.map do |current_element|
+          discriminator = discriminators(sliced_element(current_element)).first
+          type_path = discriminator.path
+          type_path = '' if type_path == '$this'
+          type_element =
+            if type_path.present?
+              profile_elements.find { |element| element.id == "#{current_element.id}.#{type_path}" }
+            else
+              current_element
+            end
+
+          type_code = type_element.type.first.code
+
+          discriminator = {
+            type: 'type',
+            code: type_code.upcase_first
+          }
+
+          discriminator[:path] = type_path unless type_path.empty?
+
+          {
+            slice_id: current_element.id,
+            slice_name: current_element.sliceName,
+            path: current_element.path.gsub("#{resource}.", ''),
+            discriminator: discriminator
+          }
+        end
+      end
+
+      def must_support_value_slice_elements
+        must_support_slice_elements.select do |element|
+          # 'pattern' is deparected in FHIR R5
+          # 'pattern' type is used in US Core v7 and all earlier versions.
+          # Since US Core v8, all 'patten' types are moved to 'value' type
+          %w[value pattern].include?(discriminators(sliced_element(element)).first.type)
         end
       end
 
-      def add_us_quality_coreuscdi_plus_quality_flag(profile_element, metadata_element)
-        if uscdi_plus_quality_element?(profile_element)
-          metadata_element.merge(us_quality_coreuscdi_plus_quality: true)
+      def value_slices
+        must_support_value_slice_elements.map do |current_element|
+          {
+            slice_id: current_element.id,
+            slice_name: current_element.sliceName,
+            path: current_element.path.gsub("#{resource}.", '')
+          }.tap do |metadata|
+            fixed_values = []
+            pattern_value = {}
+
+            discriminators(sliced_element(current_element)).each do |discriminator|
+              discriminator_path = discriminator.path
+              discriminator_path = '' if discriminator_path == '$this'
+              pattern_element =
+                if discriminator_path.present?
+                  sliced_target_path = "#{current_element.path}.#{discriminator_path}"
+
+                  profile_elements.find do |element|
+                    element.id.starts_with?(current_element.id) &&
+                      element.path == sliced_target_path
+                  end
+                else
+                  current_element
+                end
+
+              if pattern_element.fixedCode.present? || pattern_element.fixedUri.present?
+                fixed_values << {
+                  path: discriminator.path,
+                  value: pattern_element.fixedUri || pattern_element.fixedCode
+                }
+              elsif pattern_value.present?
+                raise StandardError, "Found more than one pattern slices for the same element #{pattern_element}."
+              else
+                pattern_value = save_pattern_slice(pattern_element, discriminator_path, metadata)
+              end
+            end
+
+            if !fixed_values.empty?
+              metadata[:discriminator] = {
+                type: 'value',
+                values: fixed_values
+              }
+            elsif pattern_value.present?
+              metadata[:discriminator] = pattern_value
+            end
+          end
+        end
+      end
+
+      def save_pattern_slice(pattern_element, discriminator_path, metadata)
+        if pattern_element.patternCodeableConcept.present?
+          {
+            type: 'patternCodeableConcept',
+            path: discriminator_path,
+            code: pattern_element.patternCodeableConcept.coding.first.code,
+            system: pattern_element.patternCodeableConcept.coding.first.system
+          }
+        elsif pattern_element.patternCoding.present?
+          {
+            type: 'patternCoding',
+            path: discriminator_path,
+            code: pattern_element.patternCoding.code,
+            system: pattern_element.patternCoding.system
+          }
+        elsif pattern_element.patternIdentifier.present?
+          {
+            type: 'patternIdentifier',
+            path: discriminator_path,
+            system: pattern_element.patternIdentifier.system
+          }
+        elsif pattern_element.binding&.strength == 'required' &&
+              pattern_element.binding&.valueSet.present?
+
+          value_extractor = ValueExactor.new(ig_resources, resource, profile_elements)
+
+          values = value_extractor.codings_from_value_set_binding(pattern_element).presence ||
+                   value_extractor.values_from_resource_metadata([metadata[:path]]).presence || []
+
+          {
+            type: 'requiredBinding',
+            path: discriminator_path,
+            values: values
+          }
+        else
+          raise StandardError, 'Unsupported discriminator pattern type'
+        end
+      end
+
+      def plain_must_support_elements
+        all_must_support_elements - must_support_extension_elements - must_support_slice_elements
+      end
+
+      def element_part_of_slice_discrimination?(element)
+        must_support_slice_elements.any? { |ms_slice| element.id.include?(ms_slice.id) }
+      end
+
+      def handle_fixed_values(metadata, element)
+        if element.fixedUri.present?
+          metadata[:fixed_value] = element.fixedUri
+        elsif element.patternCodeableConcept.present? && !element_part_of_slice_discrimination?(element)
+          metadata[:fixed_value] = element.patternCodeableConcept.coding.first.code
+          metadata[:path] += '.coding.code'
+        elsif element.fixedCode.present?
+          metadata[:fixed_value] = element.fixedCode
+        elsif element.patternIdentifier.present? && !element_part_of_slice_discrimination?(element)
+          metadata[:fixed_value] = element.patternIdentifier.system
+          metadata[:path] += '.system'
+        end
+      end
+
+      def type_must_support_extension?(extensions)
+        extensions&.any? do |extension|
+          extension.url == 'http://hl7.org/fhir/StructureDefinition/elementdefinition-type-must-support' &&
+            extension.valueBoolean
+        end
+      end
+
+      def save_type_code?(type)
+        type.code == 'Reference'
+      end
+
+      def get_type_must_support_metadata(current_metadata, current_element)
+        current_element.type.map do |type|
+          next unless type_must_support_extension?(type.extension)
+
+          metadata =
+            {
+              path: "#{current_metadata[:path].delete_suffix('[x]')}#{type.code.upcase_first}",
+              original_path: current_metadata[:path]
+            }
+          metadata[:types] = [type.code] if save_type_code?(type)
+          handle_type_must_support_target_profiles(type, metadata) if type.code == 'Reference'
+
+          metadata
+        end.compact
+      end
+
+      def handle_type_must_support_target_profiles(type, metadata)
+        target_profiles = []
+
+        if type.targetProfile&.length == 1
+          target_profiles << type.targetProfile.first
         else
-          metadata_element
+          type.source_hash['_targetProfile']&.each_with_index do |hash, index|
+            if hash.present?
+              element = FHIR::Element.new(hash)
+              target_profiles << type.targetProfile[index] if type_must_support_extension?(element.extension)
+            end
+          end
+        end
+
+        # remove target_profile for FHIR Base resource type.
+        target_profiles.delete_if { |reference| reference.start_with?('http://hl7.org/fhir/StructureDefinition') }
+        metadata[:target_profiles] = target_profiles if target_profiles.present?
+      end
+
+      def handle_choice_type_in_sliced_element(current_metadata, must_support_elements_metadata)
+        choice_element_metadata = must_support_elements_metadata.find do |metadata|
+          metadata[:original_path].present? &&
+            current_metadata[:path].include?(metadata[:original_path])
+        end
+
+        return unless choice_element_metadata.present?
+
+        current_metadata[:original_path] = current_metadata[:path]
+        current_metadata[:path] = current_metadata[:path].sub(choice_element_metadata[:original_path], choice_element_metadata[:path])
+      end
+
+      #### SPECIAL CASE ####
+
+      def vital_sign?
+        [
+          'http://hl7.org/fhir/StructureDefinition/vitalsigns',
+          'http://hl7.org/fhir/us/core/StructureDefinition/us-core-vital-signs'
+        ].include?(profile.baseDefinition)
+      end
+
+      def blood_pressure?
+        %w[bp us-core-blood-pressure us-core-average-blood-pressure].include?(profile.id)
+      end
+
+      # Exclude Observation.component from vital sign profiles except observation-bp and observation-pulse-ox
+
+      def remove_vital_sign_component
+        return if blood_pressure? || profile.name == 'USCorePulseOximetryProfile'
+
+        return unless vital_sign?
+
+        @must_supports[:elements].delete_if do |element|
+          element[:path].start_with?('component')
+        end
+      end
+
+      # Exclude Observation.value[x] from observation-bp
+
+      def remove_blood_pressure_value_data_absent_reason
+        return unless blood_pressure?
+
+        @must_supports[:elements].delete_if do |element|
+          element[:path].start_with?('value[x]') ||
+            element[:original_path]&.start_with?('value[x]') ||
+            element[:path] == ('dataAbsentReason')
+        end
+
+        @must_supports[:slices].delete_if do |slice|
+          slice[:path].start_with?('value[x]')
+        end
+      end
+
+      # ONC and US Core 4.0.0 both clarified that health IT developers that always provide HL7 FHIR "observation" values
+      # are not required to demonstrate Health IT Module support for "dataAbsentReason" elements.
+      # Remove MS check for dataAbsentReason and component.dataAbsentReason from vital sign profiles and observation lab profile
+      # Smoking status profile does not have MS on dataAbsentReason. It is safe to use profile.type == 'Observation'
+      # Since US Core 5.0.1, Blood Pressure profile restores component.dataAbsentReason as MustSupport.
+      # US Quality Core Test Kit has to keep this as there are still profiles either are us-core or inherit from us-core
+
+      def remove_observation_data_absent_reason
+        return if blood_pressure?
+
+        pattern = /(component(:[^.]+)?\.)?dataAbsentReason/
+
+        return unless profile.type == 'Observation'
+
+        @must_supports[:elements].delete_if do |element|
+          pattern.match?(element[:path])
+        end
+      end
+
+      def uscdi_plus_quality_element?(element)
+        return false if element.mustSupport
+
+        element.extension.any? do |extension|
+          extension.url.downcase.end_with?(
+            'uscdiplusquality',
+            'us-quality-core-uscdi-quality-extension'
+          )
         end
       end
 
       def all_must_support_elements
         profile_elements.select do |element|
-          element.mustSupport || uscdi_plus_quality_element?(element) || is_uscdi_requirement_element?(element)
+          element.mustSupport || uscdi_plus_quality_element?(element) || uscdi_requirement_element?(element)
         end
       end
 
       def must_support_extensions
-        super.map do |extension|
-          profile_element = must_support_extension_elements.find { |e| e.id == extension[:id] }
+        must_support_extension_elements.map do |profile_element|
+          metadata = {
+            id: profile_element.id,
+            path: profile_element.path.gsub("#{resource}.", ''),
+            url: profile_element.type.first.profile.first
+          }
+
+          if uscdi_plus_quality_element?(profile_element)
+            metadata[:uscdi_plus_quality] = true
+          elsif uscdi_requirement_element?(profile_element)
+            metadata[:uscdi_only] = true
+          end
 
-          add_us_quality_coreuscdi_plus_quality_flag(profile_element, extension)
+          metadata
         end
       end
 
       def must_support_slices
-        super.map do |slice|
-          profile_element = must_support_slice_elements.find { |e| e.id == slice[:slice_id] }
+        (type_slices + value_slices).map do |metadata|
+          profile_element = must_support_slice_elements.find { |e| e.id == metadata[:slice_id] }
 
-          add_us_quality_coreuscdi_plus_quality_flag(profile_element, slice)
+          if uscdi_plus_quality_element?(profile_element)
+            metadata[:uscdi_plus_quality] = true
+          elsif uscdi_requirement_element?(profile_element)
+            metadata[:uscdi_only] = true
+          end
+
+          metadata
         end
       end
 
       def must_support_elements
-        ms_elements = super
+        ms_elements =
+          plain_must_support_elements.each_with_object([]) do |current_element, must_support_elements_metadata|
+            {
+              path: current_element.id.gsub("#{resource}.", '')
+            }.tap do |current_metadata|
+              if current_element.id.include?(':') && !current_element.id.include?('extension')
+                slice_name = current_element.id.match(/:(\w+)/)[1]
+
+                next if must_support_slice_elements.none? { |slice| slice.sliceName == slice_name }
+              end
+
+              type_must_support_metadata = get_type_must_support_metadata(current_metadata, current_element)
+
+              if type_must_support_metadata.any?
+                must_support_elements_metadata.concat(type_must_support_metadata)
+              else
+                handle_choice_type_in_sliced_element(current_metadata, must_support_elements_metadata)
+
+                supported_types = current_element.type.select { |type| save_type_code?(type) }.map(&:code)
+                current_metadata[:types] = supported_types if supported_types.present?
+
+                handle_type_must_support_target_profiles(current_element.type.first, current_metadata) if current_element.type.first&.code == 'Reference'
+
+                handle_fixed_values(current_metadata, current_element)
+
+                must_support_elements_metadata << current_metadata
+              end
+            end
+          end.uniq
+
         return ms_elements unless profile.url.include?('us-quality-core')
 
-        ms_elements.map do |element|
+        ms_elements.map do |metadata|
           profile_element = plain_must_support_elements.find do |e|
             path = e.id.gsub("#{resource}.", '')
-            [element[:path], element[:original_path]].include?(path)
+            [metadata[:path], metadata[:original_path]].include?(path)
           end
 
-          add_us_quality_coreuscdi_plus_quality_flag(profile_element, element)
+          if uscdi_plus_quality_element?(profile_element)
+            metadata[:uscdi_plus_quality] = true
+          elsif uscdi_requirement_element?(profile_element)
+            metadata[:uscdi_only] = true
+          end
+
+          metadata
         end
       end
 
       # Aligns US Core v6.1.0 must support requirements to [USCDI v3.1](https://isp.healthit.gov/united-states-core-data-interoperability-uscdi#uscdi-v3-1)
+
       def remove_patient_gender_identity
         return unless profile.type == 'Patient'
         return unless @must_supports && @must_supports[:extensions]
@@ -70,6 +439,11 @@ module USQualityCoreTestKit
         remove_vital_sign_component
         remove_blood_pressure_value_data_absent_reason
         remove_observation_data_absent_reason
+
+        # if (profile.url.start_with?('http://hl7.org/fhir/us/quality-core') && profile.version.start_with?('1.0.0')) ||
+        #   (profile.url.start_with?('http://hl7.org/fhir/us/core') && profile.version == '9.0.0')
+        MustSupportMetadataExtractorV1.new(profile, @must_supports).handle_special_cases
+        # end
       end
     end
   end