fhir_scorecard 1.0

data/lib/rubrics/codes_umls.rb

@@ -0,0 +1,105 @@
+module FHIR
+  class CodesUmls < FHIR::Rubrics
+
+    # SNOMED, LOINC, RxNorm, ICD9, and ICD10 codes validate against UMLS
+    rubric :codes_umls do |record|
+      results = {
+        :eligible_fields => 0,
+        :validated_fields => 0
+      }
+      resources = record.entry.map{|e|e.resource}
+      resources.each do |resource|
+        results.merge!(check_fields(resource)){|k,a,b|a+b}
+      end
+
+      percentage = results[:validated_fields].to_f / results[:eligible_fields].to_f
+      percentage = 0.0 if percentage.nan?
+      points = 10.0 * percentage
+      message = "#{(100 * percentage).to_i}% (#{results[:validated_fields]}/#{results[:eligible_fields]}) of SNOMED, LOINC, RxNorm, ICD9, and ICD10 validated against UMLS. Maximum of 10 points."
+      response(points.to_i,message)
+    end
+
+    def self.check_fields(fhir_model)
+      results = {
+        :eligible_fields => 0,
+        :validated_fields => 0
+      }
+      # check each codeable field
+      fhir_model.class::METADATA.each do |key, meta|
+        field_name = meta['local_name'] || key
+        declared_binding = eligible_binding(meta)
+        supposed_to_be_umls = !declared_binding.nil?
+        value = fhir_model.instance_variable_get("@#{field_name}")
+
+        if meta['type']=='Coding'
+          if value.is_a?(Array)
+            value.each do |v| 
+              results.merge!(check_coding(v,supposed_to_be_umls,declared_binding)){|k,a,b|a+b}            
+            end
+          else
+            results.merge!(check_coding(value,supposed_to_be_umls,declared_binding)){|k,a,b|a+b}
+          end
+        elsif meta['type']=='CodeableConcept'
+          if value.is_a?(Array)
+            value.each do |cc|
+              cc.coding.each do |c|
+                results.merge!(check_coding(c,supposed_to_be_umls,declared_binding)){|k,a,b|a+b}
+              end
+            end
+          else
+            if value.nil?
+              results[:eligible_fields] += 1 if supposed_to_be_umls
+            else
+              value.coding.each do |c|
+                results.merge!(check_coding(c,supposed_to_be_umls,declared_binding)){|k,a,b|a+b}
+              end
+            end
+          end
+        elsif !value.nil?
+          if value.is_a?(Array)
+            value.each{|v| results.merge!(check_fields(v)){|k,a,b|a+b} if v.is_a?(FHIR::Model)}
+          else # not an Array
+            results.merge!(check_fields(value)){|k,a,b|a+b} if value.is_a?(FHIR::Model)
+          end
+        end
+      end
+      results
+    end
+
+    # This method checks whether or not the coding is eligible and validates.
+    # A coding is eligible if it is supposed to be UMLS (as declared in the
+    # resource metadata) or it is locally declared as one of the UMLS systems.
+    # If the coding is eligible, then it is validated.
+    def self.check_coding(coding,supposed_to_be_umls,declared_binding)
+      result = {
+        :eligible_fields => 0,
+        :validated_fields => 0
+      } 
+      if coding.nil?
+        result[:eligible_fields] += 1 if supposed_to_be_umls
+      else
+        local_binding = coding.system || declared_binding
+        if supposed_to_be_umls || FHIR::Terminology::CODE_SYSTEMS[local_binding]
+          result[:eligible_fields] += 1 
+          in_umls = !FHIR::Terminology.get_description(FHIR::Terminology::CODE_SYSTEMS[local_binding],coding.code).nil?
+          result[:validated_fields] +=1 if in_umls
+        end
+      end
+      result
+    end
+
+    # This method checks the metadata on this field and returns the binding key (e.g. 'SNOMED')
+    # if one of the UMLS code systems was specified. Otherwise, it returns nil.
+    def self.eligible_binding(metadata)
+      vs_binding = metadata['binding']
+      matching_binding = FHIR::Terminology::CODE_SYSTEMS[vs_binding['uri']] if !vs_binding.nil? && vs_binding['uri']
+
+      valid_codes = metadata['valid_codes']
+      matching_code_system = valid_codes.keys.find{|k| FHIR::Terminology::CODE_SYSTEMS[k]} if !valid_codes.nil?
+      matching_code_system = FHIR::Terminology::CODE_SYSTEMS[matching_code_system] if matching_code_system
+
+      matching_binding || matching_code_system
+    end
+
+  end
+end

