Class: ObservationMatrixColumnItem

Inherits:

ApplicationRecord

• Object
• ActiveRecord::Base
• ApplicationRecord
• ObservationMatrixColumnItem

Includes:

Housekeeping, Shared::Identifiers, Shared::IsData, Shared::Notes, Shared::Tags

Defined in:

app/models/observation_matrix_column_item.rb

Overview

Each ObservationMatrixColumnItem is set containing 1 or more descriptors.

Direct Known Subclasses

Dynamic, Single

Defined Under Namespace

Classes: Dynamic, Single

Constant Summary

ALL_STI_ATTRIBUTES =

[:descriptor_id, :controlled_vocabulary_term_id].freeze

Instance Attribute Summary

• #controlled_vocabulary_term_id ⇒ Integer

  Id of the Keyword (a dynamic subclass).

• #descriptor_id ⇒ Integer

  Id of the descriptor (a single/static subclass).

• #observation_matrix_id ⇒ Integer

  Id of the matrix.

• #position ⇒ Integer

  A sort order.

• #type ⇒ String

  The column type.

Class Method Summary

• .batch_create(params) ⇒ Array

  Of ObservationMatrixColumnItems.

• .batch_create_by_descriptor_id(observation_matrix_id, descriptor_id, project_id, user_id) ⇒ Array, false
• .batch_create_by_observation_matrix_column_item_id(observation_matrix_id, observation_matrix_column_item_id, project_id, user_id) ⇒ Array, false
• .batch_create_from_observation_matrix(from_observation_matrix_id, to_observation_matrix_id, project_id, user_id) ⇒ Array, false
• .batch_create_from_pinboard(observation_matrix_id, project_id, user_id, klass) ⇒ Array, false
• .batch_create_from_tags(keyword_id, klass, observation_matrix_id) ⇒ Array, false
• .create_for(object, observation_matrix_id) ⇒ Object private
• .create_for_pinboard_items(pinboard_item_scope, observation_matrix_id) ⇒ Array private

  Create observation matrix column items for all scope items.

• .create_for_tags(tag_scope, observation_matrix_id) ⇒ Array private
• .human_name ⇒ Object
• .subclass_attributes ⇒ Array

  override.

Instance Method Summary

• #cleanup_matrix_columns ⇒ Object
• #cleanup_single_matrix_column(descriptor_id, mc = nil) ⇒ Object
• #column_objects ⇒ Array

  Of all objects this row references.

• #decrement_matrix_column_reference_count(mc) ⇒ Object
• #descriptors ⇒ Array

  override.

• #find_or_build_column(descriptor) ⇒ Object
• #increment_matrix_column_reference_count(mc) ⇒ Object
• #is_dynamic? ⇒ Boolean

  Whether this is a dynamic or fixed class override in subclasses.

• #other_subclass_attributes_not_set ⇒ Object private
• #update_matrix_columns ⇒ Object
• #update_single_matrix_column(descriptor) ⇒ Object

  creates or finds and updates count, always.

Methods included from Shared::IsData

#errors_excepting, #full_error_messages_excepting, #identical, #is_community?, #is_destroyable?, #is_editable?, #is_in_use?, #is_in_users_projects?, #metamorphosize, #similar

Methods included from Shared::Tags

#reject_tags, #tag_with, #tagged?, #tagged_with?

Methods included from Shared::Notes

#concatenated_notes_string, #reject_notes

Methods included from Shared::Identifiers

#dwc_occurrence_id, #identified?, #next_by_identifier, #previous_by_identifier, #reject_identifiers, #uri, #uuid

Methods included from Housekeeping

#has_polymorphic_relationship?

Methods inherited from ApplicationRecord

transaction_with_retry

Instance Attribute Details

#controlled_vocabulary_term_id ⇒ Integer

Returns id of the Keyword (a dynamic subclass).

Returns:

• (Integer) —

  id of the Keyword (a dynamic subclass)

# File 'app/models/observation_matrix_column_item.rb', line 18

