Undelivered

gem 'undelivered'

class CreateUndeliveredReadMarks < ActiveRecord::Migration[6.1]
  def change
    create_table :undelivered_read_marks do |t|
      t.references :reader,   polymorphic: { null: false }
      t.references :readable, polymorphic: { null: false }
      t.integer    :status,   index: true
      t.datetime   :timestamp

      t.timestamps
    end

    add_index :undelivered_read_marks, [:reader_id, :reader_type, :readable_type, :readable_id, :status], name: 'undelivered_read_marks_reader_readable_status_index', unique: true
  end
end

class User < ApplicationRecord
  acts_as_reader
end

class Conversation < ApplicationRecord
  acts_as_readable on: :updated_at

  has_many :messages, dependent: :destroy
  
  def undelivered_messages(reader)
    chain = messages
    rm = find_read_mark(reader, :delivered) # this method comes from `undelivered` gem
    if rm.present?
      chain = chain.where('created_at > ?', rm.timestamp)
    end
    return chain
  end
  
  def unread_messages(reader)
    chain = messages
    rm = find_read_mark(reader, :read)
    if rm.present?
      chain = chain.where('created_at > ?', rm.timestamp)
    end
    return chain
  end
end

class Message < ApplicationRecord
  belongs_to :conversation, touch: true
end

# Suppose we got 1 users and 1 conversation
current_user = User.find(1)

conversation = Conversation.find(1)

message1 = conversation.messages.create
message2 = conversation.messages.create

# Get undelivered messages for current_user, using method of conversation class
conversation.undelivered_messages(current_user)
# => [ message1, message2 ]

# Mark them as delivered for current_user
conversation.mark_as_delivered_for!(current_user)


# Get unread messages for current_user
conversation.unread_messages(current_user)
# => [ message1, message2 ]

# Mark them as read for current_user
conversation.mark_as_read_for!(current_user)