better_conversation_manager.rb

class OneOnOne::ConversationManager
  attr_reader :session, :limit, :offset, :timestamp
  LIMIT = 5

  def initialize(session, options = {})
    @session = session
    @limit   = options[:limit].present? ? options[:limit].to_i : LIMIT
    @offset  = options[:offset].present? ? options[:offset].to_i : 0

    @timestamp  = options[:timestamp].present? ? Time.at(options[:timestamp].to_i) : nil
  end

  def updates
    data = OneOnOne::Message.connection.select_all(<<-SQL)
      SELECT *,
        CASE
          WHEN deleted_at > '#{timestamp}' THEN 'deleted'
          WHEN created_at > '#{timestamp}' THEN 'created'
        END AS type
      FROM (#{items_sql}) as data
      WHERE
        deleted_at > '#{timestamp}' OR created_at > '#{timestamp}'
    SQL

    deleted_items = data.find_all{ |item| item['type'] == 'deleted' }
    deleted_items = instantiate_and_present(deleted_items)

    created_items = data.find_all{ |item| item['type'] == 'created' }
    created_items = instantiate_and_present(created_items)

    {
      deleted_items_uuids: deleted_items.map{ |item| item[:uuid] },
      created_items: created_items.reverse
    }
  end

  def items
    data = OneOnOne::Message.connection.select_all(<<-SQL)
      SELECT *
      FROM (#{items_sql}) as data

      WHERE data.deleted_at IS NULL
      LIMIT #{offset}, #{limit}
    SQL

    instantiate_and_present(data).reverse
  end

  def total_items_count
    session.action_items.count + session.messages.count
  end

  private def items_sql
    <<-SQL
      SELECT id, user_id, created_at, body, null as description, null as assignee_id, null as deleted_at
      FROM one_on_one_messages
      WHERE session_id = #{session.id}

      UNION

      SELECT id, user_id, created_at, null as body, description, assignee_id, deleted_at
      FROM one_on_one_action_items
      WHERE session_id = #{session.id}

      ORDER BY created_at DESC
    SQL
  end

  private def instantiate_and_present(items_data)
    collection = []

    items_data.each do |item_data|
      if item_data['assignee_id'].present?
        item = OneOnOne::ActionItem.instantiate(item_data)
        custom_data = { assignee: preloaded_users(item.assignee_id) }
      else
        item = OneOnOne::Message.instantiate(item_data)
        custom_data = { files: preloaded_files(item.id) }
      end

      custom_data[:user] = preloaded_users(item.user_id)

      collection << presented_item(item, custom_data)
    end

    collection
  end

  private def preloaded_users(user_id)
    @preloaded_users ||= User.where(id: [session.manager_id, session.employee_id]).index_by(&:id)
    @preloaded_users[user_id]
  end

  private def preloaded_files(message_id)
    @preloaded_files ||= begin
      files_hash = {}
      session.files.each{ |file| (files_hash[file.message_id] ||= []) << file }
      files_hash
    end

    @preloaded_files[message_id].present? ? @preloaded_files[message_id] : []
  end

  private def item_visible?(item)
    !(item.is_a?(OneOnOne::ActionItem) && item.deleted_at)
  end

  private def presented_item(item, custom_data)
    if item.is_a?(OneOnOne::Message)
      OneOnOne::Messages::Presenter.new(item).as_mobile_json(custom_data)
    else
      OneOnOne::ActionItems::Presenter.new(item).as_mobile_json(custom_data)
    end
  end
end