data/lib/rubrics/codes_umls_preferred_descriptions.rb

@@ -0,0 +1,105 @@
+module FHIR
+  class CodesUmlsPreferredDescriptions < FHIR::Rubrics
+
+    # SNOMED, LOINC, RxNorm, ICD9, and ICD10 codes in UMLS use preferred descriptions
+    rubric :descriptions do |record|
+      results = {
+        :eligible_fields => 0,
+        :correct_descriptions => 0
+      }
+      resources = record.entry.map{|e|e.resource}
+      resources.each do |resource|
+        results.merge!(check_fields(resource)){|k,a,b|a+b}
+      end
+
+      percentage = results[:correct_descriptions].to_f / results[:eligible_fields].to_f
+      percentage = 0.0 if percentage.nan?
+      points = 10.0 * percentage
+      message = "#{(100 * percentage).to_i}% (#{results[:correct_descriptions]}/#{results[:eligible_fields]}) of SNOMED, LOINC, RxNorm, ICD9, and ICD10 codes use preferred descriptions. Maximum of 10 points."
+      response(points.to_i,message)
+    end
+
+    def self.check_fields(fhir_model)
+      results = {
+        :eligible_fields => 0,
+        :correct_descriptions => 0
+      }
+      # check each codeable field
+      fhir_model.class::METADATA.each do |key, meta|
+        field_name = meta['local_name'] || key
+        declared_binding = eligible_binding(meta)
+        supposed_to_be_umls = !declared_binding.nil?
+        value = fhir_model.instance_variable_get("@#{field_name}")
+
+        if meta['type']=='Coding'
+          if value.is_a?(Array)
+            value.each do |v| 
+              results.merge!(check_coding(v,supposed_to_be_umls,declared_binding)){|k,a,b|a+b}            
+            end
+          else
+            results.merge!(check_coding(value,supposed_to_be_umls,declared_binding)){|k,a,b|a+b}
+          end
+        elsif meta['type']=='CodeableConcept'
+          if value.is_a?(Array)
+            value.each do |cc|
+              cc.coding.each do |c|
+                results.merge!(check_coding(c,supposed_to_be_umls,declared_binding)){|k,a,b|a+b}
+              end
+            end
+          else
+            if value.nil?
+              results[:eligible_fields] += 1 if supposed_to_be_umls
+            else
+              value.coding.each do |c|
+                results.merge!(check_coding(c,supposed_to_be_umls,declared_binding)){|k,a,b|a+b}
+              end
+            end
+          end
+        elsif !value.nil?
+          if value.is_a?(Array)
+            value.each{|v| results.merge!(check_fields(v)){|k,a,b|a+b} if v.is_a?(FHIR::Model)}
+          else # not an Array
+            results.merge!(check_fields(value)){|k,a,b|a+b} if value.is_a?(FHIR::Model)
+          end
+        end
+      end
+      results
+    end
+
+    # This method checks whether or not the coding is eligible and checks the description.
+    # A coding is eligible if it is supposed to be UMLS (as declared in the
+    # resource metadata) or it is locally declared as one of the UMLS systems.
+    # If the coding is eligible, then the description is checked against the preferred description.
+    def self.check_coding(coding,supposed_to_be_umls,declared_binding)
+      result = {
+        :eligible_fields => 0,
+        :correct_descriptions => 0
+      } 
+      if coding.nil?
+        result[:eligible_fields] += 1 if supposed_to_be_umls
+      else
+        local_binding = coding.system || declared_binding
+        if supposed_to_be_umls || FHIR::Terminology::CODE_SYSTEMS[local_binding]
+          result[:eligible_fields] += 1 
+          preferred = FHIR::Terminology.get_description(FHIR::Terminology::CODE_SYSTEMS[local_binding],coding.code)
+          result[:correct_descriptions] +=1 if preferred==coding.display
+        end
+      end
+      result
+    end
+
+    # This method checks the metadata on this field and returns the binding key (e.g. 'SNOMED')
+    # if one of the UMLS code systems was specified. Otherwise, it returns nil.
+    def self.eligible_binding(metadata)
+      vs_binding = metadata['binding']
+      matching_binding = FHIR::Terminology::CODE_SYSTEMS[vs_binding['uri']] if !vs_binding.nil? && vs_binding['uri']
+
+      valid_codes = metadata['valid_codes']
+      matching_code_system = valid_codes.keys.find{|k| FHIR::Terminology::CODE_SYSTEMS[k]} if !valid_codes.nil?
+      matching_code_system = FHIR::Terminology::CODE_SYSTEMS[matching_code_system] if matching_code_system
+
+      matching_binding || matching_code_system
+    end
+
+  end
+end

