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



458
459
460
461
 
# File 'lib/abstractor/abstractable.rb', line 458

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 



463
464
465
466
 
# File 'lib/abstractor/abstractable.rb', line 463

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



427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
 
# File 'lib/abstractor/abstractable.rb', line 427

def abstractor_subjects(options = {})
  options = { grouped: nil, namespace_type: nil, namespace_id: nil, abstractor_abstraction_schema_ids: [] }.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

  if options[:abstractor_abstraction_schema_ids].any?
    subjects = subjects.where(abstractor_abstraction_schema_id: options[:abstractor_abstraction_schema_ids])
  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).

  • ‘actually answered’: Filter abstractable entites having no abstractions without an actual value (exluding blank, 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.



389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
 
# File 'lib/abstractor/abstractable.rb', line 389

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])
    when Abstractor::Enum::ABSTRACTION_STATUS_ACTUALLY_ANSWERED
      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, '') = '')", options[:namespace_type], options[:namespace_id], options[:namespace_type], options[:namespace_id]])
    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])
    when Abstractor::Enum::ABSTRACTION_STATUS_ACTUALLY_ANSWERED
      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, '') = '')"])
    else
      where(nil)
    end
  end
end

#by_abstractor_suggestion_type(abstractor_suggestion_type, options = {}) ⇒ ActiveRecord::Relation

Returns all abstractable entities filtered by the parameter abstractor_suggestion_type:

  • ‘unknown’: Filter abstractable entites having at least one suggestion withat a suggested value of ‘unknown’

  • ‘suggested’: Filter abstractable entites having at least one suggestion with an acutal value

Parameters:

  • abstractor_suggestion_type (String) —

    Filter abstactable entities that have a least one ‘unknwon’ or at least one ‘not unknown’ suggestion

  • 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.

  • :abstractor_abstraction_schemas (List of Integer, List of ActiveRecord::Relation) —

    The list of abstractor abstraction schemas to filter upon. Defaults to all abstractor abstraction schemas if not specified.

Returns:

  • (ActiveRecord::Relation) —

    List of abstractable entities.



354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
 
# File 'lib/abstractor/abstractable.rb', line 354

def by_abstractor_suggestion_type(abstractor_suggestion_type, options = {})
  options = { namespace_type: nil, namespace_id: nil }.merge(options)
  options = { abstractor_abstraction_schemas: abstractor_abstraction_schemas }.merge(options)
  if options[:namespace_type] || options[:namespace_id]
    case abstractor_suggestion_type
    when Abstractor::Enum::ABSTRACTION_SUGGESTION_TYPE_UNKNOWN
      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 = ? AND sub.abstractor_abstraction_schema_id IN (?) JOIN abstractor_suggestions sug ON aa.id = sug.abstractor_abstraction_id WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND sug.unknown = ?)", options[:namespace_type], options[:namespace_id], options[:abstractor_abstraction_schemas], true])
    when Abstractor::Enum::ABSTRACTION_SUGGESTION_TYPE_SUGGESTED
      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 = ? AND sub.abstractor_abstraction_schema_id IN (?) JOIN abstractor_suggestions sug ON aa.id = sug.abstractor_abstraction_id WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND COALESCE(sug.unknown, ?) = ? AND sug.suggested_value IS NOT NULL AND COALESCE(sug.suggested_value, '') != '' )", options[:namespace_type], options[:namespace_id], options[:abstractor_abstraction_schemas], false, false])
    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 = ? AND sub.abstractor_abstraction_schema_id IN (?) 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], options[:abstractor_abstraction_schemas]])
    end
  else
    case abstractor_suggestion_type
    when Abstractor::Enum::ABSTRACTION_SUGGESTION_TYPE_UNKNOWN
      where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.abstractor_abstraction_schema_id IN (?) JOIN abstractor_suggestions sug ON aa.id = sug.abstractor_abstraction_id WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND sug.unknown = ?)", options[:abstractor_abstraction_schemas], true])
    when Abstractor::Enum::ABSTRACTION_SUGGESTION_TYPE_SUGGESTED
      where(["EXISTS (SELECT 1 FROM abstractor_abstractions aa JOIN abstractor_subjects sub ON aa.abstractor_subject_id = sub.id AND sub.abstractor_abstraction_schema_id IN (?) JOIN abstractor_suggestions sug ON aa.id = sug.abstractor_abstraction_id WHERE aa.deleted_at IS NULL AND aa.about_type = '#{self.to_s}' AND #{self.table_name}.id = aa.about_id AND COALESCE(sug.unknown, ?) = ? AND sug.suggested_value IS NOT NULL AND COALESCE(sug.suggested_value, '') != '' )", options[:abstractor_abstraction_schemas], false, false])
    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



484
485
486
487
488
489
490
491
492
493
494
495
496
497
 
# File 'lib/abstractor/abstractable.rb', line 484

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


521
522
523
524
525
526
527
528
529
530
531
532
533
534
 
# File 'lib/abstractor/abstractable.rb', line 521

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