Module: Abstractor::Abstractable::InstanceMethods

Included in:
Abstractor::Abstractable
Defined in:
lib/abstractor/abstractable.rb

Instance Method Summary collapse

Instance Method Details

#abstract(options = {}) ⇒ void

This method returns an undefined value.

The method for generating abstractions from the abstractable entity.

The generation of abstactions is based on the setup of Abstactor::AbstractorAbstactionSchema, Abstractor::AbstractorSubject, Abstractor::AbstractorSubjectGroup and Abstractor::AbstractorAbstractionSource associated to the abstractable entity.

Namespacing allows for different sets data points to be associated to the same abstractable entity.

Namespacing is achieved by setting the Abstractor::AbstractorSubject#namespace_type and Abstractor::AbstractorSubject#namespace_id attributes.

Passing a namespace to this method will restrict the generation of abstractions to the given namespace. Otherwise, all configured abstractions associated to the abstractable entity will be generated.

A practical example of the use of a namespace would be two different clincal departments wanting to chart abstract two distinct sets of datapoints for progress notes extracted from an electronic medical record system.

Parameters:

  • options (Hash) (defaults to: {}) —

    the options to filter the generation of abstractions to a namespace.

Options Hash (options):

  • :namespace_type (String) —

    The type parameter of the namespace.

  • :namespace_id (Integer) —

    The instance parameter of the namespace.



71
72
73
74
75
76
 
# File 'lib/abstractor/abstractable.rb', line 71

def abstract(options = {})
  options = { namespace_type: nil, namespace_id: nil }.merge(options)
  self.class.abstractor_subjects(options).each do |abstractor_subject|
    abstractor_subject.abstract(self)
  end
end

#abstractor_abstraction_groups_by_namespace(options = {}) ⇒ ActiveRecord::Relation

Returns all abstraction groups for the abstractable entity by a namespace.

Parameters:

  • options (Hash) (defaults to: {}) —

    the options to filter the list of abstraction groups to a namespace.

Options Hash (options):

  • :namespace_type (String) —

    The type parameter of the namespace.

  • :namespace_id (Integer) —

    The instance parameter of the namespace.

Returns:

  • (ActiveRecord::Relation) —

    List of [Abstractor::AbstractorAbstractionGroup].



40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/abstractor/abstractable.rb', line 40

def abstractor_abstraction_groups_by_namespace(options = {})
  options = { namespace_type: nil, namespace_id: nil }.merge(options)
  if options[:namespace_type] || options[:namespace_id]
    groups = abstractor_abstraction_groups.find(abstractor_abstractions_by_namespace(options).joins(:abstractor_abstraction_group).includes(:abstractor_abstraction_group).map{|s| s.abstractor_abstraction_group.id})
  else
    groups = abstractor_abstraction_groups.not_deleted
  end
  if options[:abstractor_subject_group_id]
    groups.select{|g| g.abstractor_subject_group_id == options[:abstractor_subject_group_id]}
  else
    groups
  end
end

#abstractor_abstractions_by_abstractor_abstraction_status(abstractor_abstraction_status, options = {}) ⇒ ActiveRecord::Relation

Returns all abstraction for the abstractable entity by abstractor_abstraction_status:

  • ‘needs_review’: Filter abstractions without a determined value (value, unknown or not_applicable).

  • ‘reviewed’: Filter abstractions having a determined value (value, unknown or not_applicable).

Parameters:

  • abstractor_abstraction_status (String) —

    Filter abstractions that need review or are reviews.

  • options (Hash) (defaults to: {}) —

    the options to filter abstractions to a namespace.

Options Hash (options):

  • :namespace_type (String) —

    the type parameter of the namespace.

  • :namespace_id (Integer) —

    the instance parameter of the namespace.

Returns:

  • (ActiveRecord::Relation) —

    list of [Abstractor::AbstractorAbstraction].



136
137
138
139
140
141
142
143
144
 
# File 'lib/abstractor/abstractable.rb', line 136

def abstractor_abstractions_by_abstractor_abstraction_status(abstractor_abstraction_status, options = {})
  options = { namespace_type: nil, namespace_id: nil }.merge(options)
  case abstractor_abstraction_status
  when Abstractor::Enum::ABSTRACTION_STATUS_NEEDS_REVIEW
    abstractor_abstractions_by_namespace(options).select { |abstractor_abstraction| abstractor_abstraction.value.blank? && abstractor_abstraction.unknown.blank? && abstractor_abstraction.not_applicable.blank? }
  when Abstractor::Enum::ABSTRACTION_STATUS_REVIEWED
    abstractor_abstractions_by_namespace(options).select { |abstractor_abstraction| !abstractor_abstraction.value.blank? || !abstractor_abstraction.unknown.blank? || !abstractor_abstraction.not_applicable.blank? }
  end
end

#abstractor_abstractions_by_namespace(options = {}) ⇒ ActiveRecord::Relation

Returns all abstractions for the abstractable entity by a namespace.

Parameters:

  • options (Hash) (defaults to: {}) —

    the options to filter the list of abstractions to a namespace.

Options Hash (options):

  • :namespace_type (String) —

    The type parameter of the namespace.

  • :namespace_id (Integer) —

    The instance parameter of the namespace.

Returns:

  • (ActiveRecord::Relation) —

    List of [Abstractor::AbstractorAbstraction].



25
26
27
28
29
30
31
32
 