data/lib/rubrics/completeness.rb

@@ -0,0 +1,61 @@
+module FHIR
+  class Completeness < FHIR::Rubrics
+
+    REQUIRED = [
+      'AllergyIntolerance','Condition','CarePlan','Immunization',
+      'Observation','Encounter'
+    ]
+
+    EXPECTED = [ 
+      'FamilyMemberHistory','DiagnosticReport','ImagingStudy','VisionPrescription',
+      'Practitioner','Organization','Communication','Appointment','DeviceUseStatement',
+      'QuestionnaireResponse','Coverage'
+    ]
+
+    MEDICATIONS = [ 'MedicationStatement','MedicationDispense','MedicationAdministration','MedicationOrder' ]
+
+    # A Patient Record is not complete without certain required items and medications.
+    rubric :completeness do |record|
+      
+      missing_required = REQUIRED.clone
+      missing_expected = EXPECTED.clone
+      missing_meds = MEDICATIONS.clone
+
+      resources = record.entry.map{|e|e.resource}
+      resources.each do |resource|
+        if !resource.nil?
+          missing_required.delete(resource.resourceType)
+          missing_expected.delete(resource.resourceType)
+          missing_meds.delete(resource.resourceType)
+        end
+      end
+
+      # 15 points for required resources
+      numerator = (REQUIRED.length.to_f - missing_required.length.to_f)
+      numerator += 1 if (missing_meds.length < MEDICATIONS.length)
+      denominator = REQUIRED.length.to_f + 1.0 # add one for medications
+      percentage_required = (  numerator / denominator )
+      percentage_required = 0.0 if percentage_required.nan?
+      points = 20.0 * percentage_required
+
+      # 5 points for expected resources
+      numerator = (EXPECTED.length.to_f - missing_expected.length.to_f)
+      denominator = EXPECTED.length.to_f
+      percentage_expected = (  numerator / denominator )
+      percentage_expected = 0.0 if percentage_expected.nan?
+      points += (5.0 * percentage_expected)    
+
+      message = "#{(100 * percentage_required).to_i}% of REQUIRED Resources and #{(100 * percentage_expected).to_i}% of EXPECTED Resources were present. Maximum of 20 points."
+      response(points.to_i,message)
+    end
+
+    def self.get_vital_code(codeableconcept)
+      return nil if codeableconcept.nil? || codeableconcept.coding.nil?
+
+      coding = codeableconcept.coding.find{|x| x.system=='http://loinc.org' && VITAL_SIGNS.has_key?(x.code)}
+      code = coding.code if coding
+      code
+    end
+
+  end
+end

data/lib/rubrics/cvx_immunizations.rb

@@ -0,0 +1,32 @@
+module FHIR
+  class CVXImmunizations < FHIR::Rubrics
+
+    # Immunizations should be coded with CVX
+    rubric :cvx_immunizations do |record|
+      results = {
+        :eligible_fields => 0,
+        :validated_fields => 0
+      }
+
+      resources = record.entry.map{|e|e.resource}
+      resources.each do |resource|
+        if resource.is_a?(FHIR::Immunization)
+            results[:eligible_fields] += 1
+            results[:validated_fields] += 1 if cvx?(resource.vaccineCode)        
+        end
+      end
+
+      percentage = results[:validated_fields].to_f / results[:eligible_fields].to_f
+      percentage = 0.0 if percentage.nan?
+      points = 10.0 * percentage
+      message = "#{(100 * percentage).to_i}% (#{results[:validated_fields]}/#{results[:eligible_fields]}) of Immunization vaccine codes use CVX. Maximum of 10 points."
+      response(points.to_i,message)
+    end
+
+    def self.cvx?(codeableconcept)
+      return false if codeableconcept.nil? || codeableconcept.coding.nil?
+      codeableconcept.coding.any?{|x| x.system=='http://hl7.org/fhir/sid/cvx' && FHIR::Terminology.get_description('CVX',x.code)}
+    end
+
+  end
+end

data/lib/rubrics/cvx_meds.rb