class ObservationMatrixColumnItem < ApplicationRecord
  include Housekeeping
  include Shared::Identifiers
  include Shared::Notes
  include Shared::Tags
  include Shared::IsData

  acts_as_list scope: [:observation_matrix_id, :project_id]

  ALL_STI_ATTRIBUTES = [:descriptor_id, :controlled_vocabulary_term_id].freeze

  belongs_to :observation_matrix, inverse_of: :observation_matrix_column_items

  # TODO: remove from subclasses WHY does this need to be here
  # belongs_to :descriptor, inverse_of: :observation_matrix_column_items

  # See above and corresponding questions
  # belongs_to :controlled_vocabulary_term, inverse_of: :observation_matrix_column_items

  validates_presence_of :observation_matrix
  validate :other_subclass_attributes_not_set, if: -> { !type.blank? }

  after_save :update_matrix_columns
  after_destroy :cleanup_matrix_columns

  # @return [Array]
  #   of all objects this row references
  def column_objects
    objects = []

    objects.push *descriptors if descriptors
    objects
  end

  def cleanup_matrix_columns
    return true unless descriptors.size > 0
    ObservationMatrixColumn.where(descriptor_id: descriptors.map(&:id), observation_matrix: observation_matrix).each do |mc|
      cleanup_single_matrix_column(mc.descriptor_id, mc)
    end
    true
  end

  def update_matrix_columns
    descriptors.each do |d|
      update_single_matrix_column(d)
    end
  end

  def cleanup_single_matrix_column(descriptor_id, mc = nil)
    mc ||= ObservationMatrixColumn.where(
      descriptor_id: descriptor_id,
      observation_matrix: observation_matrix
    ).first
    decrement_matrix_column_reference_count(mc) if !mc.nil?
  end

  def decrement_matrix_column_reference_count(mc)
    current = mc.reference_count - 1
    if current == 0
      mc.delete
    else
      mc.update_columns(reference_count: current)
      mc.update_columns(cached_observation_matrix_column_item_id: nil) if current == 1 && type =~ /Single/ # we've deleted the only single, so the last must be a Dynamic/Tagged
    end
  end

  def find_or_build_column(descriptor)
    ObservationMatrixColumn.find_or_initialize_by(
      observation_matrix: observation_matrix,
      descriptor: descriptor)
  end

  # creates or finds and updates count, always
  def update_single_matrix_column(descriptor)
    mc = find_or_build_column(descriptor)
    mc.save! if !mc.persisted?

    increment_matrix_column_reference_count(mc)
  end

  def increment_matrix_column_reference_count(mc)
    mc.update_columns(reference_count: (mc.reference_count || 0) + 1)
    mc.update_columns(cached_observation_matrix_column_item_id: id) if type =~ /Single/
  end

  def self.human_name
    self.name.demodulize.humanize
  end

  # @return [Array]
  #    the required attributes for this subclass
  # override
  def self.subclass_attributes
    []
  end

  # @return [Array]
  #    the descriptors "defined" by this matrix column item
  # override
  def descriptors
    false
  end

  # @return [Array] of ObservationMatrixColumnItems
  def self.batch_create(params)
    case params[:batch_type]
    when 'tags'
      batch_create_from_tags(params[:keyword_id], params[:klass], params[:observation_matrix_id])
    when 'pinboard'
      batch_create_from_pinboard(params[:observation_matrix_id], params[:project_id], params[:user_id], params[:klass])
    when 'matrix_clone'
      batch_create_from_observation_matrix(params[:observation_matrix_id], params[:target_observation_matrix_id], params[:project_id], params[:user_id])
    when 'descriptor_id'
      batch_create_by_descriptor_id(params[:observation_matrix_id], params[:descriptor_id], params[:project_id], params[:user_id])

    when 'observation_matrix_column_item_id'
      batch_create_by_observation_matrix_column_item_id(params[:observation_matrix_id], params[:observation_matrix_column_item_id], params[:project_id], params[:user_id])
    end
  end

  # @return [Array, false]
  def self.batch_create_by_observation_matrix_column_item_id(observation_matrix_id, observation_matrix_column_item_id, project_id, user_id )
    created = []
    matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
    ids = [observation_matrix_column_item_id].flatten.compact
    return false if matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin
        ids.each do |i|
          o = ObservationMatrixColumnItem.where(project_id: project_id).find(i)
          c = o.dup
          c.observation_matrix = matrix
          c.created_by_id = user_id
          c.save!
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @return [Array, false]
  def self.batch_create_by_descriptor_id(observation_matrix_id, descriptor_id, project_id, user_id )
    created = []
    matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
    ids = [descriptor_id].flatten.compact
    return false if matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin
        ids.each do |i|
          c = ObservationMatrixColumnItem::Single::Descriptor.create!(
            descriptor: Descriptor.where(project_id: project_id).find(i),
            observation_matrix_id: matrix.id,
            project_id: project_id,
            created_by_id: user_id)
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @return [Array, false]
  def self.batch_create_from_observation_matrix(from_observation_matrix_id, to_observation_matrix_id, project_id, user_id )
    created = []

    from_matrix = ObservationMatrix.where(project_id: project_id).find(from_observation_matrix_id)
    to_matrix = ObservationMatrix.where(project_id: project_id).find(to_observation_matrix_id)

    return false if from_matrix.nil? || to_matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin

        from_matrix.observation_matrix_column_items.each do |oci|
          c = oci.dup
          c.observation_matrix = to_matrix
          c.created_by_id = user_id
          c.save!
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @params klass [String] the subclass of the Descriptor ike `Descriptor::Working` or `Descriptor::Continuous`
  # @return [Array, false]
  def self.batch_create_from_tags(keyword_id, klass, observation_matrix_id)
    created = []
    ObservationMatrixColumnItem.transaction do
      begin
        if klass
          klass.constantize.joins(:tags).where(tags: {keyword_id: keyword_id } ).each do |o|
            created.push create_for(o, observation_matrix_id)
          end
        else
          created += create_for_tags(
            Tag.where(
              keyword_id: keyword_id,
              tag_object_type: 'Descriptor').all,
             observation_matrix_id
          )
        end
      rescue ActiveRecord::RecordInvalid => e
        raise # return false
      end
    end
    return created
  end

  # @params klass [String] the class name like `Otu` or `CollectionObject`
  # @return [Array, false]
  def self.batch_create_from_pinboard(observation_matrix_id, project_id, user_id, klass)
    return false if observation_matrix_id.blank? || project_id.blank? || user_id.blank?
    created = []
    ObservationMatrixColumn.transaction do
      begin
        if klass
          klass.constantize.joins(:pinboard_items).where(pinboard_items: {user_id: user_id, project_id: project_id}).each do |o|
            created.push create_for(o, observation_matrix_id)
          end
        else
          created += create_for_pinboard_items(
            PinboardItem.where(project_id: project_id, user_id: user_id, pinned_object_type: 'Descriptor').all,
            observation_matrix_id
          )
        end
      rescue ActiveRecord::RecordInvalid => e
        return false
      end
    end
    return created
  end

  # @return [Boolean]
  #   whether this is a dynamic or fixed class
  #   override in subclasses
  def is_dynamic?
    false
  end

  private

  # @return [Array]
  def self.create_for_tags(tag_scope, observation_matrix_id)
    a = []
    tag_scope.each do |o|
      a.push create_for(o.tag_object, observation_matrix_id)
    end
    a
  end

  # @param pinboard_item_scope [PinboardItem Scope]
  # @return [Array]
  #   create observation matrix column items for all scope items
  def self.create_for_pinboard_items(pinboard_item_scope, observation_matrix_id)
    a = []
    pinboard_item_scope.each do |o|
      a.push create_for(o.pinned_object, observation_matrix_id)
    end
    a
  end

  def self.create_for(object, observation_matrix_id)
    ObservationMatrixColumnItem::Single::Descriptor.create!(
      observation_matrix_id: observation_matrix_id,
      descriptor: object)
  end

  def other_subclass_attributes_not_set
    (ALL_STI_ATTRIBUTES - self.class.subclass_attributes).each do |atr|
      errors.add(atr, 'is not valid for this type of observation matrix column item') if !send(atr).blank?
    end
  end

end

#descriptor_id ⇒ Integer

Returns id of the descriptor (a single/static subclass).

Returns:

• (Integer) —

  id of the descriptor (a single/static subclass)

# File 'app/models/observation_matrix_column_item.rb', line 18

