davinci_pas_test_kit 0.9.0

data/lib/davinci_pas_test_kit/generator/group_metadata_extractor.rb

@@ -0,0 +1,244 @@
+require_relative 'group_metadata'
+require_relative 'ig_metadata'
+require_relative 'must_support_metadata_extractor'
+require_relative 'terminology_binding_metadata_extractor'
+
+module DaVinciPASTestKit
+  class Generator
+    class GroupMetadataExtractor
+      attr_accessor :resource_capabilities, :profile_url, :ig_metadata, :ig_resources
+
+      def initialize(resource_capabilities, profile_url, ig_metadata, ig_resources)
+        self.resource_capabilities = resource_capabilities
+        self.profile_url = profile_url
+        self.ig_metadata = ig_metadata
+        self.ig_resources = ig_resources
+      end
+
+      def group_metadata
+        @group_metadata ||=
+          GroupMetadata.new(group_metadata_hash)
+      end
+
+      def group_metadata_hash
+        @group_metadata_hash ||=
+          {
+            name:,
+            class_name:,
+            version:,
+            reformatted_version:,
+            resource:,
+            conformance_expectation:,
+            profile_url:,
+            profile_name:,
+            profile_version:,
+            title:,
+            short_description:,
+            interactions:,
+            operations:,
+            # searches:,
+            # search_definitions:,
+            # include_params:,
+            # revincludes:,
+            required_concepts:,
+            must_supports:,
+            mandatory_elements:,
+            bindings:,
+            references:
+          }
+
+        # mark_mandatory_and_must_support_searches
+
+        @group_metadata_hash
+      end
+
+      # def mark_mandatory_and_must_support_searches
+      #   searches.each do |search|
+      #     search[:names_not_must_support_or_mandatory] = search[:names].reject do |name|
+      #       full_paths = search_definitions[name.to_sym][:full_paths]
+      #       any_must_support_elements = must_supports[:elements].any? do |element|
+      #         full_must_support_paths = ["#{resource}.#{element[:original_path]}", "#{resource}.#{element[:path]}"]
+
+      #         full_paths.any? do |path|
+      #           # allow for non-choice, choice types, and _id
+      #           name == '_id' ||
+      #                   full_must_support_paths.include?(path) ||
+      #                   full_must_support_paths.include?("#{path}[x]")
+      #         end
+      #       end
+
+      #       any_must_support_slices = must_supports[:slices].any? do |slice|
+      #         # only handle type slices because that is all we need for now
+      #         # for a slice like Observation.effective[x]:effectiveDateTime, the search parameter's expression could
+      #         # be either Observation.effective or Observation.effectiveDateTime.
+      #         if slice[:discriminator] && slice[:discriminator][:type] == 'type'
+      #           full_must_support_path = "#{resource}.#{slice[:path].sub('[x]', slice[:discriminator][:code])}"
+      #           base_must_support_path = "#{resource}.#{slice[:path].sub('[x]', '')}"
+
+      #           full_paths.intersection([full_must_support_path, base_must_support_path]).present?
+      #         else
+      #           false
+      #         end
+      #       end
+
+      #       any_mandatory_elements = mandatory_elements.any? do |element|
+      #         full_paths.include?(element)
+      #       end
+
+      #       any_must_support_elements || any_must_support_slices || any_mandatory_elements
+      #     end
+
+      #     search[:must_support_or_mandatory] = search[:names_not_must_support_or_mandatory].empty?
+      #   end
+      # end
+
+      def profile
+        @profile ||= ig_resources.profile_by_url(profile_url)
+      end
+
+      def profile_elements
+        @profile_elements ||= profile.snapshot.element
+      end
+
+      def base_name
+        profile_url.split('StructureDefinition/').last
+      end
+
+      def name
+        base_name.tr('-', '_')
+      end
+
+      def class_name
+        base_name
+          .split('-')
+          .map(&:capitalize)
+          .join
+          .gsub('PAS', "PAS#{ig_metadata.reformatted_version}")
+          .concat('Sequence')
+      end
+
+      def version
+        ig_metadata.ig_version
+      end
+
+      def reformatted_version
+        ig_metadata.reformatted_version
+      end
+
+      def resource
+        profile.type
+      end
+
+      def conformance_expectation
+        resource_capabilities&.extension&.first&.valueCode
+      end
+
+      def profile_name
+        profile.title.gsub('  ', ' ')
+      end
+
+      def profile_version
+        profile.version
+      end
+
+      def title
+        puts profile.title
+        profile.title.gsub(/PAS\s*/, '').gsub(/\s*Profile/, '').strip
+      end
+
+      def short_description
+        "Verify support for the server capabilities required by the #{profile_name}."
+      end
+
+      def interactions
+        @interactions ||=
+          resource_capabilities.interaction.map do |interaction|
+            {
+              code: interaction.code,
+              expectation: interaction&.extension&.first&.valueCode # TODO: fix expectation extension finding
+            }
+          end
+      end
+
+      def operations
+        @operations ||=
+          resource_capabilities.operation.map do |operation|
+            {
+              code: operation.name,
+              expectation: operation&.extension&.first&.valueCode # TODO: fix expectation extension finding
+            }
+          end
+      end
+
+      # def search_metadata_extractor
+      #   @search_metadata_extractor ||=
+      #     SearchMetadataExtractor.new(resource_capabilities, ig_resources, resource, profile_elements)
+      # end
+
+      # def searches
+      #   @searches ||= search_metadata_extractor.searches
+      # end
+
+      # def search_definitions
+      #   @search_definitions ||= search_metadata_extractor.search_definitions
+      # end
+
+      # def include_params
+      #   resource_capabilities.searchInclude || []
+      # end
+
+      # def revincludes
+      #   resource_capabilities.searchRevInclude || []
+      # end
+
+      def required_concepts
+        return [] if resource == 'Observation'
+
+        profile_elements
+          .select { |element| element.type&.any? { |type| type.code == 'CodeableConcept' } }
+          .select { |element| element.binding&.strength == 'required' }
+          .map { |element| element.path.gsub("#{resource}.", '').gsub('[x]', 'CodeableConcept') }
+      end
+
+      def terminology_binding_metadata_extractor
+        @terminology_binding_metadata_extractor ||=
+          TerminologyBindingMetadataExtractor.new(profile_elements, ig_resources, resource)
+      end
+
+      def bindings
+        @bindings ||=
+          terminology_binding_metadata_extractor.terminology_bindings
+      end
+
+      def must_support_metadata_extractor
+        @must_support_metadata_extractor ||=
+          MustSupportMetadataExtractor.new(profile_elements, profile, resource, ig_resources)
+      end
+
+      def must_supports
+        @must_supports ||=
+          must_support_metadata_extractor.must_supports
+      end
+
+      def mandatory_elements
+        @mandatory_elements ||=
+          profile_elements
+            .select { |element| element.min.positive? }
+            .map(&:path)
+            .uniq
+      end
+
+      def references
+        @references ||=
+          profile_elements
+            .select { |element| element.type&.first&.code == 'Reference' }
+            .map do |reference_definition|
+            {
+              path: reference_definition.path,
+              profiles: reference_definition.type.first.targetProfile
+            }
+          end
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/ig_loader.rb