@@ -0,0 +1,73 @@
+module FHIR
+  class CVXMeds < FHIR::Rubrics
+
+    # Medications should *NOT* be coded with CVX
+    rubric :cvx_medications do |record|
+      results = {
+        :eligible_fields => 0,
+        :validated_fields => 0
+      }
+      # Medication.code (CodeableConcept)
+      # MedicationAdministration.medicationCodeableConcept / medicationReference
+      # MedicationDispense.medicationCodeableConcept / medicationReference
+      # MedicationOrder.medicationCodeableConcept / medicationReference
+      # MedicationStatement.medicationCodeableConcept / medicationReference
+
+      resources = record.entry.map{|e|e.resource}
+      resources.each do |resource|
+        if resource.is_a?(FHIR::Medication)
+            results[:eligible_fields] += 1
+            results[:validated_fields] += 1 if cvx?(resource.code)        
+        elsif (
+            resource.is_a?(FHIR::MedicationOrder) ||
+            resource.is_a?(FHIR::MedicationDispense) ||
+            resource.is_a?(FHIR::MedicationAdministration) ||
+            resource.is_a?(FHIR::MedicationStatement) )
+          if resource.medicationCodeableConcept
+            results[:eligible_fields] += 1
+            results[:validated_fields] += 1 if cvx?(resource.medicationCodeableConcept)
+          elsif resource.medicationReference
+            results[:eligible_fields] += 1
+            results[:validated_fields] += 1 if local_cvx_reference?(resource.medicationReference,record,resource.contained)            
+          end
+        end
+      end
+
+      percentage = results[:validated_fields].to_f / results[:eligible_fields].to_f
+      percentage = 0.0 if percentage.nan?
+      points = -10.0 * percentage
+      message = "#{(100 * percentage).to_i}% (#{results[:validated_fields]}/#{results[:eligible_fields]}) of Medication[x] Resource codes use CVX. Maximum of 10 point penalty."
+      response(points.to_i,message)
+    end
+
+    def self.cvx?(codeableconcept)
+      return false if codeableconcept.nil? || codeableconcept.coding.nil?
+      codeableconcept.coding.any?{|x| x.system=='http://hl7.org/fhir/sid/cvx' && FHIR::Terminology.get_description('CVX',x.code)}
+    end
+
+    def self.local_cvx_reference?(reference,record,contained)
+      if contained && reference.reference && reference.reference.start_with?('#')
+        contained.each do |resource|
+          return true if resource.is_a?(FHIR::Medication) && reference.reference[1..-1]==resource.id
+        end
+      end
+      record.entry.each do |entry|
+        if entry.resource.is_a?(FHIR::Medication) && reference_matchs?(reference,entry)
+          return true
+        end
+      end
+      false    
+    end
+
+    def self.reference_matchs?(reference,entry)
+      if reference.reference.start_with?('urn:uuid:')
+        (reference.reference == entry.fullUrl)
+      elsif reference.reference.include?('Medication/')
+        (reference.reference.split('Medication/').last.split('/').first == entry.id)
+      else 
+        false # unable to verify reference points to CVX
+      end
+    end
+
+  end
+end

data/lib/rubrics/datetimes_iso8601.rb

@@ -0,0 +1,73 @@
+module FHIR
+  class DateTimesIso8601 < FHIR::Rubrics
+
+    # Codes are present for all codes, Codings, and CodeableConcepts
+    rubric :iso8601_dates do |record|
+      results = {
+        :datetime_fields => 0,
+        :iso8601_fields => 0
+      }
+      resources = record.entry.map{|e|e.resource}
+      resources.each do |resource|
+        results.merge!(check_metadata(resource)){|k,a,b|a+b}
+      end
+
+      percentage = results[:iso8601_fields].to_f / results[:datetime_fields].to_f
+      percentage = 0.0 if percentage.nan?
+      points = 10.0 * percentage
+      message = "#{(100 * percentage).to_i}% (#{results[:iso8601_fields]}/#{results[:datetime_fields]}) of date/time/dateTime/instant fields were populated with reasonable iso8601 values. Maximum of 10 points."
+      response(points.to_i,message)
+    end
+
+    def self.check_metadata(fhir_model)
+      results = {
+        :datetime_fields => 0,
+        :iso8601_fields => 0
+      }
+      # check for metadata
+      # count all codeable fields
+      fhir_model.class::METADATA.each do |key, meta|
+        field_name = meta['local_name'] || key
+        if ['date','time','dateTime','instant'].include?(meta['type'])
+          results[:datetime_fields] += 1
+          value = fhir_model.instance_variable_get("@#{field_name}")
+          # check that the field is actually the correct type
+          if !value.nil?
+            if value.is_a?(Array)
+              if !value.empty? # the Array has at least one value
+                results[:iso8601_fields] += 1 if value.any?{|x|type_okay(meta['type'],x)}
+              end
+            else # not an Array
+              results[:iso8601_fields] += 1 if type_okay(meta['type'],value)
+            end
+          end
+        else
+          value = fhir_model.instance_variable_get("@#{field_name}")
+          if !value.nil?
+            if value.is_a?(Array)
+              value.each{|v| results.merge!(check_metadata(v)){|k,a,b|a+b} if v.is_a?(FHIR::Model)}
+            else # not an Array
+              results.merge!(check_metadata(value)){|k,a,b|a+b} if value.is_a?(FHIR::Model)
+            end
+          end            
+        end
+      end
+      results
+    end
+
+    def self.type_okay(type,item)
+      okay = false
+      begin
+        time = Time.iso8601(item)
+        okay = true
+        if time.year
+          okay = (time.year > 1900) && (time.year < (Time.now + (10 * 365 * 24 * 60 * 60)).year)
+        end
+      rescue Exception => e
+        okay = false
+      end
+      okay
+    end
+
+  end
+end