class ObservationMatrixColumnItem < ApplicationRecord
  include Housekeeping
  include Shared::Identifiers
  include Shared::Notes
  include Shared::Tags
  include Shared::IsData

  acts_as_list scope: [:observation_matrix_id, :project_id]

  ALL_STI_ATTRIBUTES = [:descriptor_id, :controlled_vocabulary_term_id].freeze

  belongs_to :observation_matrix, inverse_of: :observation_matrix_column_items

  # TODO: remove from subclasses WHY does this need to be here
  # belongs_to :descriptor, inverse_of: :observation_matrix_column_items

  # See above and corresponding questions
  # belongs_to :controlled_vocabulary_term, inverse_of: :observation_matrix_column_items

  validates_presence_of :observation_matrix
  validate :other_subclass_attributes_not_set, if: -> { !type.blank? }

  after_save :update_matrix_columns
  after_destroy :cleanup_matrix_columns

  # @return [Array]
  #   of all objects this row references
  def column_objects
    objects = []

    objects.push *descriptors if descriptors
    objects
  end

  def cleanup_matrix_columns
    return true unless descriptors.size > 0
    ObservationMatrixColumn.where(descriptor_id: descriptors.map(&:id), observation_matrix: observation_matrix).each do |mc|
      cleanup_single_matrix_column(mc.descriptor_id, mc)
    end
    true
  end

  def update_matrix_columns
    descriptors.each do |d|
      update_single_matrix_column(d)
    end
  end

  def cleanup_single_matrix_column(descriptor_id, mc = nil)
    mc ||= ObservationMatrixColumn.where(
      descriptor_id: descriptor_id,
      observation_matrix: observation_matrix
    ).first
    decrement_matrix_column_reference_count(mc) if !mc.nil?
  end

  def decrement_matrix_column_reference_count(mc)
    current = mc.reference_count - 1
    if current == 0
      mc.delete
    else
      mc.update_columns(reference_count: current)
      mc.update_columns(cached_observation_matrix_column_item_id: nil) if current == 1 && type =~ /Single/ # we've deleted the only single, so the last must be a Dynamic/Tagged
    end
  end

  def find_or_build_column(descriptor)
    ObservationMatrixColumn.find_or_initialize_by(
      observation_matrix: observation_matrix,
      descriptor: descriptor)
  end

  # creates or finds and updates count, always
  def update_single_matrix_column(descriptor)
    mc = find_or_build_column(descriptor)
    mc.save! if !mc.persisted?

    increment_matrix_column_reference_count(mc)
  end

  def increment_matrix_column_reference_count(mc)
    mc.update_columns(reference_count: (mc.reference_count || 0) + 1)
    mc.update_columns(cached_observation_matrix_column_item_id: id) if type =~ /Single/
  end

  def self.human_name
    self.name.demodulize.humanize
  end

  # @return [Array]
  #    the required attributes for this subclass
  # override
  def self.subclass_attributes
    []
  end

  # @return [Array]
  #    the descriptors "defined" by this matrix column item
  # override
  def descriptors
    false
  end

  # @return [Array] of ObservationMatrixColumnItems
  def self.batch_create(params)
    case params[:batch_type]
    when 'tags'
      batch_create_from_tags(params[:keyword_id], params[:klass], params[:observation_matrix_id])
    when 'pinboard'
      batch_create_from_pinboard(params[:observation_matrix_id], params[:project_id], params[:user_id], params[:klass])
    when 'matrix_clone'
      batch_create_from_observation_matrix(params[:observation_matrix_id], params[:target_observation_matrix_id], params[:project_id], params[:user_id])
    when 'descriptor_id'
      batch_create_by_descriptor_id(params[:observation_matrix_id], params[:descriptor_id], params[:project_id], params[:user_id])

    when 'observation_matrix_column_item_id'
      batch_create_by_observation_matrix_column_item_id(params[:observation_matrix_id], params[:observation_matrix_column_item_id], params[:project_id], params[:user_id])
    end
  end

  # @return [Array, false]
  def self.batch_create_by_observation_matrix_column_item_id(observation_matrix_id, observation_matrix_column_item_id, project_id, user_id )
    created = []
    matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
    ids = [observation_matrix_column_item_id].flatten.compact
    return false if matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin
        ids.each do |i|
          o = ObservationMatrixColumnItem.where(project_id: project_id).find(i)
          c = o.dup
          c.observation_matrix = matrix
          c.created_by_id = user_id
          c.save!
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @return [Array, false]
  def self.batch_create_by_descriptor_id(observation_matrix_id, descriptor_id, project_id, user_id )
    created = []
    matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
    ids = [descriptor_id].flatten.compact
    return false if matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin
        ids.each do |i|
          c = ObservationMatrixColumnItem::Single::Descriptor.create!(
            descriptor: Descriptor.where(project_id: project_id).find(i),
            observation_matrix_id: matrix.id,
            project_id: project_id,
            created_by_id: user_id)
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @return [Array, false]
  def self.batch_create_from_observation_matrix(from_observation_matrix_id, to_observation_matrix_id, project_id, user_id )
    created = []

    from_matrix = ObservationMatrix.where(project_id: project_id).find(from_observation_matrix_id)
    to_matrix = ObservationMatrix.where(project_id: project_id).find(to_observation_matrix_id)

    return false if from_matrix.nil? || to_matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin

        from_matrix.observation_matrix_column_items.each do |oci|
          c = oci.dup
          c.observation_matrix = to_matrix
          c.created_by_id = user_id
          c.save!
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @params klass [String] the subclass of the Descriptor ike `Descriptor::Working` or `Descriptor::Continuous`
  # @return [Array, false]
  def self.batch_create_from_tags(keyword_id, klass, observation_matrix_id)
    created = []
    ObservationMatrixColumnItem.transaction do
      begin
        if klass
          klass.constantize.joins(:tags).where(tags: {keyword_id: keyword_id } ).each do |o|
            created.push create_for(o, observation_matrix_id)
          end
        else
          created += create_for_tags(
            Tag.where(
              keyword_id: keyword_id,
              tag_object_type: 'Descriptor').all,
             observation_matrix_id
          )
        end
      rescue ActiveRecord::RecordInvalid => e
        raise # return false
      end
    end
    return created
  end

  # @params klass [String] the class name like `Otu` or `CollectionObject`
  # @return [Array, false]
  def self.batch_create_from_pinboard(observation_matrix_id, project_id, user_id, klass)
    return false if observation_matrix_id.blank? || project_id.blank? || user_id.blank?
    created = []
    ObservationMatrixColumn.transaction do
      begin
        if klass
          klass.constantize.joins(:pinboard_items).where(pinboard_items: {user_id: user_id, project_id: project_id}).each do |o|
            created.push create_for(o, observation_matrix_id)
          end
        else
          created += create_for_pinboard_items(
            PinboardItem.where(project_id: project_id, user_id: user_id, pinned_object_type: 'Descriptor').all,
            observation_matrix_id
          )
        end
      rescue ActiveRecord::RecordInvalid => e
        return false
      end
    end
    return created
  end

  # @return [Boolean]
  #   whether this is a dynamic or fixed class
  #   override in subclasses
  def is_dynamic?
    false
  end

  private

  # @return [Array]
  def self.create_for_tags(tag_scope, observation_matrix_id)
    a = []
    tag_scope.each do |o|
      a.push create_for(o.tag_object, observation_matrix_id)
    end
    a
  end

  # @param pinboard_item_scope [PinboardItem Scope]
  # @return [Array]
  #   create observation matrix column items for all scope items
  def self.create_for_pinboard_items(pinboard_item_scope, observation_matrix_id)
    a = []
    pinboard_item_scope.each do |o|
      a.push create_for(o.pinned_object, observation_matrix_id)
    end
    a
  end

  def self.create_for(object, observation_matrix_id)
    ObservationMatrixColumnItem::Single::Descriptor.create!(
      observation_matrix_id: observation_matrix_id,
      descriptor: object)
  end

  def other_subclass_attributes_not_set
    (ALL_STI_ATTRIBUTES - self.class.subclass_attributes).each do |atr|
      errors.add(atr, 'is not valid for this type of observation matrix column item') if !send(atr).blank?
    end
  end

end

#observation_matrix_id ⇒ Integer

Returns id of the matrix.

Returns:

• (Integer) —

  id of the matrix

# File 'app/models/observation_matrix_column_item.rb', line 18

