fazer-ai · CayoPOliveira · Jun 18, 2025 · Jun 19, 2025 · Jun 19, 2025 · Jun 19, 2025
diff --git a/.env.example b/.env.example
@@ -266,3 +266,6 @@ BAILEYS_PROVIDER_DEFAULT_URL=http://localhost:3025
 BAILEYS_PROVIDER_DEFAULT_API_KEY=
 
 RESEND_API_KEY=
+
+# Baileys API Whatsapp configurations
+BAILEYS_MESSAGE_HISTORY_COUNT=50
diff --git a/app/javascript/dashboard/i18n/locale/en/inboxMgmt.json b/app/javascript/dashboard/i18n/locale/en/inboxMgmt.json
@@ -272,6 +272,10 @@
         "MARK_AS_READ": {
           "LABEL": "Send read receipts"
         },
+        "SYNC_FULL_HISTORY": {
+          "ONLY_CONTACTS_LABEL": "Sync only contacts",
+          "LABEL": "Sync messages and contacts"
+        },
         "ADVANCED_OPTIONS": "Advanced options",
         "BAILEYS": {
           "SUBTITLE": "Click below to setup the WhatsApp channel using Baileys.",

diff --git a/app/javascript/dashboard/i18n/locale/pt_BR/inboxMgmt.json b/app/javascript/dashboard/i18n/locale/pt_BR/inboxMgmt.json
@@ -272,6 +272,10 @@
         "MARK_AS_READ": {
           "LABEL": "Enviar confirmações de leitura"
         },
+        "SYNC_FULL_HISTORY": {
+          "ONLY_CONTACTS_LABEL": "Sincronizar apenas contatos",
+          "LABEL": "Sincronizar contatos e mensagens"
+        },
         "ADVANCED_OPTIONS": "Opções avançadas",
         "BAILEYS": {
           "SUBTITLE": "Clique abaixo para configurar o canal do WhatsApp usando o Baileys.",

diff --git a/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/BaileysWhatsapp.vue b/app/javascript/dashboard/routes/dashboard/settings/inbox/channels/BaileysWhatsapp.vue
@@ -27,6 +27,8 @@ export default {
       providerUrl: '',
       showAdvancedOptions: false,
       markAsRead: true,
+      syncContacts: false,
+      syncFullHistory: false,
     };
   },
   computed: {
@@ -53,6 +55,8 @@ export default {
       try {
         const providerConfig = {
           mark_as_read: this.markAsRead,
+          sync_contacts: this.syncContacts,
+          sync_full_history: this.syncFullHistory,
         };
 
         if (this.apiKey || this.providerUrl) {
@@ -177,6 +181,34 @@ export default {
           </div>
         </label>
       </div>
+
+      <div
+        v-if="!syncFullHistory"
+        class="w-[65%] flex-shrink-0 flex-grow-0 max-w-[65%]"
+      >
+        <label>
+          <div class="flex mb-2 items-center">
+            <span class="mr-2 text-sm">
+              {{
+                $t(
+                  'INBOX_MGMT.ADD.WHATSAPP.SYNC_FULL_HISTORY.ONLY_CONTACTS_LABEL'
+                )
+              }}
+            </span>
+            <Switch id="syncContacts" v-model="syncContacts" />
+          </div>
+        </label>
+      </div>
+      <div class="w-[65%] flex-shrink-0 flex-grow-0 max-w-[65%]">
+        <label>
+          <div class="flex mb-2 items-center">
+            <span class="mr-2 text-sm">
+              {{ $t('INBOX_MGMT.ADD.WHATSAPP.SYNC_FULL_HISTORY.LABEL') }}
+            </span>
+            <Switch id="syncFullHistory" v-model="syncFullHistory" />
+          </div>
+        </label>
+      </div>
     </template>
 
     <div class="w-full">

diff --git a/app/models/channel/whatsapp.rb b/app/models/channel/whatsapp.rb
@@ -117,6 +117,12 @@ def received_messages(messages, conversation)
     provider_service.received_messages(conversation.contact.phone_number, messages)
   end
 
+  def fetch_message_history(oldest_message)
+    return unless provider_service.respond_to?(:fetch_message_history)
+
+    provider_service.fetch_message_history(oldest_message)
+  end
+
   delegate :setup_channel_provider, to: :provider_service
   delegate :send_message, to: :provider_service
   delegate :send_template, to: :provider_service

diff --git a/app/models/message.rb b/app/models/message.rb
@@ -60,7 +60,7 @@ class Message < ApplicationRecord
   }.to_json.freeze
 
   before_validation :ensure_content_type
-  before_validation :prevent_message_flooding
+  before_validation :prevent_message_flooding, unless: :skip_prevent_message_flooding
   before_save :ensure_processed_message_content
   before_save :ensure_in_reply_to
 
@@ -78,6 +78,7 @@ class Message < ApplicationRecord
 
   # when you have a temperory id in your frontend and want it echoed back via action cable
   attr_accessor :echo_id
+  attr_accessor :skip_prevent_message_flooding
 
   enum message_type: { incoming: 0, outgoing: 1, activity: 2, template: 3 }
   enum content_type: {

diff --git a/app/services/whatsapp/baileys_handlers/messaging_history_set.rb b/app/services/whatsapp/baileys_handlers/messaging_history_set.rb
@@ -0,0 +1,207 @@
+module Whatsapp::BaileysHandlers::MessagingHistorySet # rubocop:disable Metrics/ModuleLength
+  private
+
+  def process_messaging_history_set
+    provider_config = inbox.channel.provider_config
+
+    return unless provider_config['sync_contacts'].presence || provider_config['sync_full_history'].presence
+
+    process_contacts(params)
+    process_messages(params) if provider_config['sync_full_history'].presence
+  end
+
+  def process_contacts(params)
+    contacts = params.dig(:data, :contacts) || []
+    contacts.each do |contact|
+      create_contact(contact)
+    end
+  end
+
+  def process_messages(params)
+    messages = params.dig(:data, :messages) || []
+    messages.each do |message|
+      history_handle_message(message)
+    end
+  end
+
+  def create_contact(contact)
+    return unless contact[:id].present? && jid_user?(contact[:id])
+
+    phone_number = history_phone_number_from_jid(contact[:id])
+    name = contact[:verifiedName].presence || contact[:notify].presence || contact[:name].presence || phone_number
+    ::ContactInboxWithContactBuilder.new(
+      # FIXME: update the source_id to complete jid in future
+      source_id: phone_number,
+      inbox: inbox,
+      contact_attributes: { name: name, phone_number: "+#{phone_number}" }
+    ).perform
+  end
+
+  # TODO: Refactor jid_type method in helpers to receive the jid as an argument and use it here
+  def jid_user?(jid)
+    server = jid.split('@').last
+    server == 's.whatsapp.net' || server == 'c.us'
+  end
+
+  # TODO: Refactor this method in helpers to receive the jid as an argument and remove it from here
+  def history_phone_number_from_jid(jid)
+    jid.split('@').first.split(':').first.split('_').first
+  end
+
+  def history_handle_message(raw_message)
+    return unless history_message_valid?(raw_message)
+
+    id = raw_message.dig(:key, :id)
+    jid = raw_message.dig(:key, :remoteJid)
+
+    history_cache_message_source_id_in_redis(id)
+    begin
+      contact_inbox = find_contact_inbox(jid)
+      unless contact_inbox.contact
+        Rails.logger.warn "Contact not found for message: #{id}"
+        return
+      end
+
+      history_create_message(raw_message, contact_inbox)
+    ensure
+      history_clear_message_source_id_from_redis(id)
+    end
+  end
+
+  def history_message_valid?(raw_message) # rubocop:disable Metrics/CyclomaticComplexity
+    id = raw_message.dig(:key, :id)
+    jid = raw_message.dig(:key, :remoteJid)
+
+    id.present? &&
+      jid.present? &&
+      raw_message[:message].present? &&
+      raw_message[:messageTimestamp].present? &&
+      jid_user?(jid) &&
+      !history_message_type(raw_message[:message]).in?(%w[protocol context]) &&
+      !history_find_message_by_source_id(id) &&
+      !history_message_under_process?(id)
+  end
+
+  # TODO: Refactor this method in helpers to receive the raw message as an argument and remove it from here
+  def history_message_type(message_content) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity,Metrics/MethodLength
+    if message_content.key?(:conversation) || message_content.dig(:extendedTextMessage, :text).present?
+      'text'
+    elsif message_content.key?(:imageMessage)
+      'image'
+    elsif message_content.key?(:audioMessage)
+      'audio'
+    elsif message_content.key?(:videoMessage)
+      'video'
+    elsif message_content.key?(:documentMessage) || message_content.key?(:documentWithCaptionMessage)
+      'file'
+    elsif message_content.key?(:stickerMessage)
+      'sticker'
+    elsif message_content.key?(:reactionMessage)
+      'reaction'
+    elsif message_content.key?(:editedMessage)
+      'edited'
+    elsif message_content.key?(:protocolMessage)
+      'protocol'
+    elsif message_content.key?(:messageContextInfo)
+      'context'
+    else
+      'unsupported'
+    end
+  end
+
+  # TODO: Remove this method when include helpers in this module, after update the methods to receive arguments
+  def history_find_message_by_source_id(source_id)
+    return unless source_id
+
+    Message.find_by(source_id: source_id).presence
+  end
+
+  def find_contact_inbox(jid)
+    phone_number = history_phone_number_from_jid(jid)
+    ::ContactInboxWithContactBuilder.new(
+      # FIXME: update the source_id to complete jid in future
+      source_id: phone_number,
+      inbox: inbox,
+      contact_attributes: { name: phone_number, phone_number: "+#{phone_number}" }
+    ).perform
+  end
+
+  # TODO: Refactor this method in helpers to receive the source_id as an argument and remove it from here
+  def history_message_under_process?(source_id)
+    key = format(Redis::RedisKeys::MESSAGE_SOURCE_KEY, id: source_id)
+    Redis::Alfred.get(key)
+  end
+
+  # TODO: Refactor this method in helpers to receive the source_id as an argument and deprecate setex, then remove it from here
+  def history_cache_message_source_id_in_redis(source_id)
+    key = format(Redis::RedisKeys::MESSAGE_SOURCE_KEY, id: source_id)
+    ::Redis::Alfred.set(key, true, nx: true, ex: 1.day)
+  end
+
+  # TODO: Refactor this method in helpers to receive the source_id as an argument and remove it from here
+  def history_clear_message_source_id_from_redis(source_id)
+    key = format(Redis::RedisKeys::MESSAGE_SOURCE_KEY, id: source_id)
+    ::Redis::Alfred.delete(key)
+  end
+
+  def history_create_message(raw_message, contact_inbox)
+    conversation = get_conversation(contact_inbox)
+    inbox = contact_inbox.inbox
+    message = conversation.messages.build(
+      skip_prevent_message_flooding: true,
+      content: history_message_content(raw_message),
+      account_id: inbox.account_id,
+      inbox_id: inbox.id,
+      source_id: raw_message[:key][:id],
+      sender: history_incoming?(raw_message) ? contact_inbox.contact : inbox.account.account_users.first.user,
+      sender_type: history_incoming?(raw_message) ? 'Contact' : 'User',
+      message_type: history_incoming?(raw_message) ? :incoming : :outgoing,
+      content_attributes: history_message_content_attributes(raw_message),
+      status: 'read'
+    )
+
+    message.save!
+  end
+
+  # NOTE: See reference in app/services/whatsapp/incoming_message_base_service.rb:97
+  def get_conversation(contact_inbox)
+    return contact_inbox.conversations.last if contact_inbox.inbox.lock_to_single_conversation
+
+    # NOTE: if lock to single conversation is disabled, create a new conversation if previous conversation is resolved
+    return contact_inbox.conversations.where.not(status: :resolved).last.presence ||
+           ::Conversation.create!(history_conversation_params(contact_inbo
1C6A
x))
+  end
+
+  # TODO: Refactor this method in helpers to receive the contact_inbox as an argument and remove it from here
+  def history_conversation_params(contact_inbox)
+    {
+      account_id: contact_inbox.inbox.account_id,
+      inbox_id: contact_inbox.inbox.id,
+      contact_id: contact_inbox.contact.id,
+      contact_inbox_id: contact_inbox.id
+    }
+  end
+
+  # TODO: Refactor this method in helpers to receive the raw message as an argument and remove it from here
+  def history_incoming?(raw_message)
+    !raw_message[:key][:fromMe]
+  end
+
+  # TODO: Refactor this method in helpers to receive the raw message as an argument and remove it from here
+  def history_message_content(raw_message)
+    raw_message.dig(:message, :conversation) ||
+      raw_message.dig(:message, :extendedTextMessage, :text) ||
+      raw_message.dig(:message, :imageMessage, :caption) ||
+      raw_message.dig(:message, :videoMessage, :caption) ||
+      raw_message.dig(:message, :documentMessage, :caption).presence ||
+      raw_message.dig(:message, :documentWithCaptionMessage, :message, :documentMessage, :caption) ||
+      raw_message.dig(:message, :reactionMessage, :text)
+  end
+
+  def history_message_content_attributes(raw_message)
+    {
+      external_created_at: baileys_extract_message_timestamp(raw_message[:messageTimestamp]),
+      is_unsupported: history_message_type(raw_message[:message]).in?(%w[image file video audio sticker unsupported]) || nil
+    }.compact
+  end
+end
diff --git a/app/services/whatsapp/incoming_message_baileys_service.rb b/app/services/whatsapp/incoming_message_baileys_service.rb
@@ -2,6 +2,7 @@ class Whatsapp::IncomingMessageBaileysService < Whatsapp::IncomingMessageBaseSer
   include Whatsapp::BaileysHandlers::ConnectionUpdate
   include Whatsapp::BaileysHandlers::MessagesUpsert
   include Whatsapp::BaileysHandlers::MessagesUpdate
+  include Whatsapp::BaileysHandlers::MessagingHistorySet
 
   class InvalidWebhookVerifyToken < StandardError; end
 

diff --git a/app/services/whatsapp/providers/whatsapp_baileys_service.rb b/app/services/whatsapp/providers/whatsapp_baileys_service.rb
@@ -9,15 +9,18 @@ class MessageNotSentError < StandardError; end
   DEFAULT_API_KEY = ENV.fetch('BAILEYS_PROVIDER_DEFAULT_API_KEY', nil)
 
   def setup_channel_provider
+    provider_config = whatsapp_channel.provider_config
+
     response = HTTParty.post(
       "#{provider_url}/connections/#{whatsapp_channel.phone_number}",
       headers: api_headers,
       body: {
         clientName: DEFAULT_CLIENT_NAME,
         webhookUrl: whatsapp_channel.inbox.callback_webhook_url,
-        webhookVerifyToken: whatsapp_channel.provider_config['webhook_verify_token'],
+        webhookVerifyToken: provider_config['webhook_verify_token'],
         # TODO: Remove on Baileys v2, default will be false
-        includeMedia: false
+        includeMedia: false,
+        syncFullHistory: provider_config['sync_contacts'].presence || provider_config['sync_full_history'].presence
       }.compact.to_json
     )
 
@@ -155,6 +158,24 @@ def unread_message(phone_number, message) # rubocop:disable Metrics/MethodLength
     process_response(response)
   end
 
+  def fetch_message_history(oldest_message)
+    response = HTTParty.post(
+      "#{provider_url}/connections/#{whatsapp_channel.phone_number}/fetch-message-history",
+      headers: api_headers,
+      body: {
+        count: ENV.fetch('BAILEYS_MESSAGE_HISTORY_COUNT', 50).to_i,
+        oldestMsgKey: {
+          id: oldest_message[:key][:id],
+          remoteJid: oldest_message[:key][:remoteJid],
+          fromMe: oldest_message[:key][:fromMe]
+        },
+        oldestMsgTimestamp: oldest_message[:messageTimestamp]
+      }.to_json
+    )
+
+    process_response(response)
+  end
+
   def received_messages(phone_number, messages)
     @phone_number = phone_number
 
@@ -277,5 +298,6 @@ def handle_channel_error
                       :update_presence,
                       :read_messages,
                       :unread_message,
-                      :received_messages
+                      :received_messages,
+                      :fetch_message_history
 end
diff --git a/spec/models/message_spec.rb b/spec/models/message_spec.rb
@@ -38,6 +38,16 @@
           expect(conv_new_message.errors[:base]).to eq(['Too many messages'])
         end
       end
+
+      it 'skips message flooding validation if skip_prevent_message_flooding is true' do
+        with_modified_env 'CONVERSATION_MESSAGE_PER_MINUTE_LIMIT': '2' do
+          conversation = message.conversation
+          create(:message, conversation: conversation)
+          conv_new_message = build(:message, conversation: message.conversation, skip_prevent_message_flooding: true)
+
+          expect(conv_new_message.valid?).to be true
+        end
+      end
     end
   end