data/lib/rubrics/labs_loinc.rb

@@ -0,0 +1,38 @@
+module FHIR
+  class LabsLoinc < FHIR::Rubrics
+
+    # Lab Results should be coded with LOINC's top 2000 codes
+    rubric :loinc_labs do |record|
+      results = {
+        :eligible_fields => 0,
+        :validated_fields => 0
+      }
+      resources = record.entry.map{|e|e.resource}
+      resources.each do |resource|
+        if resource.is_a?(FHIR::DiagnosticReport) || resource.is_a?(FHIR::Observation)
+          results[:eligible_fields] += 1
+          if resource.code
+            results[:validated_fields] += 1 if resource.code.coding.any?{|x| x.system=='http://loinc.org' && FHIR::Terminology.is_top_lab_code?(x.code)}
+          end
+        end
+        if resource.is_a?(FHIR::Observation)
+          if resource.component
+            resource.component.each do |comp|
+              results[:eligible_fields] += 1
+              if comp.code
+                results[:validated_fields] += 1 if comp.code.coding.any?{|x| x.system=='http://loinc.org' && FHIR::Terminology.is_top_lab_code?(x.code)}
+              end              
+            end
+          end
+        end
+      end
+
+      percentage = results[:validated_fields].to_f / results[:eligible_fields].to_f
+      percentage = 0.0 if percentage.nan?
+      points = 10.0 * percentage
+      message = "#{(100 * percentage).to_i}% (#{results[:validated_fields]}/#{results[:eligible_fields]}) of Observations and DiagnosticReports validated against the LOINC Top 2000. Maximum of 10 points."
+      response(points.to_i,message)
+    end
+
+  end
+end

data/lib/rubrics/quantities_ucum.rb

@@ -0,0 +1,69 @@
+module FHIR
+  class QuantitiesUcum < FHIR::Rubrics
+
+    IGNORE = [
+      'TestScript','Task','StructureDefinition','SearchParameter','Questionnaire','QuestionnaireResponse','Parameters','OperationDefinition',
+      'Group','ExplanationOfBenefit','Contract','Conformance','Claim','ActivityDefinition'
+    ]
+
+    CHECK = [
+      'VisionPrescription','SupplyDelivery','Substance','Specimen','Sequence','Observation','NutritionRequest',
+      'MedicationStatement','MedicationOrder','MedicationDispense','MedicationAdministration','Medication','Immunization','CarePlan'
+    ]
+
+    # Physical quantities should use UCUM
+    rubric :ucum_quantities do |record|
+      results = {
+        :eligible_fields => 0,
+        :validated_fields => 0
+      }
+      resources = record.entry.map{|e|e.resource}
+      resources.each do |resource|
+        results.merge!(check_fields(resource)){|k,a,b|a+b} if CHECK.include?(resource.resourceType)
+      end
+
+      percentage = results[:validated_fields].to_f / results[:eligible_fields].to_f
+      percentage = 0.0 if percentage.nan?
+      points = 10.0 * percentage
+      message = "#{(100 * percentage).to_i}% (#{results[:validated_fields]}/#{results[:eligible_fields]}) of physical quantities used or declared UCUM. Maximum of 10 points."
+      response(points.to_i,message)
+    end
+
+    def self.check_fields(fhir_model)
+      results = {
+        :eligible_fields => 0,
+        :validated_fields => 0
+      }
+      # check each codeable field
+      fhir_model.class::METADATA.each do |key, meta|
+        field_name = meta['local_name'] || key
+        value = fhir_model.instance_variable_get("@#{field_name}")
+
+        if meta['type']=='Quantity'
+          if value.is_a?(Array)
+            value.each do |v| 
+              results.merge!(check_quantity(v)){|k,a,b|a+b}            
+            end
+          else
+            results.merge!(check_quantity(value)){|k,a,b|a+b}
+          end
+        end
+      end
+      results
+    end
+
+    # This method checks whether or not the quantity uses UCUM.
+    def self.check_quantity(quantity)
+      result = {
+        :eligible_fields => 1,
+        :validated_fields => 0
+      } 
+      if quantity && quantity.system && quantity.system.start_with?('http://unitsofmeasure.org')
+        result[:validated_fields] +=1 
+      elsif quantity && quantity.unit 
+        result[:validated_fields] +=1 if FHIR::Terminology.is_known_ucum?(quantity.unit)        
+      end
+      result
+    end
+  end
+end