@@ -0,0 +1,78 @@
+require 'active_support/all'
+require 'fhir_models'
+require 'pathname'
+require 'rubygems/package'
+require 'zlib'
+require 'pry'
+require_relative 'ig_resources'
+
+module DaVinciPASTestKit
+  class Generator
+    class IGLoader
+      attr_accessor :ig_file_name
+
+      def initialize(ig_file_name)
+        self.ig_file_name = ig_file_name
+      end
+
+      def ig_resources
+        @ig_resources ||= IGResources.new
+      end
+
+      def load
+        load_ig
+        load_standalone_resources
+      end
+
+      def load_ig
+        tar = Gem::Package::TarReader.new(
+          Zlib::GzipReader.open(ig_file_name)
+        )
+
+        tar.each do |entry|
+          next if entry.directory?
+
+          file_name = entry.full_name.split('/').last
+
+          next unless file_name.end_with? '.json'
+
+          next unless entry.full_name.start_with? 'package/'
+
+          begin
+            resource = FHIR.from_contents(entry.read)
+            next if resource.nil?
+          rescue StandardError
+            puts "#{file_name} does not appear to be a FHIR resource."
+            next
+          end
+
+          ig_resources.add(resource)
+        end
+
+        ig_resources
+      end
+
+      def load_standalone_resources
+        ig_directory = ig_file_name.chomp('.tgz')
+
+        return ig_resources unless File.exist? ig_directory
+
+        Dir.glob(File.join(ig_directory, '*.json')).each do |file_path|
+          begin
+            resource = FHIR.from_contents(File.read(file_path))
+
+            next if resource.nil?
+          rescue StandardError
+            file_name = file_path.split('/').last
+            puts "#{file_name} does not appear to be a FHIR resource."
+            next
+          end
+
+          ig_resources.add(resource)
+        end
+
+        ig_resources
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/ig_metadata.rb