class ObservationMatrixColumnItem < ApplicationRecord
  include Housekeeping
  include Shared::Identifiers
  include Shared::Notes
  include Shared::Tags
  include Shared::IsData

  acts_as_list scope: [:observation_matrix_id, :project_id]

  ALL_STI_ATTRIBUTES = [:descriptor_id, :controlled_vocabulary_term_id].freeze

  belongs_to :observation_matrix, inverse_of: :observation_matrix_column_items

  # TODO: remove from subclasses WHY does this need to be here
  # belongs_to :descriptor, inverse_of: :observation_matrix_column_items

  # See above and corresponding questions
  # belongs_to :controlled_vocabulary_term, inverse_of: :observation_matrix_column_items

  validates_presence_of :observation_matrix
  validate :other_subclass_attributes_not_set, if: -> { !type.blank? }

  after_save :update_matrix_columns
  after_destroy :cleanup_matrix_columns

  # @return [Array]
  #   of all objects this row references
  def column_objects
    objects = []

    objects.push *descriptors if descriptors
    objects
  end

  def cleanup_matrix_columns
    return true unless descriptors.size > 0
    ObservationMatrixColumn.where(descriptor_id: descriptors.map(&:id), observation_matrix: observation_matrix).each do |mc|
      cleanup_single_matrix_column(mc.descriptor_id, mc)
    end
    true
  end

  def update_matrix_columns
    descriptors.each do |d|
      update_single_matrix_column(d)
    end
  end

  def cleanup_single_matrix_column(descriptor_id, mc = nil)
    mc ||= ObservationMatrixColumn.where(
      descriptor_id: descriptor_id,
      observation_matrix: observation_matrix
    ).first
    decrement_matrix_column_reference_count(mc) if !mc.nil?
  end

  def decrement_matrix_column_reference_count(mc)
    current = mc.reference_count - 1
    if current == 0
      mc.delete
    else
      mc.update_columns(reference_count: current)
      mc.update_columns(cached_observation_matrix_column_item_id: nil) if current == 1 && type =~ /Single/ # we've deleted the only single, so the last must be a Dynamic/Tagged
    end
  end

  def find_or_build_column(descriptor)
    ObservationMatrixColumn.find_or_initialize_by(
      observation_matrix: observation_matrix,
      descriptor: descriptor)
  end

  # creates or finds and updates count, always
  def update_single_matrix_column(descriptor)
    mc = find_or_build_column(descriptor)
    mc.save! if !mc.persisted?

    increment_matrix_column_reference_count(mc)
  end

  def increment_matrix_column_reference_count(mc)
    mc.update_columns(reference_count: (mc.reference_count || 0) + 1)
    mc.update_columns(cached_observation_matrix_column_item_id: id) if type =~ /Single/
  end

  def self.human_name
    self.name.demodulize.humanize
  end

  # @return [Array]
  #    the required attributes for this subclass
  # override
  def self.subclass_attributes
    []
  end

  # @return [Array]
  #    the descriptors "defined" by this matrix column item
  # override
  def descriptors
    false
  end

  # @return [Array] of ObservationMatrixColumnItems
  def self.batch_create(params)
    case params[:batch_type]
    when 'tags'
      batch_create_from_tags(params[:keyword_id], params[:klass], params[:observation_matrix_id])
    when 'pinboard'
      batch_create_from_pinboard(params[:observation_matrix_id], params[:project_id], params[:user_id], params[:klass])
    when 'matrix_clone'
      batch_create_from_observation_matrix(params[:observation_matrix_id], params[:target_observation_matrix_id], params[:project_id], params[:user_id])
    when 'descriptor_id'
      batch_create_by_descriptor_id(params[:observation_matrix_id], params[:descriptor_id], params[:project_id], params[:user_id])

    when 'observation_matrix_column_item_id'
      batch_create_by_observation_matrix_column_item_id(params[:observation_matrix_id], params[:observation_matrix_column_item_id], params[:project_id], params[:user_id])
    end
  end

  # @return [Array, false]
  def self.batch_create_by_observation_matrix_column_item_id(observation_matrix_id, observation_matrix_column_item_id, project_id, user_id )
    created = []
    matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
    ids = [observation_matrix_column_item_id].flatten.compact
    return false if matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin
        ids.each do |i|
          o = ObservationMatrixColumnItem.where(project_id: project_id).find(i)
          c = o.dup
          c.observation_matrix = matrix
          c.created_by_id = user_id
          c.save!
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @return [Array, false]
  def self.batch_create_by_descriptor_id(observation_matrix_id, descriptor_id, project_id, user_id )
    created = []
    matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
    ids = [descriptor_id].flatten.compact
    return false if matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin
        ids.each do |i|
          c = ObservationMatrixColumnItem::Single::Descriptor.create!(
            descriptor: Descriptor.where(project_id: project_id).find(i),
            observation_matrix_id: matrix.id,
            project_id: project_id,
            created_by_id: user_id)
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @return [Array, false]
  def self.batch_create_from_observation_matrix(from_observation_matrix_id, to_observation_matrix_id, project_id, user_id )
    created = []

    from_matrix = ObservationMatrix.where(project_id: project_id).find(from_observation_matrix_id)
    to_matrix = ObservationMatrix.where(project_id: project_id).find(to_observation_matrix_id)

    return false if from_matrix.nil? || to_matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin

        from_matrix.observation_matrix_column_items.each do |oci|
          c = oci.dup
          c.observation_matrix = to_matrix
          c.created_by_id = user_id
          c.save!
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @params klass [String] the subclass of the Descriptor ike `Descriptor::Working` or `Descriptor::Continuous`
  # @return [Array, false]
  def self.batch_create_from_tags(keyword_id, klass, observation_matrix_id)
    created = []
    ObservationMatrixColumnItem.transaction do
      begin
        if klass
          klass.constantize.joins(:tags).where(tags: {keyword_id: keyword_id } ).each do |o|
            created.push create_for(o, observation_matrix_id)
          end
        else
          created += create_for_tags(
            Tag.where(
              keyword_id: keyword_id,
              tag_object_type: 'Descriptor').all,
             observation_matrix_id
          )
        end
      rescue ActiveRecord::RecordInvalid => e
        raise # return false
      end
    end
    return created
  end

  # @params klass [String] the class name like `Otu` or `CollectionObject`
  # @return [Array, false]
  def self.batch_create_from_pinboard(observation_matrix_id, project_id, user_id, klass)
    return false if observation_matrix_id.blank? || project_id.blank? || user_id.blank?
    created = []
    ObservationMatrixColumn.transaction do
      begin
        if klass
          klass.constantize.joins(:pinboard_items).where(pinboard_items: {user_id: user_id, project_id: project_id}).each do |o|
            created.push create_for(o, observation_matrix_id)
          end
        else
          created += create_for_pinboard_items(
            PinboardItem.where(project_id: project_id, user_id: user_id, pinned_object_type: 'Descriptor').all,
            observation_matrix_id
          )
        end
      rescue ActiveRecord::RecordInvalid => e
        return false
      end
    end
    return created
  end

  # @return [Boolean]
  #   whether this is a dynamic or fixed class
  #   override in subclasses
  def is_dynamic?
    false
  end

  private

  # @return [Array]
  def self.create_for_tags(tag_scope, observation_matrix_id)
    a = []
    tag_scope.each do |o|
      a.push create_for(o.tag_object, observation_matrix_id)
    end
    a
  end

  # @param pinboard_item_scope [PinboardItem Scope]
  # @return [Array]
  #   create observation matrix column items for all scope items
  def self.create_for_pinboard_items(pinboard_item_scope, observation_matrix_id)
    a = []
    pinboard_item_scope.each do |o|
      a.push create_for(o.pinned_object, observation_matrix_id)
    end
    a
  end

  def self.create_for(object, observation_matrix_id)
    ObservationMatrixColumnItem::Single::Descriptor.create!(
      observation_matrix_id: observation_matrix_id,
      descriptor: object)
  end

  def other_subclass_attributes_not_set
    (ALL_STI_ATTRIBUTES - self.class.subclass_attributes).each do |atr|
      errors.add(atr, 'is not valid for this type of observation matrix column item') if !send(atr).blank?
    end
  end

