davinci_pdex_test_kit 0.9.1

data/lib/davinci_pdex_test_kit/fhir_resource_navigation.rb

@@ -0,0 +1,154 @@
+module DaVinciPDexTestKit
+  module FHIRResourceNavigation
+    DAR_EXTENSION_URL = 'http://hl7.org/fhir/StructureDefinition/data-absent-reason'.freeze
+    PRIMITIVE_DATA_TYPES = FHIR::PRIMITIVES.keys
+
+    def resolve_path(elements, path)
+      elements = Array.wrap(elements)
+      return elements if path.blank?
+
+      paths = path.split(/(?<!hl7)\./)
+      segment = paths.first
+      remaining_path = paths.drop(1).join('.')
+
+      elements.flat_map do |element|
+        child = get_next_value(element, segment)
+        resolve_path(child, remaining_path)
+      end.compact
+    end
+
+    def find_a_value_at(element, path, include_dar: false)
+      return nil if element.nil?
+
+      elements = Array.wrap(element)
+      if path.empty?
+        unless include_dar
+          elements = elements.reject do |el|
+            el.respond_to?(:extension) && el.extension.any? { |ext| ext.url == DAR_EXTENSION_URL}
+          end
+        end
+
+        return elements.find { |el| yield(el) } if block_given?
+        return elements.first
+      end
+
+      path_segments = path.split(/(?<!hl7)\./)
+
+      segment = path_segments.shift.delete_suffix('[x]').gsub(/^class$/, 'local_class').gsub(/\[x\]:/, ':').to_sym
+      no_elements_present =
+        elements.none? do |element|
+        child = get_next_value(element, segment)
+        child.present? || child == false
+      end
+      return nil if no_elements_present
+
+      remaining_path = path_segments.join('.')
+      elements.each do |element|
+        child = get_next_value(element, segment)
+        element_found =
+          if block_given?
+            find_a_value_at(child, remaining_path, include_dar: include_dar) { |value_found| yield(value_found) }
+          else
+            find_a_value_at(child, remaining_path, include_dar: include_dar)
+          end
+        return element_found if element_found.present? || element_found == false
+      end
+      nil
+    end
+
+    def get_next_value(element, property)
+      extension_url = property[/(?<=where\(url=').*(?='\))/]
+      if extension_url.present?
+        element.url == extension_url ? element : nil
+      elsif property.to_s.include?(':') && !property.to_s.include?('url')
+        slice = find_slice_via_discriminator(element, property)
+        slice
+      else
+        result = element.send(property)
+        result = find_primitive_extension(element, property) if result.nil?
+        result
+      end
+    rescue NoMethodError
+      nil
+    end
+
+    def find_primitive_extension(element, property)
+      type = element.class::METADATA[property.to_s]['type']
+      source_value = element.source_hash["_#{property}"]
+
+      PRIMITIVE_DATA_TYPES.include?(type) && source_value.present? ? FHIR::Element.new(source_value) : nil
+    end
+
+    def find_slice_via_discriminator(element, property)
+      element_name = property.to_s.split(':')[0].gsub(/^class$/, 'local_class')
+      slice_name = property.to_s.split(':')[1].gsub(/^class$/, 'local_class')
+      if metadata.present?
+        slice_by_name = metadata.must_supports[:slices].find{ |slice| slice[:slice_name] == slice_name }
+        discriminator = slice_by_name[:discriminator]
+        slices = Array.wrap(element.send(element_name))
+        slices.find do |slice|
+          case discriminator[:type]
+          when 'patternCodeableConcept'
+            slice_value = discriminator[:path].present? ? slice.send("#{discriminator[:path]}")&.coding : slice.coding
+            slice_value&.any? { |coding| coding.code == discriminator[:code] && coding.system == discriminator[:system] }
+          when 'patternCoding'
+            slice_value = discriminator[:path].present? ? slice.send(discriminator[:path]) : slice
+            slice_value&.code == discriminator[:code] && slice_value&.system == discriminator[:system]
+          when 'patternIdentifier'
+            slice.identifier.system == discriminator[:system]
+          when 'value'
+            values = discriminator[:values].map { |value| value.merge(path: value[:path].split('.')) }
+            verify_slice_by_values(slice, values)
+          when 'type'
+            case discriminator[:code]
+            when 'Date'
+              begin
+                Date.parse(slice)
+              rescue ArgumentError
+                false
+              end
+            when 'DateTime'
+              begin
+                DateTime.parse(slice)
+              rescue ArgumentError
+                false
+              end
+            when 'String'
+              slice.is_a? String
+            else
+              slice.is_a? FHIR.const_get(discriminator[:code])
+            end
+          when 'requiredBinding'
+            slice_value = discriminator[:path].present? ? slice.send("#{discriminator[:path]}").coding : slice.coding
+            slice_value {|coding| discriminator[:values].include?(coding.code) }
+          end
+        end
+      else
+        #TODO: Error handling for if this file doesn't have access to metadata for some reason (begin/rescue with StandardError?)
+      end
+    end
+
+    def verify_slice_by_values(element, value_definitions)
+      path_prefixes = value_definitions.map { |value_definition| value_definition[:path].first }.uniq
+      path_prefixes.all? do |path_prefix|
+        value_definitions_for_path =
+          value_definitions
+            .select { |value_definition| value_definition[:path].first == path_prefix }
+            .each { |value_definition| value_definition[:path].shift }
+        find_a_value_at(element, path_prefix) do |el_found|
+          child_element_value_definitions, current_element_value_definitions =
+            value_definitions_for_path.partition { |value_definition| value_definition[:path].present? }
+
+          current_element_values_match =
+            current_element_value_definitions
+              .all? { |value_definition| value_definition[:value] == el_found }
+
+          child_element_values_match =
+            child_element_value_definitions.present? ?
+              verify_slice_by_values(el_found, child_element_value_definitions) : true
+          current_element_values_match && child_element_values_match
+        end
+      end
+    end
+  end
+end

