Class: FHIR::Model

Inherits:

Object

Object
FHIR::Model

show all

Defined in:: lib/fhir_models/bootstrap/model.rb

Direct Known Subclasses

Instance Method Summary collapse

Constructor Details

#initialize(hash = {}) ⇒ `Model`

Returns a new instance of Model.

# File 'lib/fhir_models/bootstrap/model.rb', line 9

def initialize(hash={})
  self.from_hash(hash)
  self.class::METADATA.each do |key, value|
    if value['max'] > 1 && self.instance_variable_get("@#{key}").nil?
      self.instance_variable_set("@#{key}".to_sym, [])
    end
  end
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method, *args, &block) ⇒ `Object`

# File 'lib/fhir_models/bootstrap/model.rb', line 18

def method_missing(method, *args, &block)
  if defined?(self.class::MULTIPLE_TYPES) && self.class::MULTIPLE_TYPES[method.to_s]
    self.class::MULTIPLE_TYPES[method.to_s].each do |type|
      type[0] = type[0].upcase
      value = self.method("#{method}#{type}").call()
      return value if !value.nil?
    end
    return nil
  elsif (!@extension.nil? && !@extension.empty?)
    ext = @extension.select do |x|
      name = x.url.tr('-', '_').split('/').last
      anchor = name.split('#').last
      (method.to_s==name || method.to_s==anchor)
    end
    if !ext.first.nil?
      if !ext.first.value.nil?
        return ext.first.value
      else
        return ext.first
      end
    end
  elsif (!@modifierExtension.nil? && !@modifierExtension.empty?)
    ext = @modifierExtension.select do |x|
      name = x.url.tr('-', '_').split('/').last
      anchor = name.split('#').last
      (method.to_s==name || method.to_s==anchor)
    end
    if !ext.first.nil?
      if !ext.first.value.nil?
        return ext.first.value
      else
        return ext.first
      end
    end
  end
  super(method, *args, &block)
end

Instance Method Details

#attribute_mismatch(left, right, exclude = []) ⇒ `Object`

# File 'lib/fhir_models/bootstrap/model.rb', line 79

def attribute_mismatch(left, right, exclude=[])
  if left.respond_to?(:mismatch) && right.respond_to?(:mismatch)
    left.mismatch right, exclude
  else
    compare_attribute(left, right, exclude)
  end
end

#compare_attribute(left, right, exclude = []) ⇒ `Object`

# File 'lib/fhir_models/bootstrap/model.rb', line 87

def compare_attribute(left, right, exclude=[])
  if left.respond_to?(:equals?) && right.respond_to?(:equals?)
    left.equals? right, exclude
  elsif left.is_a?(Array) && right.is_a?(Array) && (left.length == right.length)
    result = true
    (0...(left.length)).each {|i| result &&= compare_attribute(left[i], right[i], exclude)}
    result
  else
    left == right
  end
end

#equals?(other, exclude = []) ⇒ `Boolean`

Returns:

(Boolean)

# File 'lib/fhir_models/bootstrap/model.rb', line 60

def equals?(other, exclude=[])
  (self.class::METADATA.keys - exclude).each do |attribute|
    return false unless compare_attribute(self.instance_variable_get("@#{attribute}".to_sym), other.instance_variable_get("@#{attribute}".to_sym), exclude)
  end
  true
end

#is_valid? ⇒ `Boolean`

Returns:

(Boolean)



99
100
101

# File 'lib/fhir_models/bootstrap/model.rb', line 99

def is_valid?
  validate.empty?
end

#mismatch(other, exclude = []) ⇒ `Object`

# File 'lib/fhir_models/bootstrap/model.rb', line 67

def mismatch(other, exclude=[])
  misses = []
  (self.class::METADATA.keys - exclude).each do |key|
    these = attribute_mismatch(self.instance_variable_get("@#{key}".to_sym), other.instance_variable_get("@#{key}".to_sym), exclude)
    if !these || (these.is_a?(Array) && !these.empty?)
      misses << "#{self.class}::#{key}"
      misses.concat these if these.is_a?(Array)
    end
  end
  misses