end

#position ⇒ Integer

Returns a sort order.

Returns:

• (Integer) —

  a sort order

# File 'app/models/observation_matrix_column_item.rb', line 18

class ObservationMatrixColumnItem < ApplicationRecord
  include Housekeeping
  include Shared::Identifiers
  include Shared::Notes
  include Shared::Tags
  include Shared::IsData

  acts_as_list scope: [:observation_matrix_id, :project_id]

  ALL_STI_ATTRIBUTES = [:descriptor_id, :controlled_vocabulary_term_id].freeze

  belongs_to :observation_matrix, inverse_of: :observation_matrix_column_items

  # TODO: remove from subclasses WHY does this need to be here
  # belongs_to :descriptor, inverse_of: :observation_matrix_column_items

  # See above and corresponding questions
  # belongs_to :controlled_vocabulary_term, inverse_of: :observation_matrix_column_items

  validates_presence_of :observation_matrix
  validate :other_subclass_attributes_not_set, if: -> { !type.blank? }

  after_save :update_matrix_columns
  after_destroy :cleanup_matrix_columns

  # @return [Array]
  #   of all objects this row references
  def column_objects
    objects = []

    objects.push *descriptors if descriptors
    objects
  end

  def cleanup_matrix_columns
    return true unless descriptors.size > 0
    ObservationMatrixColumn.where(descriptor_id: descriptors.map(&:id), observation_matrix: observation_matrix).each do |mc|
      cleanup_single_matrix_column(mc.descriptor_id, mc)
    end
    true
  end

  def update_matrix_columns
    descriptors.each do |d|
      update_single_matrix_column(d)
    end
  end

  def cleanup_single_matrix_column(descriptor_id, mc = nil)
    mc ||= ObservationMatrixColumn.where(
      descriptor_id: descriptor_id,
      observation_matrix: observation_matrix
    ).first
    decrement_matrix_column_reference_count(mc) if !mc.nil?
  end

  def decrement_matrix_column_reference_count(mc)
    current = mc.reference_count - 1
    if current == 0
      mc.delete
    else
      mc.update_columns(reference_count: current)
      mc.update_columns(cached_observation_matrix_column_item_id: nil) if current == 1 && type =~ /Single/ # we've deleted the only single, so the last must be a Dynamic/Tagged
    end
  end

  def find_or_build_column(descriptor)
    ObservationMatrixColumn.find_or_initialize_by(
      observation_matrix: observation_matrix,
      descriptor: descriptor)
  end

  # creates or finds and updates count, always
  def update_single_matrix_column(descriptor)
    mc = find_or_build_column(descriptor)
    mc.save! if !mc.persisted?

    increment_matrix_column_reference_count(mc)
  end

  def increment_matrix_column_reference_count(mc)
    mc.update_columns(reference_count: (mc.reference_count || 0) + 1)
    mc.update_columns(cached_observation_matrix_column_item_id: id) if type =~ /Single/
  end

  def self.human_name
    self.name.demodulize.humanize
  end

  # @return [Array]
  #    the required attributes for this subclass
  # override
  def self.subclass_attributes
    []
  end

  # @return [Array]
  #    the descriptors "defined" by this matrix column item
  # override
  def descriptors
    false
  end

  # @return [Array] of ObservationMatrixColumnItems
  def self.batch_create(params)
    case params[:batch_type]
    when 'tags'
      batch_create_from_tags(params[:keyword_id], params[:klass], params[:observation_matrix_id])
    when 'pinboard'
      batch_create_from_pinboard(params[:observation_matrix_id], params[:project_id], params[:user_id], params[:klass])
    when 'matrix_clone'
      batch_create_from_observation_matrix(params[:observation_matrix_id], params[:target_observation_matrix_id], params[:project_id], params[:user_id])
    when 'descriptor_id'
      batch_create_by_descriptor_id(params[:observation_matrix_id], params[:descriptor_id], params[:project_id], params[:user_id])

    when 'observation_matrix_column_item_id'
      batch_create_by_observation_matrix_column_item_id(params[:observation_matrix_id], params[:observation_matrix_column_item_id], params[:project_id], params[:user_id])
    end
  end

  # @return [Array, false]
  def self.batch_create_by_observation_matrix_column_item_id(observation_matrix_id, observation_matrix_column_item_id, project_id, user_id )
    created = []
    matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
    ids = [observation_matrix_column_item_id].flatten.compact
    return false if matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin
        ids.each do |i|
          o = ObservationMatrixColumnItem.where(project_id: project_id).find(i)
          c = o.dup
          c.observation_matrix = matrix
          c.created_by_id = user_id
          c.save!
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @return [Array, false]
  def self.batch_create_by_descriptor_id(observation_matrix_id, descriptor_id, project_id, user_id )
    created = []
    matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
    ids = [descriptor_id].flatten.compact
    return false if matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin
        ids.each do |i|
          c = ObservationMatrixColumnItem::Single::Descriptor.create!(
            descriptor: Descriptor.where(project_id: project_id).find(i),
            observation_matrix_id: matrix.id,
            project_id: project_id,
            created_by_id: user_id)
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @return [Array, false]
  def self.batch_create_from_observation_matrix(from_observation_matrix_id, to_observation_matrix_id, project_id, user_id )
    created = []

    from_matrix = ObservationMatrix.where(project_id: project_id).find(from_observation_matrix_id)
    to_matrix = ObservationMatrix.where(project_id: project_id).find(to_observation_matrix_id)

    return false if from_matrix.nil? || to_matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin

        from_matrix.observation_matrix_column_items.each do |oci|
          c = oci.dup
          c.observation_matrix = to_matrix
          c.created_by_id = user_id
          c.save!
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @params klass [String] the subclass of the Descriptor ike `Descriptor::Working` or `Descriptor::Continuous`
  # @return [Array, false]
  def self.batch_create_from_tags(keyword_id, klass, observation_matrix_id)
    created = []
    ObservationMatrixColumnItem.transaction do
      begin
        if klass
          klass.constantize.joins(:tags).where(tags: {keyword_id: keyword_id } ).each do |o|
            created.push create_for(o, observation_matrix_id)
          end
        else
          created += create_for_tags(
            Tag.where(
              keyword_id: keyword_id,
              tag_object_type: 'Descriptor').all,
             observation_matrix_id
          )
        end
      rescue ActiveRecord::RecordInvalid => e
        raise # return false
      end
    end
    return created
  end

  # @params klass [String] the class name like `Otu` or `CollectionObject`
  # @return [Array, false]
  def self.batch_create_from_pinboard(observation_matrix_id, project_id, user_id, klass)
    return false if observation_matrix_id.blank? || project_id.blank? || user_id.blank?
    created = []
    ObservationMatrixColumn.transaction do
      begin
        if klass
          klass.constantize.joins(:pinboard_items).where(pinboard_items: {user_id: user_id, project_id: project_id}).each do |o|
            created.push create_for(o, observation_matrix_id)
          end
        else
          created += create_for_pinboard_items(
            PinboardItem.where(project_id: project_id, user_id: user_id, pinned_object_type: 'Descriptor').all,
            observation_matrix_id
          )
        end
      rescue ActiveRecord::RecordInvalid => e
        return false
      end
    end
    return created
  end

  # @return [Boolean]
  #   whether this is a dynamic or fixed class
  #   override in subclasses
  def is_dynamic?
    false
  end

  private

  # @return [Array]
  def self.create_for_tags(tag_scope, observation_matrix_id)
    a = []
    tag_scope.each do |o|
      a.push create_for(o.tag_object, observation_matrix_id)
    end
    a
  end

  # @param pinboard_item_scope [PinboardItem Scope]
  # @return [Array]
  #   create observation matrix column items for all scope items
  def self.create_for_pinboard_items(pinboard_item_scope, observation_matrix_id)
    a = []
    pinboard_item_scope.each do |o|
      a.push create_for(o.pinned_object, observation_matrix_id)
    end
    a
  end

  def self.create_for(object, observation_matrix_id)
    ObservationMatrixColumnItem::Single::Descriptor.create!(
      observation_matrix_id: observation_matrix_id,
      descriptor: object)
  end

  def other_subclass_attributes_not_set
    (ALL_STI_ATTRIBUTES - self.class.subclass_attributes).each do |atr|
      errors.add(atr, 'is not valid for this type of observation matrix column item') if !send(atr).blank?
    end
  end

