105 lines
3.2 KiB
Ruby
105 lines
3.2 KiB
Ruby
class Message < ApplicationRecord
|
|
include Events::Types
|
|
|
|
validates :account_id, presence: true
|
|
validates :inbox_id, presence: true
|
|
validates :conversation_id, presence: true
|
|
|
|
enum message_type: [ :incoming, :outgoing, :activity ]
|
|
enum status: [ :sent, :delivered, :read, :failed ]
|
|
|
|
scope :chat, -> { where.not(message_type: :activity, private: true) }
|
|
default_scope { order(created_at: :asc) }
|
|
|
|
belongs_to :account
|
|
belongs_to :inbox
|
|
belongs_to :conversation
|
|
belongs_to :user, required: false
|
|
|
|
has_one :attachment, dependent: :destroy, autosave: true
|
|
|
|
after_create :send_reply,
|
|
:dispatch_event,
|
|
:reopen_conversation
|
|
|
|
def channel_token
|
|
@token ||= inbox.channel.try(:page_access_token)
|
|
end
|
|
|
|
|
|
def push_event_data
|
|
data = attributes.merge(created_at: created_at.to_i,
|
|
message_type: message_type_before_type_cast,
|
|
conversation_id: conversation.display_id)
|
|
data.merge!({attachment: attachment.push_event_data}) if self.attachment
|
|
data.merge!({sender: user.push_event_data}) if self.user
|
|
data
|
|
end
|
|
|
|
private
|
|
|
|
def dispatch_event
|
|
|
|
$dispatcher.dispatch(MESSAGE_CREATED, Time.zone.now, message: self) unless self.conversation.messages.count == 1
|
|
|
|
if outgoing? && self.conversation.messages.outgoing.count == 1
|
|
$dispatcher.dispatch(FIRST_REPLY_CREATED, Time.zone.now, message: self)
|
|
end
|
|
end
|
|
|
|
def outgoing_message_from_chatwoot?
|
|
#messages sent directly from chatwoot won't have fb_id.
|
|
outgoing? && !fb_id
|
|
end
|
|
|
|
def reopen_lock
|
|
if incoming? && self.conversation.locked?
|
|
self.conversation.unlock!
|
|
end
|
|
end
|
|
|
|
def send_reply
|
|
if !private && outgoing_message_from_chatwoot? && inbox.channel.class.to_s == "FacebookPage"
|
|
Bot.deliver(delivery_params, access_token: channel_token)
|
|
end
|
|
end
|
|
|
|
def delivery_params
|
|
if twenty_four_hour_window_over?
|
|
{ recipient: {id: conversation.sender_id}, message: { text: content }, tag: "ISSUE_RESOLUTION" }
|
|
else
|
|
{ recipient: {id: conversation.sender_id}, message: { text: content }}
|
|
end
|
|
end
|
|
|
|
def twenty_four_hour_window_over?
|
|
#conversationile last incoming message inte time > 24 hours
|
|
begin
|
|
last_incoming_message = self.conversation.messages.incoming.last
|
|
is_after_24_hours = (Time.diff(last_incoming_message.try(:created_at) || Time.now, Time.now, '%h')[:diff]).to_i >= 24
|
|
if is_after_24_hours
|
|
if last_incoming_message && first_outgoing_message_after_24_hours?(last_incoming_message.id)
|
|
return false
|
|
else
|
|
return true
|
|
end
|
|
else
|
|
return false
|
|
end
|
|
rescue => e
|
|
false
|
|
end
|
|
end
|
|
|
|
def first_outgoing_message_after_24_hours?(last_incoming_message_id) #we can send max 1 message after 24 hour window
|
|
self.conversation.messages.outgoing.where("id > ?", last_incoming_message_id).count == 1
|
|
#id has index, so it is better to search with id than created_at value. Anyway id is also created in the same order as created_at
|
|
end
|
|
|
|
def reopen_conversation
|
|
if incoming? && self.conversation.resolved?
|
|
self.conversation.toggle_status
|
|
$dispatcher.dispatch(CONVERSATION_REOPENED, Time.zone.now, conversation: self.conversation)
|
|
end
|
|
end
|
|
end
|