Module: Abstractor::Abstractable::ClassMethods

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

Instance Method Summary collapse

Instance Method Details

#abstractor_abstraction_schemas(options = {}) ⇒ Object

Returns the abstractor abstraction schemas associated with the abstractable entity.

By default, the method will return all abstractor abstraction schemas.

Parameters:

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

    the options to filter the abstaction schemas.

Options Hash (options):

  • :grouped (Boolean) —

    Filters the list of Abstractor::AbstractorAbstractionSchema objects to grouped and non-grouped. Defaults to nil which returns all abstraction schemas.

  • :namespace_type (String) —

    The type parameter of the namespace to filter the abstaction schemas.

  • :namespace_id (Integer) —

    The instance parameter of the namespace to filter the abstaction schemas.

Returns:

  • ActiveRecord::Relation list of Abstactor::AbstractorAbstractionSchema objects



244
245
246
247
 
# File 'lib/abstractor/abstractable.rb', line 244

def abstractor_abstraction_schemas(options = {})
  options = { grouped: nil, namespace_type: nil, namespace_id: nil }.merge(options)
  abstractor_subjects(options).map(&:abstractor_abstraction_schema)
end

#abstractor_subject_groups(options = {}) ⇒ Object 



249
250
251
252
 
# File 'lib/abstractor/abstractable.rb', line 249

def abstractor_subject_groups(options = {})
  options = { grouped: true, namespace_type: nil, namespace_id: nil }.merge(options)
  Abstractor::AbstractorSubjectGroup.find(abstractor_subjects(options).map{|s| s.abstractor_subject_group.id})
end

#abstractor_subjects(options = {}) ⇒ Object

Returns the abstractor subjects associated with the abstractable entity.

By default, the method will return all abstractor subjects.

Parameters:

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

    the options to filter the subjects returned.

Options Hash (options):

  • :grouped (Boolean) —

    Filters the list of Abstactor::AbstractorSubject objects to grouped and non-grouped. Defaults to nil which returns all objects.

  • :namespace_type (String) —

    The type parameter of the namespace to filter the subjects.

  • :namespace_id (Integer) —

    The instance parameter of the namespace to filter the subjects.

Returns:

  • ActiveRecord::Relation list of Abstactor::AbstractorSubject objects



218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/abstractor/abstractable.rb', line 218

def abstractor_subjects(options = {})
  options = { grouped: nil, namespace_type: nil, namespace_id: nil }.merge(options)
  subjects = Abstractor::AbstractorSubject.where(subject_type: self.to_s)
  if options[:namespace_type] || options[:namespace_id]
    subjects = subjects.where(namespace_type: options[:namespace_type], namespace_id: options[:namespace_id])
  end
  subjects = case options[:grouped]
  when true
    subjects.joins(:abstractor_subject_group).includes(:abstractor_subject_group)
  when false
    subjects.where("not exists (select 'a' from abstractor_subject_group_members where abstractor_subject_id = abstractor_subjects.id)")
  when nil
    subjects
  end
end

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

Returns all abstractable entities filtered by the parameter abstractor_abstraction_status:

  • ‘needs_review’: Filter abstractable entites having at least one abstraction without a determined value (value, unknown or not_applicable).

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

Parameters:

  • abstractor_abstraction_status (String) —

    Filter abstactable entities that an abstraction that ‘needs_review’ or are all abstractions are ‘reviewed’.

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

    the options to filter the entities returned.

Options Hash (options):

  • :namespace_type (String) —

    The type parameter of the namespace to filter the entities.

  • :namespace_id (Integer) —

    The instance parameter of the namespace to filter the entities.

Returns:

  • (ActiveRecord::Relation) —

    List of abstractable entities.



184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'lib/abstractor/abstractable.rb', line 184