end

#type ⇒ String

Returns the column type.

Returns:

• (String) —

  the column type

# File 'app/models/observation_matrix_column_item.rb', line 18

class ObservationMatrixColumnItem < ApplicationRecord
  include Housekeeping
  include Shared::Identifiers
  include Shared::Notes
  include Shared::Tags
  include Shared::IsData

  acts_as_list scope: [:observation_matrix_id, :project_id]

  ALL_STI_ATTRIBUTES = [:descriptor_id, :controlled_vocabulary_term_id].freeze

  belongs_to :observation_matrix, inverse_of: :observation_matrix_column_items

  # TODO: remove from subclasses WHY does this need to be here
  # belongs_to :descriptor, inverse_of: :observation_matrix_column_items

  # See above and corresponding questions
  # belongs_to :controlled_vocabulary_term, inverse_of: :observation_matrix_column_items

  validates_presence_of :observation_matrix
  validate :other_subclass_attributes_not_set, if: -> { !type.blank? }

  after_save :update_matrix_columns
  after_destroy :cleanup_matrix_columns

  # @return [Array]
  #   of all objects this row references
  def column_objects
    objects = []

    objects.push *descriptors if descriptors
    objects
  end

  def cleanup_matrix_columns
    return true unless descriptors.size > 0
    ObservationMatrixColumn.where(descriptor_id: descriptors.map(&:id), observation_matrix: observation_matrix).each do |mc|
      cleanup_single_matrix_column(mc.descriptor_id, mc)
    end
    true
  end

  def update_matrix_columns
    descriptors.each do |d|
      update_single_matrix_column(d)
    end
  end

  def cleanup_single_matrix_column(descriptor_id, mc = nil)
    mc ||= ObservationMatrixColumn.where(
      descriptor_id: descriptor_id,
      observation_matrix: observation_matrix
    ).first
    decrement_matrix_column_reference_count(mc) if !mc.nil?
  end

  def decrement_matrix_column_reference_count(mc)
    current = mc.reference_count - 1
    if current == 0
      mc.delete
    else
      mc.update_columns(reference_count: current)
      mc.update_columns(cached_observation_matrix_column_item_id: nil) if current == 1 && type =~ /Single/ # we've deleted the only single, so the last must be a Dynamic/Tagged
    end
  end

  def find_or_build_column(descriptor)
    ObservationMatrixColumn.find_or_initialize_by(
      observation_matrix: observation_matrix,
      descriptor: descriptor)
  end

  # creates or finds and updates count, always
  def update_single_matrix_column(descriptor)
    mc = find_or_build_column(descriptor)
    mc.save! if !mc.persisted?

    increment_matrix_column_reference_count(mc)
  end

  def increment_matrix_column_reference_count(mc)
    mc.update_columns(reference_count: (mc.reference_count || 0) + 1)
    mc.update_columns(cached_observation_matrix_column_item_id: id) if type =~ /Single/
  end

  def self.human_name
    self.name.demodulize.humanize
  end

  # @return [Array]
  #    the required attributes for this subclass
  # override
  def self.subclass_attributes
    []
  end

  # @return [Array]
  #    the descriptors "defined" by this matrix column item
  # override
  def descriptors
    false
  end

  # @return [Array] of ObservationMatrixColumnItems
  def self.batch_create(params)
    case params[:batch_type]
    when 'tags'
      batch_create_from_tags(params[:keyword_id], params[:klass], params[:observation_matrix_id])
    when 'pinboard'
      batch_create_from_pinboard(params[:observation_matrix_id], params[:project_id], params[:user_id], params[:klass])
    when 'matrix_clone'
      batch_create_from_observation_matrix(params[:observation_matrix_id], params[:target_observation_matrix_id], params[:project_id], params[:user_id])
    when 'descriptor_id'
      batch_create_by_descriptor_id(params[:observation_matrix_id], params[:descriptor_id], params[:project_id], params[:user_id])

    when 'observation_matrix_column_item_id'
      batch_create_by_observation_matrix_column_item_id(params[:observation_matrix_id], params[:observation_matrix_column_item_id], params[:project_id], params[:user_id])
    end
  end

  # @return [Array, false]
  def self.batch_create_by_observation_matrix_column_item_id(observation_matrix_id, observation_matrix_column_item_id, project_id, user_id )
    created = []
    matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
    ids = [observation_matrix_column_item_id].flatten.compact
    return false if matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin
        ids.each do |i|
          o = ObservationMatrixColumnItem.where(project_id: project_id).find(i)
          c = o.dup
          c.observation_matrix = matrix
          c.created_by_id = user_id
          c.save!
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @return [Array, false]
  def self.batch_create_by_descriptor_id(observation_matrix_id, descriptor_id, project_id, user_id )
    created = []
    matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
    ids = [descriptor_id].flatten.compact
    return false if matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin
        ids.each do |i|
          c = ObservationMatrixColumnItem::Single::Descriptor.create!(
            descriptor: Descriptor.where(project_id: project_id).find(i),
            observation_matrix_id: matrix.id,
            project_id: project_id,
            created_by_id: user_id)
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @return [Array, false]
  def self.batch_create_from_observation_matrix(from_observation_matrix_id, to_observation_matrix_id, project_id, user_id )
    created = []

    from_matrix = ObservationMatrix.where(project_id: project_id).find(from_observation_matrix_id)
    to_matrix = ObservationMatrix.where(project_id: project_id).find(to_observation_matrix_id)

    return false if from_matrix.nil? || to_matrix.nil?

    ObservationMatrixColumnItem.transaction do
      begin

        from_matrix.observation_matrix_column_items.each do |oci|
          c = oci.dup
          c.observation_matrix = to_matrix
          c.created_by_id = user_id
          c.save!
          created.push c
        end
      rescue ActiveRecord::RecordInvalid => e
        next
      end
    end
    return created
  end

  # @params klass [String] the subclass of the Descriptor ike `Descriptor::Working` or `Descriptor::Continuous`
  # @return [Array, false]
  def self.batch_create_from_tags(keyword_id, klass, observation_matrix_id)
    created = []
    ObservationMatrixColumnItem.transaction do
      begin
        if klass
          klass.constantize.joins(:tags).where(tags: {keyword_id: keyword_id } ).each do |o|
            created.push create_for(o, observation_matrix_id)
          end
        else
          created += create_for_tags(
            Tag.where(
              keyword_id: keyword_id,
              tag_object_type: 'Descriptor').all,
             observation_matrix_id
          )
        end
      rescue ActiveRecord::RecordInvalid => e
        raise # return false
      end
    end
    return created
  end

  # @params klass [String] the class name like `Otu` or `CollectionObject`
  # @return [Array, false]
  def self.batch_create_from_pinboard(observation_matrix_id, project_id, user_id, klass)
    return false if observation_matrix_id.blank? || project_id.blank? || user_id.blank?
    created = []
    ObservationMatrixColumn.transaction do
      begin
        if klass
          klass.constantize.joins(:pinboard_items).where(pinboard_items: {user_id: user_id, project_id: project_id}).each do |o|
            created.push create_for(o, observation_matrix_id)
          end
        else
          created += create_for_pinboard_items(
            PinboardItem.where(project_id: project_id, user_id: user_id, pinned_object_type: 'Descriptor').all,
            observation_matrix_id
          )
        end
      rescue ActiveRecord::RecordInvalid => e
        return false
      end
    end
    return created
  end

  # @return [Boolean]
  #   whether this is a dynamic or fixed class
  #   override in subclasses
  def is_dynamic?
    false
  end

  private

  # @return [Array]
  def self.create_for_tags(tag_scope, observation_matrix_id)
    a = []
    tag_scope.each do |o|
      a.push create_for(o.tag_object, observation_matrix_id)
    end
    a
  end

  # @param pinboard_item_scope [PinboardItem Scope]
  # @return [Array]
  #   create observation matrix column items for all scope items
  def self.create_for_pinboard_items(pinboard_item_scope, observation_matrix_id)
    a = []
    pinboard_item_scope.each do |o|
      a.push create_for(o.pinned_object, observation_matrix_id)
    end
    a
  end

  def self.create_for(object, observation_matrix_id)
    ObservationMatrixColumnItem::Single::Descriptor.create!(
      observation_matrix_id: observation_matrix_id,
      descriptor: object)
  end

  def other_subclass_attributes_not_set
    (ALL_STI_ATTRIBUTES - self.class.subclass_attributes).each do |atr|
      errors.add(atr, 'is not valid for this type of observation matrix column item') if !send(atr).blank?
    end
  end