# File 'lib/abstractor/abstractable.rb', line 25

def abstractor_abstractions_by_namespace(options = {})
  options = { namespace_type: nil, namespace_id: nil }.merge(options)
  abstractions = abstractor_abstractions.not_deleted
  if options[:namespace_type] || options[:namespace_id]
    abstractions = abstractions.where(abstractor_subject_id: self.class.abstractor_subjects(options).map(&:id))
  end
  abstractions
end

#abstractor_subject_group_complete?(abstractor_subject_group_id, options = {}) ⇒ boolean

Determines if provided abstractor_subject_group reached number of abstractor_abstraction_groups defined by abstractor_subject_group cardinality

Parameters:

  • abstractor_subject_group_id (Integer) —

    the id of abstractor_subject_group of interest.

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :namespace_type (String) —

    the type parameter of the namespace.

  • :namespace_id (Integer) —

    the instance parameter of the namespace.

Returns:

  • (boolean) 


114
115
116
117
118
119
120
121
122
123
 
# File 'lib/abstractor/abstractable.rb', line 114

def abstractor_subject_group_complete?(abstractor_subject_group_id, options = {})
  abstractor_subject_group = Abstractor::AbstractorSubjectGroup.find(abstractor_subject_group_id)
  if abstractor_subject_group.cardinality.blank?
    false
  else
    options = { namespace_type: nil, namespace_id: nil, abstractor_subject_group_id: abstractor_subject_group_id }.merge(options)
    abstractor_abstraction_groups = abstractor_abstraction_groups_by_namespace(options)
    abstractor_abstraction_groups.length == abstractor_subject_group.cardinality
  end
end

#detect_abstractor_abstraction(abstractor_subject) ⇒ Object 



78
79
80
 
# File 'lib/abstractor/abstractable.rb', line 78

def detect_abstractor_abstraction(abstractor_subject)
  abstractor_abstractions(true).not_deleted.detect { |abstractor_abstraction| abstractor_abstraction.abstractor_subject_id == abstractor_subject.id }
end

#detect_abstractor_abstraction_group(abstractor_subject_group) ⇒ Object 



95
96
97
 
# File 'lib/abstractor/abstractable.rb', line 95

def detect_abstractor_abstraction_group(abstractor_subject_group)
  abstractor_abstraction_groups(true).detect { |abstractor_abstraction_group| abstractor_abstraction_group.abstractor_subject_group_id ==  abstractor_subject_group.id }
end

#find_or_create_abstractor_abstraction(abstractor_abstraction_schema, abstractor_subject) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/abstractor/abstractable.rb', line 82

def find_or_create_abstractor_abstraction(abstractor_abstraction_schema, abstractor_subject)
  if abstractor_abstraction = detect_abstractor_abstraction(abstractor_subject)
  else
    abstractor_abstraction = Abstractor::AbstractorAbstraction.create!(abstractor_subject: abstractor_subject, about: self)
    if abstractor_subject.groupable?
      abstractor_abstraction_group = find_or_initialize_abstractor_abstraction_group(abstractor_subject.abstractor_subject_group)
      abstractor_abstraction_group.abstractor_abstractions << abstractor_abstraction
      abstractor_abstraction_group.save!
    end
  end
  abstractor_abstraction
end

#find_or_initialize_abstractor_abstraction_group(abstractor_subject_group) ⇒ Object 



99
100
101
102
103
104
105
 
# File 'lib/abstractor/abstractable.rb', line 99

def find_or_initialize_abstractor_abstraction_group(abstractor_subject_group)
  if abstractor_abstraction_group = detect_abstractor_abstraction_group(abstractor_subject_group)
  else
    abstractor_abstraction_group = Abstractor::AbstractorAbstractionGroup.new(abstractor_subject_group: abstractor_subject_group, about: self, system_generated: true)
  end
  abstractor_abstraction_group
end

#remove_abstractions(options = {}) ⇒ void

This method returns an undefined value.

Removes all abstractions, suggestions and indirect sources for the abstractable entity. Optionally filtred to only ‘unreviewed’ abstractions and to a given namespace.

Parameters:

  • options (Hash) (defaults to: {}) —

    the options to filter the removal of abstractions.

Options Hash (options):

  • :only_unreviewed (Booelan) —

    Instructs whether to confine removal to only ‘unreviewed’ abstractions.

  • :namespace_type (String) —

    The type parameter of the namespace to remove.

  • :namespace_id (Integer) —

    The instance parameter of the namespace to remove.



154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 
# File 'lib/abstractor/abstractable.rb', line 154

def remove_abstractions(options = {})
  options = { only_unreviewed: true, namespace_type: nil, namespace_id: nil }.merge(options)
  abstractor_abstractions_by_namespace(options).each do |abstractor_abstraction|
    if !options[:only_unreviewed] || (options[:only_unreviewed] && abstractor_abstraction.unreviewed?)
      abstractor_abstraction.abstractor_suggestions.each do |abstractor_suggestion|
        abstractor_suggestion.abstractor_suggestion_sources.destroy_all
        abstractor_suggestion.abstractor_suggestion_object_value.destroy if abstractor_suggestion.abstractor_suggestion_object_value
        abstractor_suggestion.destroy
      end
      abstractor_abstraction.abstractor_indirect_sources.each do |abstractor_indirect_source|
        abstractor_indirect_source.destroy
      end
      abstractor_abstraction.destroy
    end
  end
end