def by_abstractor_abstraction_status(abstractor_abstraction_status, options = {})
  options = { namespace_type: nil, namespace_id: nil }.merge(options)

  if options[:namespace_type] || options[:namespace_id]
    case abstractor_abstraction_status
    when Abstractor::Enum::ABSTRACTION_STATUS_NEEDS_REVIEW
      where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND (aa.value IS NULL OR aa.value = '') AND (aa.unknown IS NULL OR aa.unknown = ?) AND (aa.not_applicable IS NULL OR aa.not_applicable = ?))", options[:namespace_type], options[:namespace_id], false, false])
    when Abstractor::Enum::ABSTRACTION_STATUS_REVIEWED
      where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id) AND NOT EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND COALESCE(aa.value, '') = '' AND COALESCE(aa.unknown, ?) != ? AND COALESCE(aa.not_applicable, ?) != ?)", options[:namespace_type], options[:namespace_id], options[:namespace_type], options[:namespace_id], false, true, false, true])
    else
      where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.namespace_type = ? AND sub.namespace_id = ? WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id)", options[:namespace_type], options[:namespace_id]])
    end
  else
    case abstractor_abstraction_status
    when Abstractor::Enum::ABSTRACTION_STATUS_NEEDS_REVIEW
      where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND (aa.value IS NULL OR aa.value = '') AND (aa.unknown IS NULL OR aa.unknown = ?) AND (aa.not_applicable IS NULL OR aa.not_applicable = ?))", false, false])
    when Abstractor::Enum::ABSTRACTION_STATUS_REVIEWED
      where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id) AND NOT EXISTS (SELECT 1 FROM abstractor_abstractions aa WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND COALESCE(aa.value, '') = '' AND COALESCE(aa.unknown, ?) != ? AND COALESCE(aa.not_applicable, ?) != ?)", false, true, false, true])
    else
      where(nil)
    end
  end
end

#pivot_abstractions(options = {}) ⇒ Object

Pivot abstractions to simulate regular columns on an abstractable entity.

Example: an ActiveRecod model PathologyCaseReport with the columns

  • ‘collection_date’

  • ‘report_text’

And the abstraction ‘has_cancer_diagnosis’.

This method allows for the querying of the pathology_cases table as if it was strucutred like so: ‘select id, collection_date, report_text, has_cancer_diagnosis from pathology_cases’

Parameters:

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

    the options to pivot the abstractions.

Options Hash (options):

  • :namespace_type (String) —

    The type parameter of the namespace to pivot abstractions.

  • :namespace_id (Integer) —

    The instance parameter of the namespace to pivot abstractions.

Returns:

  • ActiveRecord::Relation



270
271
272
273
274
275
276
277
278
279
280
281
282
283
 
# File 'lib/abstractor/abstractable.rb', line 270

def pivot_abstractions(options = {})
  options = { grouped: false, namespace_type: nil, namespace_id: nil }.merge(options)
  select = prepare_pivot_select(options)
  adapter = ActiveRecord::Base.connection.instance_values["config"][:adapter]
  j = case adapter
  when 'sqlite3'
    prepare_pivot_joins(select, "'t'", options)
  when 'sqlserver'
    prepare_pivot_joins(select, '1', options)
  when 'postgresql'
    prepare_pivot_joins(select, 'true', options)
  end
  joins(j).select("#{self.table_name}.*, pivoted_abstractions.*")
end

#pivot_grouped_abstractions(abstractor_subject_groups_name, options = {}) ⇒ Object

Pivot grouped abstractions to simulate regular columns on an abstractable entity.

Example: an ActiveRecod model RadationTreatment with the columns

  • ‘treatment_date’

  • ‘total_dose’

And the abstractions grouped together with the name ‘has_treatment_target’:

  • ‘has_anatomical_location’.

  • ‘has_laterality’

This method allows for the querying of the radiation_treatments table as if it was strucutred like so: ‘select id, treatment_date, toatl_dose, has_anatomical_location, has_laterality from radiation_treatments’

If an abstractable entity has multiple instances of grouped abstractions the entity will be returned mutlple times.

Parameters:

  • abstractor_subject_groups_name (String) —

    name of Methods::Models:AbtractorSubjectGroup

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

    the options to pivot the grouped abstractions.

Options Hash (options):

  • :namespace_type (String) —

    The type parameter of the namespace to pivot grouped abstractions.

  • :namespace_id (Integer) —

    The instance parameter of the namespace to pivot grouped abstractions.

Returns:

  • ActiveRecord::Relation

See Also:

  • Methods::Models:AbstractorSubjectGroup


307
308
309
310
311
312
313
314
315
316
317
318
319
320
 
# File 'lib/abstractor/abstractable.rb', line 307

def pivot_grouped_abstractions(abstractor_subject_groups_name, options = {})
  options = { grouped: true, namespace_type: nil, namespace_id: nil }.merge(options)
  select = prepare_pivot_select(options)
  adapter = ActiveRecord::Base.connection.instance_values["config"][:adapter]
  j = case adapter
  when 'sqlite3'
    prepare_grouped_pivot_joins(select, "'t'", abstractor_subject_groups_name, options)
  when 'sqlserver'
    prepare_grouped_pivot_joins(select, '1', abstractor_subject_groups_name, options)
  when 'postgresql'
    prepare_grouped_pivot_joins(select, 'true', abstractor_subject_groups_name, options)
  end
  joins(j).select("#{self.table_name}.*, pivoted_abstractions.*")
end