end

Class Method Details

.batch_create(params) ⇒ Array

Returns of ObservationMatrixColumnItems.

Returns:

• (Array) —

  of ObservationMatrixColumnItems

# File 'app/models/observation_matrix_column_item.rb', line 122

def self.batch_create(params)
  case params[:batch_type]
  when 'tags'
    batch_create_from_tags(params[:keyword_id], params[:klass], params[:observation_matrix_id])
  when 'pinboard'
    batch_create_from_pinboard(params[:observation_matrix_id], params[:project_id], params[:user_id], params[:klass])
  when 'matrix_clone'
    batch_create_from_observation_matrix(params[:observation_matrix_id], params[:target_observation_matrix_id], params[:project_id], params[:user_id])
  when 'descriptor_id'
    batch_create_by_descriptor_id(params[:observation_matrix_id], params[:descriptor_id], params[:project_id], params[:user_id])

  when 'observation_matrix_column_item_id'
    batch_create_by_observation_matrix_column_item_id(params[:observation_matrix_id], params[:observation_matrix_column_item_id], params[:project_id], params[:user_id])
  end
end

.batch_create_by_descriptor_id(observation_matrix_id, descriptor_id, project_id, user_id) ⇒ Array, false

Returns:

• (Array, false)

# File 'app/models/observation_matrix_column_item.rb', line 163

def self.batch_create_by_descriptor_id(observation_matrix_id, descriptor_id, project_id, user_id )
  created = []
  matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
  ids = [descriptor_id].flatten.compact
  return false if matrix.nil?

  ObservationMatrixColumnItem.transaction do
    begin
      ids.each do |i|
        c = ObservationMatrixColumnItem::Single::Descriptor.create!(
          descriptor: Descriptor.where(project_id: project_id).find(i),
          observation_matrix_id: matrix.id,
          project_id: project_id,
          created_by_id: user_id)
        created.push c
      end
    rescue ActiveRecord::RecordInvalid => e
      next
    end
  end
  return created
end

.batch_create_by_observation_matrix_column_item_id(observation_matrix_id, observation_matrix_column_item_id, project_id, user_id) ⇒ Array, false

Returns:

• (Array, false)

# File 'app/models/observation_matrix_column_item.rb', line 139

def self.batch_create_by_observation_matrix_column_item_id(observation_matrix_id, observation_matrix_column_item_id, project_id, user_id )
  created = []
  matrix  = ObservationMatrix.where(project_id: project_id).find(observation_matrix_id)
  ids = [observation_matrix_column_item_id].flatten.compact
  return false if matrix.nil?

  ObservationMatrixColumnItem.transaction do
    begin
      ids.each do |i|
        o = ObservationMatrixColumnItem.where(project_id: project_id).find(i)
        c = o.dup
        c.observation_matrix = matrix
        c.created_by_id = user_id
        c.save!
        created.push c
      end
    rescue ActiveRecord::RecordInvalid => e
      next
    end
  end
  return created
end

.batch_create_from_observation_matrix(from_observation_matrix_id, to_observation_matrix_id, project_id, user_id) ⇒ Array, false

Returns:

• (Array, false)

# File 'app/models/observation_matrix_column_item.rb', line 187

def self.batch_create_from_observation_matrix(from_observation_matrix_id, to_observation_matrix_id, project_id, user_id )
  created = []

  from_matrix = ObservationMatrix.where(project_id: project_id).find(from_observation_matrix_id)
  to_matrix = ObservationMatrix.where(project_id: project_id).find(to_observation_matrix_id)

  return false if from_matrix.nil? || to_matrix.nil?

  ObservationMatrixColumnItem.transaction do
    begin

      from_matrix.observation_matrix_column_items.each do |oci|
        c = oci.dup
        c.observation_matrix = to_matrix
        c.created_by_id = user_id
        c.save!
        created.push c
      end
    rescue ActiveRecord::RecordInvalid => e
      next
    end
  end
  return created