data/lib/rubrics/references_resolve.rb

@@ -0,0 +1,86 @@
+module FHIR
+  class ReferencesResolve < FHIR::Rubrics
+
+    # All References should resolve to Resources within the Bundle.
+    rubric :references_resolve do |record|
+      results = {
+        :eligible_fields => 0,
+        :validated_fields => 0
+      }
+
+      resources = record.entry.map{|e|e.resource}
+      resources.each do |resource|
+        results.merge!(check_metadata(resource,record)){|k,a,b|a+b}
+      end
+
+      percentage = results[:validated_fields].to_f / results[:eligible_fields].to_f
+      percentage = 0.0 if percentage.nan?
+      points = 10.0 * percentage
+      message = "#{(100 * percentage).to_i}% (#{results[:validated_fields]}/#{results[:eligible_fields]}) of all possible References resolved locally within the Bundle. Maximum of 10 points."
+      response(points.to_i,message)
+    end
+
+    def self.check_metadata(fhir_model,record)
+      results = {
+        :eligible_fields => 0,
+        :validated_fields => 0
+      }
+      # check for metadata
+      # examine all References
+      fhir_model.class::METADATA.each do |key, meta|
+        field_name = meta['local_name'] || key
+        if meta['type']=='Reference'
+          results[:eligible_fields] += 1
+          value = fhir_model.instance_variable_get("@#{field_name}")
+          # check that the field is actually the correct type
+          if !value.nil?
+            if value.is_a?(Array)
+              if !value.empty? # the Array has at least one value
+                results[:eligible_fields] += (value.length-1)
+                value.each do |ref|
+                  results[:validated_fields] += 1 if local_reference?(ref,record,fhir_model.contained)
+                end
+              end
+            else # not an Array
+              results[:validated_fields] += 1 if local_reference?(value,record,fhir_model.contained)
+            end
+          end
+        else
+          value = fhir_model.instance_variable_get("@#{field_name}")
+          if !value.nil?
+            if value.is_a?(Array)
+              value.each{|v| results.merge!(check_metadata(v,record)){|k,a,b|a+b} if v.is_a?(FHIR::Model)}
+            else # not an Array
+              results.merge!(check_metadata(value,record)){|k,a,b|a+b} if value.is_a?(FHIR::Model)
+            end
+          end            
+        end
+      end
+      results
+    end
+
+    def self.local_reference?(reference,record,contained)
+      if contained && reference.reference && reference.reference.start_with?('#')
+        contained.each do |resource|
+          return true if reference.reference[1..-1]==resource.id
+        end
+      end
+      record.entry.each do |entry|
+        return true if reference_matchs?(reference,entry)
+      end
+      false    
+    end
+
+    def self.reference_matchs?(reference,entry)
+      return false if (reference.nil? || reference.reference.nil?)
+      if reference.reference.start_with?('urn:uuid:')
+        (reference.reference == entry.fullUrl)
+      else
+        # some weaknesses here:
+        # 'Patient/20' will match both 'http://foo/Patient/20/_history/1' and 'http://foo/Patient/20303/_history/1' 
+        ((entry.fullUrl =~ /#{reference.reference}/) || (entry.resource && entry.resource.id =~ /#{reference.reference}/ ))
+      end
+    end
+
+  end
+end