end

#to_reference ⇒ `Object`



56
57
58

# File 'lib/fhir_models/bootstrap/model.rb', line 56

def to_reference
  FHIR::Reference.new(reference: "#{self.class.name.split('::').last}/#{self.id}")
end

#validate(contained = nil) ⇒ `Object`



103
104
105

# File 'lib/fhir_models/bootstrap/model.rb', line 103

def validate(contained=nil)
  validate_profile(self.class::METADATA, contained)
end

#validate_profile(metadata, contained = nil) ⇒ `Object`

# File 'lib/fhir_models/bootstrap/model.rb', line 107

def validate_profile(metadata, contained=nil)
  contained_here = [ self.instance_variable_get('@contained'.to_sym) ].flatten
  contained_here << contained
  contained_here = contained_here.flatten.compact
  errors = {}
  metadata.each do |field, meta|
    if meta.is_a?(Array)
      # this field has been 'sliced'
      meta.each do |slice|
        local_name = slice['local_name'] || field
        value = [ self.instance_variable_get("@#{local_name}".to_sym) ].flatten.compact
        subset = [] # subset is the values associated with just this slice
        if slice['type']=='Extension'
          if slice['type_profiles']
            subset = value.select{|x|slice['type_profiles'].include?(x.url)}
          else
            subset = value
          end
        else
          FHIR.logger.warn 'Validation not supported on slices (except for Extensions)'
        end
        validate_field(field, subset, contained_here, slice, errors)
      end
    else
      local_name = meta['local_name'] || field
      value = [ self.instance_variable_get("@#{local_name}".to_sym) ].flatten.compact
      validate_field(field, value, contained_here, meta, errors)
    end
  end # metadata.each
  # check multiple types
  multiple_types = self.class::MULTIPLE_TYPES rescue {}
  multiple_types.each do |prefix, suffixes|
    count = 0
    present = []
    suffixes.each do |suffix|
      typename = "#{prefix}#{suffix[0].upcase}#{suffix[1..-1]}"
      count += 1 if errors[typename]
      # check which multiple data types are actually present, not just errors
      # actually, this might be allowed depending on cardinality
      value = self.instance_variable_get("@#{typename}")
      present << typename if !value.nil? || (value.is_a?(Array) && !value.empty?)
    end
    errors[prefix] = ["#{prefix}[x]: more than one type present."] if(count > 1)
    # remove errors for suffixes that are not present
    suffixes.each do |suffix|
      typename = "#{prefix}#{suffix[0].upcase}#{suffix[1..-1]}"
      errors.delete(typename) if !present.include?(typename)
    end
  end
  errors.keep_if{|_k, v|(v && !v.empty?)}
end

Class: FHIR::Model

Direct Known Subclasses

Instance Method Summary collapse

Constructor Details

#initialize(hash = {}) ⇒ Model

Dynamic Method Handling

#method_missing(method, *args, &block) ⇒ Object

Instance Method Details

#attribute_mismatch(left, right, exclude = []) ⇒ Object

#compare_attribute(left, right, exclude = []) ⇒ Object

#equals?(other, exclude = []) ⇒ Boolean

#is_valid? ⇒ Boolean

#mismatch(other, exclude = []) ⇒ Object

#to_reference ⇒ Object

#validate(contained = nil) ⇒ Object

#validate_profile(metadata, contained = nil) ⇒ Object

#initialize(hash = {}) ⇒ `Model`

#method_missing(method, *args, &block) ⇒ `Object`

#attribute_mismatch(left, right, exclude = []) ⇒ `Object`

#compare_attribute(left, right, exclude = []) ⇒ `Object`

#equals?(other, exclude = []) ⇒ `Boolean`

#is_valid? ⇒ `Boolean`

#mismatch(other, exclude = []) ⇒ `Object`

#to_reference ⇒ `Object`

#validate(contained = nil) ⇒ `Object`

#validate_profile(metadata, contained = nil) ⇒ `Object`