Restructure omni services and add Chatwoot research snapshot

research/chatwoot/spec/jobs/notification/delete_notification_job_spec.rb

@@ -0,0 +1,38 @@
+require 'rails_helper'
+
+RSpec.describe Notification::DeleteNotificationJob do
+  let(:user) { create(:user) }
+  let(:conversation) { create(:conversation) }
+
+  context 'when enqueuing the job' do
+    it 'enqueues the job to delete all notifications' do
+      expect do
+        described_class.perform_later(user.id, type: :all)
+      end.to have_enqueued_job(described_class).on_queue('low')
+    end
+
+    it 'enqueues the job to delete read notifications' do
+      expect do
+        described_class.perform_later(user.id, type: :read)
+      end.to have_enqueued_job(described_class).on_queue('low')
+    end
+  end
+
+  context 'when performing the job' do
+    before do
+      create(:notification, user: user, read_at: nil)
+      create(:notification, user: user, read_at: Time.current)
+    end
+
+    it 'deletes all notifications' do
+      described_class.perform_now(user, type: :all)
+      expect(user.notifications.count).to eq(0)
+    end
+
+    it 'deletes only read notifications' do
+      described_class.perform_now(user, type: :read)
+      expect(user.notifications.count).to eq(1)
+      expect(user.notifications.where(read_at: nil).count).to eq(1)
+    end
+  end
+end

research/chatwoot/spec/jobs/notification/remove_duplicate_notification_job_spec.rb

@@ -0,0 +1,22 @@
+require 'rails_helper'
+
+RSpec.describe Notification::RemoveDuplicateNotificationJob do
+  let(:user) { create(:user) }
+  let(:conversation) { create(:conversation) }
+
+  it 'enqueues the job' do
+    duplicate_notification = create(:notification, user: user, notification_type: 'conversation_creation', primary_actor: conversation)
+    expect do
+      described_class.perform_later(duplicate_notification)
+    end.to have_enqueued_job(described_class)
+      .on_queue('default')
+  end
+
+  it 'removes duplicate notifications' do
+    create(:notification, user: user, notification_type: 'conversation_creation', primary_actor: conversation)
+    duplicate_notification = create(:notification, user: user, notification_type: 'conversation_creation', primary_actor: conversation)
+
+    described_class.perform_now(duplicate_notification)
+    expect(Notification.count).to eq(1)
+  end
+end

research/chatwoot/spec/jobs/notification/remove_old_notification_job_spec.rb

@@ -0,0 +1,65 @@
+require 'rails_helper'
+
+RSpec.describe Notification::RemoveOldNotificationJob do
+  let(:account) { create(:account) }
+  let(:user) { create(:user, account: account) }
+  let(:conversation) { create(:conversation, account: account) }
+
+  it 'enqueues the job' do
+    expect do
+      described_class.perform_later
+    end.to have_enqueued_job(described_class)
+      .on_queue('purgable')
+  end
+
+  describe 'removing old notifications' do
+    it 'removes notifications older than 1 month' do
+      create(:notification, user: user, notification_type: 'conversation_creation', primary_actor: conversation,
+                            created_at: 2.months.ago)
+      create(:notification, user: user, notification_type: 'conversation_creation', primary_actor: conversation,
+                            created_at: 1.month.ago)
+      create(:notification, user: user, notification_type: 'conversation_creation', primary_actor: conversation,
+                            created_at: 1.day.ago)
+      create(:notification, user: user, notification_type: 'conversation_creation', primary_actor: conversation,
+                            created_at: 1.hour.ago)
+
+      described_class.perform_now
+      expect(Notification.count).to eq(2)
+    end
+  end
+
+  describe 'trimming user notifications' do
+    it 'does not delete notifications when user has fewer than 300' do
+      create_list(:notification, 50, user: user, account: account, primary_actor: conversation)
+
+      expect { described_class.perform_now }.not_to(change(Notification, :count))
+    end
+
+    it 'trims to 300 notifications per user keeping the most recent' do
+      old_notifications = create_list(:notification, 50, user: user, account: account, primary_actor: conversation,
+                                                         created_at: 2.days.ago)
+      recent_notifications = create_list(:notification, 300, user: user, account: account, primary_actor: conversation,
+                                                             created_at: 1.hour.ago)
+
+      described_class.perform_now
+
+      expect(Notification.where(user_id: user.id).count).to eq(300)
+      expect(Notification.where(id: old_notifications.map(&:id))).to be_empty
+      expect(Notification.where(id: recent_notifications.map(&:id)).count).to eq(300)
+    end
+  end
+
+  describe 'combined functionality' do
+    it 'removes old notifications and trims user notifications in one job' do
+      # User with old and excess notifications
+      create_list(:notification, 100, user: user, account: account, primary_actor: conversation, created_at: 2.months.ago)
+      create_list(:notification, 250, user: user, account: account, primary_actor: conversation, created_at: 1.day.ago)
+
+      described_class.perform_now
+
+      # All old notifications removed, remaining trimmed to 300
+      expect(Notification.where(user_id: user.id).count).to eq(250)
+      expect(Notification.where('created_at < ?', 1.month.ago)).to be_empty
+    end
+  end
+end

research/chatwoot/spec/jobs/notification/reopen_snoozed_notifications_job_spec.rb

@@ -0,0 +1,26 @@
+require 'rails_helper'
+
+RSpec.describe Notification::ReopenSnoozedNotificationsJob do
+  let!(:snoozed_till_5_minutes_ago) { create(:notification, snoozed_until: 5.minutes.ago) }
+  let!(:snoozed_till_tomorrow) { create(:notification, snoozed_until: 1.day.from_now) }
+  let!(:snoozed_indefinitely) { create(:notification) }
+
+  it 'enqueues the job' do
+    expect { described_class.perform_later }.to have_enqueued_job(described_class)
+      .on_queue('low')
+  end
+
+  context 'when called' do
+    it 'reopens snoozed notifications whose snooze until has passed' do
+      described_class.perform_now
+
+      snoozed_until = snoozed_till_5_minutes_ago.reload.snoozed_until
+
+      expect(snoozed_till_5_minutes_ago.reload.snoozed_until).to be_nil
+      expect(snoozed_till_tomorrow.reload.snoozed_until.to_date).to eq 1.day.from_now.to_date
+      expect(snoozed_indefinitely.reload.snoozed_until).to be_nil
+      expect(snoozed_indefinitely.reload.read_at).to be_nil
+      expect(snoozed_until).to eq(snoozed_till_5_minutes_ago.reload.meta['snoozed_until'])
+    end
+  end
+end