end

.batch_create_from_pinboard(observation_matrix_id, project_id, user_id, klass) ⇒ Array, false

Returns:

• (Array, false)

# File 'app/models/observation_matrix_column_item.rb', line 239

def self.batch_create_from_pinboard(observation_matrix_id, project_id, user_id, klass)
  return false if observation_matrix_id.blank? || project_id.blank? || user_id.blank?
  created = []
  ObservationMatrixColumn.transaction do
    begin
      if klass
        klass.constantize.joins(:pinboard_items).where(pinboard_items: {user_id: user_id, project_id: project_id}).each do |o|
          created.push create_for(o, observation_matrix_id)
        end
      else
        created += create_for_pinboard_items(
          PinboardItem.where(project_id: project_id, user_id: user_id, pinned_object_type: 'Descriptor').all,
          observation_matrix_id
        )
      end
    rescue ActiveRecord::RecordInvalid => e
      return false
    end
  end
  return created
end

.batch_create_from_tags(keyword_id, klass, observation_matrix_id) ⇒ Array, false

Returns:

• (Array, false)

# File 'app/models/observation_matrix_column_item.rb', line 214

def self.batch_create_from_tags(keyword_id, klass, observation_matrix_id)
  created = []
  ObservationMatrixColumnItem.transaction do
    begin
      if klass
        klass.constantize.joins(:tags).where(tags: {keyword_id: keyword_id } ).each do |o|
          created.push create_for(o, observation_matrix_id)
        end
      else
        created += create_for_tags(
          Tag.where(
            keyword_id: keyword_id,
            tag_object_type: 'Descriptor').all,
           observation_matrix_id
        )
      end
    rescue ActiveRecord::RecordInvalid => e
      raise # return false
    end
  end
  return created
end

.create_for(object, observation_matrix_id) ⇒ Object (private)

# File 'app/models/observation_matrix_column_item.rb', line 290

def self.create_for(object, observation_matrix_id)
  ObservationMatrixColumnItem::Single::Descriptor.create!(
    observation_matrix_id: observation_matrix_id,
    descriptor: object)
end

.create_for_pinboard_items(pinboard_item_scope, observation_matrix_id) ⇒ Array (private)

Returns create observation matrix column items for all scope items.

Parameters:

• pinboard_item_scope (PinboardItem Scope)

Returns:

• (Array) —

  create observation matrix column items for all scope items

# File 'app/models/observation_matrix_column_item.rb', line 282

def self.create_for_pinboard_items(pinboard_item_scope, observation_matrix_id)
  a = []
  pinboard_item_scope.each do |o|
    a.push create_for(o.pinned_object, observation_matrix_id)
  end
  a
end

.create_for_tags(tag_scope, observation_matrix_id) ⇒ Array (private)

Returns:

• (Array)

# File 'app/models/observation_matrix_column_item.rb', line 271

def self.create_for_tags(tag_scope, observation_matrix_id)
  a = []
  tag_scope.each do |o|
    a.push create_for(o.tag_object, observation_matrix_id)
  end
  a
end

.human_name ⇒ Object

# File 'app/models/observation_matrix_column_item.rb', line 103

def self.human_name
  self.name.demodulize.humanize
end

.subclass_attributes ⇒ Array

override

Returns:

• (Array) —

  the required attributes for this subclass

# File 'app/models/observation_matrix_column_item.rb', line 110

def self.subclass_attributes
  []
end

Instance Method Details

#cleanup_matrix_columns ⇒ Object

# File 'app/models/observation_matrix_column_item.rb', line 52

def cleanup_matrix_columns
  return true unless descriptors.size > 0
  ObservationMatrixColumn.where(descriptor_id: descriptors.map(&:id), observation_matrix: observation_matrix).each do |mc|
    cleanup_single_matrix_column(mc.descriptor_id, mc)
  end
  true
end

#cleanup_single_matrix_column(descriptor_id, mc = nil) ⇒ Object

# File 'app/models/observation_matrix_column_item.rb', line 66

def cleanup_single_matrix_column(descriptor_id, mc = nil)
  mc ||= ObservationMatrixColumn.where(
    descriptor_id: descriptor_id,
    observation_matrix: observation_matrix
  ).first
  decrement_matrix_column_reference_count(mc) if !mc.nil?
end

#column_objects ⇒ Array

Returns of all objects this row references.

Returns:

• (Array) —

  of all objects this row references

# File 'app/models/observation_matrix_column_item.rb', line 45

def column_objects
  objects = []

  objects.push *descriptors if descriptors
  objects
end

#decrement_matrix_column_reference_count(mc) ⇒ Object

# File 'app/models/observation_matrix_column_item.rb', line 74

def decrement_matrix_column_reference_count(mc)
  current = mc.reference_count - 1
  if current == 0
    mc.delete
  else
    mc.update_columns(reference_count: current)
    mc.update_columns(cached_observation_matrix_column_item_id: nil) if current == 1 && type =~ /Single/ # we've deleted the only single, so the last must be a Dynamic/Tagged
  end
end

#descriptors ⇒ Array

override

Returns:

• (Array) —

  the descriptors “defined” by this matrix column item

# File 'app/models/observation_matrix_column_item.rb', line 117

def descriptors
  false
end

#find_or_build_column(descriptor) ⇒ Object

# File 'app/models/observation_matrix_column_item.rb', line 84

def find_or_build_column(descriptor)
  ObservationMatrixColumn.find_or_initialize_by(
    observation_matrix: observation_matrix,
    descriptor: descriptor)
end

#increment_matrix_column_reference_count(mc) ⇒ Object

# File 'app/models/observation_matrix_column_item.rb', line 98

def increment_matrix_column_reference_count(mc)
  mc.update_columns(reference_count: (mc.reference_count || 0) + 1)
  mc.update_columns(cached_observation_matrix_column_item_id: id) if type =~ /Single/
end

#is_dynamic? ⇒ Boolean

Returns whether this is a dynamic or fixed class override in subclasses.

Returns:

• (Boolean) —

  whether this is a dynamic or fixed class override in subclasses

# File 'app/models/observation_matrix_column_item.rb', line 264

def is_dynamic?
  false
end

#other_subclass_attributes_not_set ⇒ Object (private)

# File 'app/models/observation_matrix_column_item.rb', line 296

def other_subclass_attributes_not_set
  (ALL_STI_ATTRIBUTES - self.class.subclass_attributes).each do |atr|
    errors.add(atr, 'is not valid for this type of observation matrix column item') if !send(atr).blank?
  end
end

#update_matrix_columns ⇒ Object

# File 'app/models/observation_matrix_column_item.rb', line 60

def update_matrix_columns
  descriptors.each do |d|
    update_single_matrix_column(d)
  end
end

#update_single_matrix_column(descriptor) ⇒ Object

creates or finds and updates count, always

# File 'app/models/observation_matrix_column_item.rb', line 91

def update_single_matrix_column(descriptor)
  mc = find_or_build_column(descriptor)
  mc.save! if !mc.persisted?

  increment_matrix_column_reference_count(mc)
end