@@ -0,0 +1,66 @@
+module DaVinciPASTestKit
+  class Generator
+    class IGMetadata
+      attr_accessor :ig_version, :groups, :use_case_groups
+
+      def reformatted_version
+        @reformatted_version ||= ig_version.delete('.-')
+      end
+
+      def ordered_groups
+        @ordered_groups ||=
+          [patient_group] + non_delayed_groups + delayed_groups
+      end
+
+      def patient_group
+        @patient_group ||=
+          groups.find { |group| group.resource == 'Patient' }
+      end
+
+      def delayed_groups
+        @delayed_groups ||=
+          groups.select(&:delayed?)
+      end
+
+      def non_delayed_groups
+        @non_delayed_groups ||=
+          groups.reject(&:delayed?) - [patient_group]
+      end
+
+      def delayed_profiles
+        @delayed_profiles ||=
+          delayed_groups.map(&:profile_url)
+      end
+
+      def add_use_case_groups(id, file_name)
+        @use_case_groups ||= []
+        @use_case_groups << { id:, file_name: }
+      end
+
+      def bundle_groups
+        @bundle_groups ||=
+          groups.select { |group| group.resource == 'Bundle' }
+            .reject { |group| group.profile_name.include?('Base') }
+      end
+
+      def claim_groups
+        @claim_groups ||=
+          groups.select { |group| group.resource == 'Claim' }
+            .reject { |group| group.profile_name.include?('Base') }
+      end
+
+      def postprocess_groups(ig_resources)
+        groups.each do |group|
+          group.add_delayed_references(delayed_profiles, ig_resources)
+        end
+      end
+
+      def to_hash
+        {
+          ig_version:,
+          groups: groups.map(&:to_hash)
+        }
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/ig_metadata_extractor.rb

@@ -0,0 +1,54 @@
+require_relative 'ig_metadata'
+require_relative 'group_metadata_extractor'
+require 'pry'
+module DaVinciPASTestKit
+  class Generator
+    class IGMetadataExtractor
+      attr_accessor :ig_resources, :metadata
+
+      def initialize(ig_resources)
+        self.ig_resources = ig_resources
+        self.metadata = IGMetadata.new
+      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
+        # TODO: uncomment bellow when PAS IG will have a solid capability statement.
+        # ig_resources.capability_statement.rest.first.resource
+
+        # Work around for the code above to extract the IG supported profiles/resources
+        resources = []
+        ig_resources.base_resources_and_supported_profiles.each do |k, v|
+          resource = FHIR::CapabilityStatement::Rest::Resource.new(
+            type: k,
+            supportedProfile: v,
+            operation: k == 'Claim' ? [{ name: '$submit' }, { name: '$inquire' }] : []
+          )
+          resources << resource
+        end
+
+        resources
+      end
+
+      def add_metadata_from_resources
+        metadata.groups =
+          resources_in_capability_statement.flat_map do |resource|
+            resource.supportedProfile&.map do |supported_profile|
+              GroupMetadataExtractor.new(resource, supported_profile, metadata, ig_resources).group_metadata
+            end
+          end
+
+        metadata.postprocess_groups(ig_resources)
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/ig_resources.rb