data/lib/davinci_pdex_test_kit/group_metadata.rb

@@ -0,0 +1,109 @@
+module DaVinciPDexTestKit
+  class GroupMetadata
+    ATTRIBUTES = [
+      :name,
+      :class_name,
+      :version,
+      :reformatted_version,
+      :resource,
+      :profile_url,
+      :profile_name,
+      :profile_version,
+      :title,
+      :short_description,
+      :is_delayed,
+      :interactions,
+      :operations,
+      :searches,
+      :search_definitions,
+      :include_params,
+      :revincludes,
+      :required_concepts,
+      :must_supports,
+      :mandatory_elements,
+      :bindings,
+      :references,
+      :tests,
+      :granular_scope_tests,
+      :id,
+      :file_name,
+      :delayed_references
+    ].freeze
+
+    ATTRIBUTES.each { |name| attr_accessor name }
+
+    def initialize(metadata)
+      metadata.each do |key, value|
+        raise "Unknown attribute #{key}" unless ATTRIBUTES.include? key
+
+        instance_variable_set(:"@#{key}", value)
+      end
+    end
+
+    def delayed?
+      @is_delayed ||= if resource == 'Patient'
+                        false
+                      else
+                        no_patient_searches? || non_uscdi_resource?
+                      end
+    end
+
+    def exclude_search_tests?
+      delayed? && !searchable_delayed_resource?
+    end
+
+    def no_patient_searches?
+      searches.none? { |search| search[:names].include? 'patient' }
+    end
+
+    def non_uscdi_resource?
+      SpecialCases::NON_USCDI_RESOURCES.key?(resource) && SpecialCases::NON_USCDI_RESOURCES[resource].include?(reformatted_version)
+    end
+
+    def searchable_delayed_resource?
+      SpecialCases::SEARCHABLE_DELAYED_RESOURCES.key?(resource) && SpecialCases::SEARCHABLE_DELAYED_RESOURCES[resource].include?(reformatted_version)
+    end
+
+    def add_test(id:, file_name:)
+      self.tests ||= []
+
+      test_metadata = {
+        id: id,
+        file_name: file_name
+      }
+
+      if delayed? && id.include?('read')
+        self.tests.unshift(test_metadata)
+      else
+        self.tests << test_metadata
+      end
+    end
+
+    def add_granular_scope_test(id:, file_name:)
+      self.granular_scope_tests ||= []
+
+      self.granular_scope_tests << {
+        id:,
+        file_name:
+      }
+    end
+
+    def to_hash
+      ATTRIBUTES.each_with_object({}) { |key, hash| hash[key] = send(key) unless send(key).nil? }
+    end
+
+    def add_delayed_references(delayed_profiles, ig_resources)
+      self.delayed_references =
+        references
+          .select { |reference| (reference[:profiles] & delayed_profiles).present? }
+          .map do |reference|
+            profile_urls = (reference[:profiles] & delayed_profiles)
+            delayed_resources = profile_urls.map { |url| ig_resources.resource_for_profile(url) }
+            {
+              path: reference[:path].gsub("#{resource}.", ''),
+              resources: delayed_resources
+            }
+          end
+    end
+  end
+end