@@ -0,0 +1,74 @@
+module DaVinciPASTestKit
+  class Generator
+    class IGResources
+      def add(resource)
+        resources_by_type[resource.resourceType] << resource
+      end
+
+      def capability_statement(mode = 'server')
+        resources_by_type['CapabilityStatement'].find do |capability_statement_resource|
+          capability_statement_resource.rest.any? { |r| r.mode == mode }
+        end
+      end
+
+      def base_resources_and_supported_profiles
+        definitions = [
+          'ImplementationGuide',
+          'CapabilityStatement',
+          'CodeSystem',
+          'OperationDefinition',
+          'StructureDefinition',
+          'ValueSet'
+        ]
+        base_resources = resources_by_type.keys.reject { |k| definitions.include?(k) }
+        resource_profiles = {}
+        base_resources.each do |res|
+          profile_urls = resources_by_type['StructureDefinition'].find_all { |p| p.type == res }.map(&:url)
+          resource_profiles[res] = profile_urls
+        end
+        resource_profiles
+      end
+
+      def ig
+        resources_by_type['ImplementationGuide'].first
+      end
+
+      def inspect
+        'IGResources'
+      end
+
+      def profile_by_url(url)
+        resources_by_type['StructureDefinition'].find { |profile| profile.url == url }
+      end
+
+      def resource_type_for_profile(url)
+        profile_by_url(url).type
+      end
+
+      def value_set_by_url(url)
+        resources_by_type['ValueSet'].find { |profile| profile.url == url }
+      end
+
+      # def search_param_by_resource_and_name(resource, name)
+      #   # remove '_' from search parameter name, such as _id or _tag
+      #   normalized_name = normalized_name = name.to_s.delete_prefix('_')
+
+      #   param = resources_by_type['SearchParameter']
+      #     .find { |param| param.id == "#{resource.downcase}-#{normalized_name}" }
+
+      #   if param.nil?
+      #     param = resources_by_type['SearchParameter']
+      #       .find { |param| param.id == "Resource-#{normalized_name}" }
+      #   end
+
+      #   return param
+      # end
+
+      private
+
+      def resources_by_type
+        @resources_by_type ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+    end
+  end
+end

data/lib/davinci_pas_test_kit/generator/must_support_check_profiles.rb

@@ -0,0 +1,86 @@
+module DaVinciPASTestKit
+  class Generator
+    module MustSupportCheckProfiles
+      SUBMIT_REQUEST_REQUIRED_PROFILES = [
+        'PAS Request Bundle',
+        'PAS Beneficiary Patient',
+        'PAS Claim Update',
+        'PAS Coverage',
+        'PAS Device Request',
+        'PAS Encounter',
+        'PAS Insurer Organization',
+        'PAS Medication Request',
+        'PAS Nutrition Order',
+        'PAS Practitioner',
+        'PAS PractitionerRole',
+        'PAS Requestor Organization',
+        'PAS Service Request',
+        'PAS Subscriber Patient'
+      ].freeze
+
+      SUBMIT_RESPONSE_REQUIRED_PROFILES = [
+        'PAS Beneficiary Patient',
+        'PAS Claim Response',
+        'PAS CommunicationRequest',
+        'PAS Insurer Organization',
+        'PAS Practitioner',
+        'PAS PractitionerRole',
+        'PAS Requestor Organization',
+        'PAS Response Bundle',
+        'PAS Task'
+      ].freeze
+
+      INQUIRY_REQUEST_REQUIRED_PROFILES = [
+        'PAS Beneficiary Patient',
+        'PAS Claim Inquiry',
+        'PAS Coverage',
+        'PAS Inquiry Request Bundle',
+        'PAS Insurer Organization',
+        'PAS Practitioner',
+        'PAS PractitionerRole',
+        'PAS Requestor Organization',
+        'PAS Subscriber Patient'
+      ].freeze
+
+      INQUIRY_RESPONSE_REQUIRED_PROFILES = [
+        'PAS Beneficiary Patient',
+        'PAS Claim Inquiry Response',
+        'PAS Inquiry Response Bundle',
+        'PAS Insurer Organization',
+        'PAS Practitioner',
+        'PAS PractitionerRole',
+        'PAS Requestor Organization',
+        'PAS Task'
+      ].freeze
+
+      OPTIONAL_PROFILES = [
+        'PAS Medication Request',
+        'PAS Service Request',
+        'PAS Device Request',
+        'PAS Nutrition Order'
+      ].freeze
+
+      class << self
+        def submit_request_group?(group)
+          SUBMIT_REQUEST_REQUIRED_PROFILES.include?(group.profile_name)
+        end
+
+        def submit_response_group?(group)
+          SUBMIT_RESPONSE_REQUIRED_PROFILES.include?(group.profile_name)
+        end
+
+        def inquiry_request_group?(group)
+          INQUIRY_REQUEST_REQUIRED_PROFILES.include?(group.profile_name)
+        end
+
+        def inquiry_response_group?(group)
+          INQUIRY_RESPONSE_REQUIRED_PROFILES.include?(group.profile_name)
+        end
+
+        def optional_group?(group)
+          OPTIONAL_PROFILES.include?(group.profile_name)
+        end
+      end
+    end
+  end
+end