Merge branch 'release/3.6.0'

chore: Fix for inbound email domain being nil

app/controllers/api/v1/accounts/notifications_controller.rb

@@ -7,8 +7,8 @@ class Api::V1::Accounts::NotificationsController < Api::V1::Accounts::BaseContro
   before_action :set_current_page, only: [:index]
 
   def index
+    @notifications = notification_finder.notifications
     @unread_count = notification_finder.unread_count
-    @notifications = notification_finder.perform
     @count = notification_finder.count
   end
 

app/finders/conversation_finder.rb

@@ -169,6 +169,12 @@ class ConversationFinder
     )
 
     sort_by, sort_order = SORT_OPTIONS[params[:sort_by]] || SORT_OPTIONS['last_activity_at_desc']
-    @conversations.send(sort_by, sort_order).page(current_page).per(ENV.fetch('CONVERSATION_RESULTS_PER_PAGE', '25').to_i)
+    @conversations = @conversations.send(sort_by, sort_order)
+
+    if params[:updated_within].present?
+      @conversations.where('conversations.updated_at > ?', Time.zone.now - params[:updated_within].to_i.seconds)
+    else
+      @conversations.page(current_page).per(ENV.fetch('CONVERSATION_RESULTS_PER_PAGE', '25').to_i)
+    end
   end
 end

app/finders/notification_finder.rb

@@ -10,8 +10,8 @@ class NotificationFinder
     set_up
   end
 
-  def perform
-    notifications
+  def notifications
+    @notifications.page(current_page).per(RESULTS_PER_PAGE).order(last_activity_at: sort_order)
   end
 
   def unread_count
@@ -26,27 +26,31 @@ class NotificationFinder
 
   def set_up
     find_all_notifications
-    filter_by_read_status
-    filter_by_status
+    filter_snoozed_notifications
+    fitler_read_notifications
   end
 
   def find_all_notifications
     @notifications = current_user.notifications.where(account_id: @current_account.id)
   end
 
-  def filter_by_status
-    @notifications = @notifications.where('snoozed_until > ?', DateTime.now.utc) if params[:status] == 'snoozed'
+  def filter_snoozed_notifications
+    @notifications = @notifications.where(snoozed_until: nil) unless type_included?('snoozed')
   end
 
-  def filter_by_read_status
-    @notifications = @notifications.where.not(read_at: nil) if params[:type] == 'read'
+  def fitler_read_notifications
+    @notifications = @notifications.where(read_at: nil) unless type_included?('read')
+  end
+
+  def type_included?(type)
+    (params[:includes] || []).include?(type)
   end
 
   def current_page
     params[:page] || 1
   end
 
-  def notifications
-    @notifications.page(current_page).per(RESULTS_PER_PAGE).order(last_activity_at: params[:sort_order] || :desc)
+  def sort_order
+    params[:sort_order] || :desc
   end
 end

app/javascript/dashboard/api/agents.js

@@ -1,9 +1,17 @@
+/* global axios */
+
 import ApiClient from './ApiClient';
 
 class Agents extends ApiClient {
   constructor() {
     super('agents', { accountScoped: true });
   }
+
+  bulkInvite({ emails }) {
+    return axios.post(`${this.url}/bulk_create`, {
+      emails,
+    });
+  }
 }
 
 export default new Agents();

app/javascript/dashboard/api/notifications.js

@@ -7,12 +7,13 @@ class NotificationsAPI extends ApiClient {
   }
 
   get({ page, status, type, sortOrder }) {
+    const includesFilter = [status, type].filter(value => !!value);
+
     return axios.get(this.url, {
       params: {
         page,
-        status,
-        type,
         sort_order: sortOrder,
+        includes: includesFilter,
       },
     });
   }

app/javascript/dashboard/api/specs/agents.spec.js

@@ -10,4 +10,29 @@ describe('#AgentAPI', () => {
     expect(agents).toHaveProperty('update');
     expect(agents).toHaveProperty('delete');
   });
+
+  describe('API calls', () => {
+    const originalAxios = window.axios;
+    const axiosMock = {
+      post: jest.fn(() => Promise.resolve()),
+    };
+
+    beforeEach(() => {
+      window.axios = axiosMock;
+    });
+
+    afterEach(() => {
+      window.axios = originalAxios;
+    });
+
+    it('#bulkInvite', () => {
+      agents.bulkInvite({ emails: ['hello@hi.com'] });
+      expect(axiosMock.post).toHaveBeenCalledWith(
+        '/api/v1/agents/bulk_create',
+        {
+          emails: ['hello@hi.com'],
+        }
+      );
+    });
+  });
 });

app/javascript/dashboard/api/specs/notifications.spec.js

@@ -27,20 +27,36 @@ describe('#NotificationAPI', () => {
       window.axios = originalAxios;
     });
 
-    it('#get', () => {
-      notificationsAPI.get({
-        page: 1,
-        status: 'read',
-        type: 'Conversation',
-        sortOrder: 'desc',
-      });
-      expect(axiosMock.get).toHaveBeenCalledWith('/api/v1/notifications', {
-        params: {
+    describe('#get', () => {
+      it('generates the API call if both params are available', () => {
+        notificationsAPI.get({
           page: 1,
-          status: 'read',
-          type: 'Conversation',
-          sort_order: 'desc',
-        },
+          status: 'snoozed',
+          type: 'read',
+          sortOrder: 'desc',
+        });
+        expect(axiosMock.get).toHaveBeenCalledWith('/api/v1/notifications', {
+          params: {
+            page: 1,
+            sort_order: 'desc',
+            includes: ['snoozed', 'read'],
+          },
+        });
+      });
+
+      it('generates the API call if one of the params are available', () => {
+        notificationsAPI.get({
+          page: 1,
+          type: 'read',
+          sortOrder: 'desc',
+        });
+        expect(axiosMock.get).toHaveBeenCalledWith('/api/v1/notifications', {
+          params: {
+            page: 1,
+            sort_order: 'desc',
+            includes: ['read'],
+          },
+        });
       });
     });
 

app/javascript/dashboard/components/widgets/WootWriter/Editor.vue

@@ -753,7 +753,7 @@ export default {
 }
 
 .ProseMirror-prompt {
-  @apply z-50 bg-slate-25 dark:bg-slate-700 rounded-md border border-solid border-slate-75 dark:border-slate-800;
+  @apply z-[9999] bg-slate-25 dark:bg-slate-700 rounded-md border border-solid border-slate-75 dark:border-slate-800 shadow-lg;
 
   h5 {
     @apply dark:text-slate-25 text-slate-800;

app/javascript/dashboard/store/modules/notifications/getters.js

@@ -1,4 +1,4 @@
-import { applyInboxPageFilters, sortComparator } from './helpers';
+import { sortComparator } from './helpers';
 
 export const getters = {
   getNotifications($state) {
@@ -6,11 +6,8 @@ export const getters = {
   },
   getFilteredNotifications: $state => filters => {
     const sortOrder = filters.sortOrder === 'desc' ? 'newest' : 'oldest';
-    const filteredNotifications = Object.values($state.records).filter(
-      notification => applyInboxPageFilters(notification, filters)
-    );
-    const sortedNotifications = filteredNotifications.sort((a, b) =>
-      sortComparator(a, b, sortOrder)
+    const sortedNotifications = Object.values($state.records).sort((n1, n2) =>
+      sortComparator(n1, n2, sortOrder)
     );
     return sortedNotifications;
   },

app/javascript/dashboard/store/modules/notifications/helpers.js

@@ -1,31 +1,3 @@
-export const filterByStatus = (snoozedUntil, filterStatus) =>
-  filterStatus === 'snoozed' ? !!snoozedUntil : !snoozedUntil;
-
-export const filterByType = (readAt, filterType) =>
-  filterType === 'read' ? !!readAt : !readAt;
-
-export const filterByTypeAndStatus = (
-  readAt,
-  snoozedUntil,
-  filterType,
-  filterStatus
-) => {
-  const shouldFilterByStatus = filterByStatus(snoozedUntil, filterStatus);
-  const shouldFilterByType = filterByType(readAt, filterType);
-  return shouldFilterByStatus && shouldFilterByType;
-};
-
-export const applyInboxPageFilters = (notification, filters) => {
-  const { status, type } = filters;
-  const { read_at: readAt, snoozed_until: snoozedUntil } = notification;
-
-  if (status && type)
-    return filterByTypeAndStatus(readAt, snoozedUntil, type, status);
-  if (status && !type) return filterByStatus(snoozedUntil, status);
-  if (!status && type) return filterByType(readAt, type);
-  return true;
-};
-
 const INBOX_SORT_OPTIONS = {
   newest: 'desc',
   oldest: 'asc',

app/javascript/dashboard/store/modules/specs/notifications/getters.spec.js

@@ -34,6 +34,8 @@ describe('#getters', () => {
       sortOrder: 'desc',
     };
     expect(getters.getFilteredNotifications(state)(filters)).toEqual([
+      { id: 1, read_at: '2024-02-07T11:42:39.988Z', snoozed_until: null },
+      { id: 2, read_at: null, snoozed_until: null },
       {
         id: 3,
         read_at: '2024-02-07T11:42:39.988Z',

app/javascript/dashboard/store/modules/specs/notifications/helpers.spec.js

@@ -1,10 +1,4 @@
-import {
-  filterByStatus,
-  filterByType,
-  filterByTypeAndStatus,
-  applyInboxPageFilters,
-  sortComparator,
-} from '../../notifications/helpers';
+import { sortComparator } from '../../notifications/helpers';
 
 const notifications = [
   {
@@ -45,126 +39,6 @@ const notifications = [
   },
 ];
 
-describe('#filterByStatus', () => {
-  it('returns the notifications with snoozed status', () => {
-    const filters = { status: 'snoozed' };
-    notifications.forEach(notification => {
-      expect(
-        filterByStatus(notification.snoozed_until, filters.status)
-      ).toEqual(notification.snoozed_until !== null);
-    });
-  });
-  it('returns true if the notification is snoozed', () => {
-    const filters = { status: 'snoozed' };
-    expect(
-      filterByStatus(notifications[3].snoozed_until, filters.status)
-    ).toEqual(true);
-  });
-  it('returns false if the notification is not snoozed', () => {
-    const filters = { status: 'snoozed' };
-    expect(
-      filterByStatus(notifications[2].snoozed_until, filters.status)
-    ).toEqual(false);
-  });
-});
-
-describe('#filterByType', () => {
-  it('returns the notifications with read status', () => {
-    const filters = { type: 'read' };
-    notifications.forEach(notification => {
-      expect(filterByType(notification.read_at, filters.type)).toEqual(
-        notification.read_at !== null
-      );
-    });
-  });
-  it('returns true if the notification is read', () => {
-    const filters = { type: 'read' };
-    expect(filterByType(notifications[0].read_at, filters.type)).toEqual(true);
-  });
-  it('returns false if the notification is not read', () => {
-    const filters = { type: 'read' };
-    expect(filterByType(notifications[1].read_at, filters.type)).toEqual(false);
-  });
-});
-
-describe('#filterByTypeAndStatus', () => {
-  it('returns the notifications with type and status', () => {
-    const filters = { type: 'read', status: 'snoozed' };
-    notifications.forEach(notification => {
-      expect(
-        filterByTypeAndStatus(
-          notification.read_at,
-          notification.snoozed_until,
-          filters.type,
-          filters.status
-        )
-      ).toEqual(
-        notification.read_at !== null && notification.snoozed_until !== null
-      );
-    });
-  });
-  it('returns true if the notification is read and snoozed', () => {
-    const filters = { type: 'read', status: 'snoozed' };
-    expect(
-      filterByTypeAndStatus(
-        notifications[4].read_at,
-        notifications[4].snoozed_until,
-        filters.type,
-        filters.status
-      )
-    ).toEqual(true);
-  });
-  it('returns false if the notification is not read and snoozed', () => {
-    const filters = { type: 'read', status: 'snoozed' };
-    expect(
-      filterByTypeAndStatus(
-        notifications[3].read_at,
-        notifications[3].snoozed_until,
-        filters.type,
-        filters.status
-      )
-    ).toEqual(false);
-  });
-});
-
-describe('#applyInboxPageFilters', () => {
-  it('returns the notifications with type and status', () => {
-    const filters = { type: 'read', status: 'snoozed' };
-    notifications.forEach(notification => {
-      expect(applyInboxPageFilters(notification, filters)).toEqual(
-        filterByTypeAndStatus(
-          notification.read_at,
-          notification.snoozed_until,
-          filters.type,
-          filters.status
-        )
-      );
-    });
-  });
-  it('returns the notifications with type only', () => {
-    const filters = { type: 'read', status: null };
-    notifications.forEach(notification => {
-      expect(applyInboxPageFilters(notification, filters)).toEqual(
-        filterByType(notification.read_at, filters.type)
-      );
-    });
-  });
-  it('returns the notifications with status only', () => {
-    const filters = { type: null, status: 'snoozed' };
-    notifications.forEach(notification => {
-      expect(applyInboxPageFilters(notification, filters)).toEqual(
-        filterByStatus(notification.snoozed_until, filters.status)
-      );
-    });
-  });
-  it('returns true if there are no filters', () => {
-    const filters = { type: null, status: null };
-    notifications.forEach(notification => {
-      expect(applyInboxPageFilters(notification, filters)).toEqual(true);
-    });
-  });
-});
-
 describe('#sortComparator', () => {
   it('returns the notifications sorted by newest', () => {
     const sortOrder = 'newest';

app/javascript/v3/components/Form/Input.vue

@@ -6,24 +6,29 @@
     :has-error="hasError"
     :error-message="errorMessage"
   >
+    <template #rightOfLabel>
+      <slot />
+    </template>
     <input
       :id="name"
       :name="name"
       :type="type"
       autocomplete="off"
+      :tabindex="tabindex"
       :required="required"
       :placeholder="placeholder"
       :data-testid="dataTestid"
       :value="value"
       :class="{
-        'focus:ring-red-600 ring-red-600': hasError,
-        'dark:ring-slate-600 dark:focus:ring-woot-500 ring-slate-200':
+        'focus:outline-red-600 outline-red-600 dark:focus:outline-red-600 dark:outline-red-600':
+          hasError,
+        'outline-slate-200 dark:outline-slate-600 dark:focus:outline-woot-500 focus:outline-woot-500':
           !hasError,
         'px-3 py-3': spacing === 'base',
         'px-3 py-2 mb-0': spacing === 'compact',
         'pl-9': icon,
       }"
-      class="block w-full border-none shadow-sm appearance-none rounded-xl outline outline-1 outline-slate-200 dark:outline-slate-200/20 focus:outline-none focus:outline-0 text-slate-900 dark:text-slate-100 placeholder:text-slate-400 focus:ring-2 focus:ring-woot-500 sm:text-sm sm:leading-6 dark:bg-slate-800"
+      class="block w-full border-none shadow-sm appearance-none rounded-xl outline outline-1 focus:outline-2 text-slate-900 dark:text-slate-100 placeholder:text-slate-400 sm:text-sm sm:leading-6 dark:bg-slate-800"
       @input="onInput"
       @blur="$emit('blur')"
     />
@@ -48,6 +53,10 @@ export default {
       type: String,
       default: 'text',
     },
+    tabindex: {
+      type: Number,
+      default: undefined,
+    },
     required: {
       type: Boolean,
       default: false,

app/javascript/v3/components/Form/Textarea.vue

@@ -0,0 +1,83 @@
+<template>
+  <with-label
+    :label="label"
+    :name="name"
+    :has-error="hasError"
+    :error-message="errorMessage"
+  >
+    <textarea
+      :id="name"
+      :name="name"
+      autocomplete="off"
+      :required="required"
+      :placeholder="placeholder"
+      :data-testid="dataTestid"
+      :value="value"
+      :rows="rows"
+      :class="{
+        'focus:outline-red-600 outline-red-600': hasError,
+        'dark:outline-slate-600 dark:focus:outline-woot-500 outline-slate-200 focus:outline-woot-500':
+          !hasError,
+        'resize-none': !allowResize,
+      }"
+      class="block w-full p-3 border-none rounded-xl shadow-sm appearance-none outline outline-1 focus:outline focus:outline-2 text-slate-900 dark:text-slate-100 placeholder:text-slate-400 bg-white dark:bg-slate-800"
+      @input="onInput"
+      @blur="$emit('blur')"
+    />
+  </with-label>
+</template>
+<script>
+import WithLabel from './WithLabel.vue';
+export default {
+  components: {
+    WithLabel,
+  },
+  props: {
+    label: {
+      type: String,
+      default: '',
+    },
+    name: {
+      type: String,
+      required: true,
+    },
+    required: {
+      type: Boolean,
+      default: false,
+    },
+    placeholder: {
+      type: String,
+      default: '',
+    },
+    value: {
+      type: [String, Number],
+      default: '',
+    },
+    rows: {
+      type: Number,
+      default: 3,
+    },
+    allowResize: {
+      type: Boolean,
+      default: true,
+    },
+    hasError: {
+      type: Boolean,
+      default: false,
+    },
+    errorMessage: {
+      type: String,
+      default: '',
+    },
+    dataTestid: {
+      type: String,
+      default: '',
+    },
+  },
+  methods: {
+    onInput(e) {
+      this.$emit('input', e.target.value);
+    },
+  },
+};
+</script>

app/javascript/v3/components/Form/WithLabel.vue

@@ -9,6 +9,7 @@
       <slot name="label">
         {{ label }}
       </slot>
+      <slot name="rightOfLabel" />
     </label>
     <div class="w-full">
       <div class="flex items-center relative w-full">

app/javascript/v3/views/login/Index.vue

@@ -46,6 +46,7 @@
             name="email_address"
             type="text"
             data-testid="email_input"
+            :tabindex="1"
             required
             :label="$t('LOGIN.EMAIL.LABEL')"
             :placeholder="$t('LOGIN.EMAIL.PLACEHOLDER')"
@@ -58,19 +59,25 @@
             name="password"
             data-testid="password_input"
             required
+            :tabindex="2"
             :label="$t('LOGIN.PASSWORD.LABEL')"
             :placeholder="$t('LOGIN.PASSWORD.PLACEHOLDER')"
             :has-error="$v.credentials.password.$error"
             @input="$v.credentials.password.$touch"
           >
             <p v-if="!globalConfig.disableUserProfileUpdate">
-              <router-link to="auth/reset/password" class="text-link">
+              <router-link
+                to="auth/reset/password"
+                class="text-link text-sm"
+                tabindex="4"
+              >
                 {{ $t('LOGIN.FORGOT_PASSWORD') }}
               </router-link>
             </p>
           </form-input>
           <submit-button
             :disabled="loginApi.showLoading"
+            :tabindex="3"
             :button-text="$t('LOGIN.SUBMIT')"
             :loading="loginApi.showLoading"
           />

app/jobs/notification/reopen_snoozed_notifications_job.rb

@@ -4,7 +4,7 @@ class Notification::ReopenSnoozedNotificationsJob < ApplicationJob
   def perform
     # rubocop:disable Rails/SkipsModelValidations
     Notification.where(snoozed_until: 3.days.ago..Time.current)
-                .update_all(snoozed_until: nil, updated_at: Time.current, last_activity_at: Time.current)
+                .update_all(snoozed_until: nil, updated_at: Time.current, last_activity_at: Time.current, read_at: nil)
     # rubocop:enable Rails/SkipsModelValidations
   end
 end

app/models/account.rb

@@ -111,11 +111,12 @@ class Account < ApplicationRecord
   end
 
   def inbound_email_domain
-    domain || GlobalConfig.get('MAILER_INBOUND_EMAIL_DOMAIN')['MAILER_INBOUND_EMAIL_DOMAIN'] || ENV.fetch('MAILER_INBOUND_EMAIL_DOMAIN', false)
+    domain.presence || GlobalConfig.get('MAILER_INBOUND_EMAIL_DOMAIN')['MAILER_INBOUND_EMAIL_DOMAIN'] || ENV.fetch('MAILER_INBOUND_EMAIL_DOMAIN',
+                                                                                                                   false)
   end
 
   def support_email
-    super || ENV.fetch('MAILER_SENDER_EMAIL') { GlobalConfig.get('MAILER_SUPPORT_EMAIL')['MAILER_SUPPORT_EMAIL'] }
+    super.presence || ENV.fetch('MAILER_SENDER_EMAIL') { GlobalConfig.get('MAILER_SUPPORT_EMAIL')['MAILER_SUPPORT_EMAIL'] }
   end
 
   def usage_limits

app/models/notification.rb

@@ -4,6 +4,7 @@
 #
 #  id                   :bigint           not null, primary key
 #  last_activity_at     :datetime
+#  meta                 :jsonb
 #  notification_type    :integer          not null
 #  primary_actor_type   :string           not null
 #  read_at              :datetime
@@ -95,13 +96,17 @@ class Notification < ApplicationRecord
   def push_message_title
     case notification_type
     when 'conversation_creation'
-      conversation_creation_message_content
+      I18n.t('notifications.notification_title.conversation_creation', display_id: conversation.display_id, inbox_name: primary_actor.inbox.name)
     when 'conversation_assignment'
       I18n.t('notifications.notification_title.conversation_assignment', display_id: conversation.display_id)
     when 'assigned_conversation_new_message', 'participating_conversation_new_message'
-      message_created_message_content
+      I18n.t(
+        'notifications.notification_title.assigned_conversation_new_message',
+        display_id: conversation.display_id,
+        content: content
+      )
     when 'conversation_mention'
-      mention_content
+      "[##{conversation&.display_id}] #{transform_user_mention_content content}"
     else
       ''
     end
@@ -111,18 +116,6 @@ class Notification < ApplicationRecord
     primary_actor
   end
 
-  def conversation_creation_message_content
-    "#{conversation.messages.first&.sender&.name}: #{content}"
-  end
-
-  def message_created_message_content
-    "#{secondary_actor&.sender&.name}: #{content}"
-  end
-
-  def mention_content
-    "#{secondary_actor&.sender&.name}: #{transform_user_mention_content(secondary_actor&.content&.truncate_words(10) || '')}"
-  end
-
   def content
     transform_user_mention_content(secondary_actor&.content&.truncate_words(10) || '')
   end

config/app.yml

@@ -1,5 +1,5 @@
 shared: &shared
-  version: '3.5.2'
+  version: '3.6.0'
 
 development:
   <<: *shared

db/migrate/20240215065844_add_meta_to_notifications.rb

@@ -0,0 +1,5 @@
+class AddMetaToNotifications < ActiveRecord::Migration[7.0]
+  def change
+    add_column :notifications, :meta, :jsonb, default: {}
+  end
+end

db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[7.0].define(version: 2024_02_07_103014) do
+ActiveRecord::Schema[7.0].define(version: 2024_02_15_065844) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "pg_stat_statements"
   enable_extension "pg_trgm"
@@ -750,6 +750,7 @@ ActiveRecord::Schema[7.0].define(version: 2024_02_07_103014) do
     t.datetime "updated_at", null: false
     t.datetime "snoozed_until"
     t.datetime "last_activity_at", default: -> { "CURRENT_TIMESTAMP" }
+    t.jsonb "meta", default: {}
     t.index ["account_id"], name: "index_notifications_on_account_id"
     t.index ["last_activity_at"], name: "index_notifications_on_last_activity_at"
     t.index ["primary_actor_type", "primary_actor_id"], name: "uniq_primary_actor_per_account_notifications"

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatwoot/chatwoot",
-  "version": "3.5.2",
+  "version": "3.6.0",
   "license": "MIT",
   "scripts": {
     "eslint": "eslint app/**/*.{js,vue}",

spec/controllers/api/v1/accounts/contacts_controller_spec.rb

@@ -50,8 +50,11 @@ RSpec.describe 'Contacts API', type: :request do
 
         expect(response).to have_http_status(:success)
         response_body = response.parsed_body
-        expect(response_body['payload'].first['email']).to eq(contact.email)
-        expect(response_body['payload'].first['contact_inboxes'].blank?).to be(true)
+
+        contact_emails = response_body['payload'].pluck('email')
+        contact_inboxes = response_body['payload'].pluck('contact_inboxes').flatten.compact
+        expect(contact_emails).to include(contact.email)
+        expect(contact_inboxes).to eq([])
       end
 
       it 'returns all contacts with company name desc order' do

spec/factories/notifications.rb

@@ -6,5 +6,15 @@ FactoryBot.define do
     notification_type { 'conversation_assignment' }
     user
     account
+    read_at { nil }
+    snoozed_until { nil }
+  end
+
+  trait :read do
+    read_at { DateTime.now.utc - 3.days }
+  end
+
+  trait :snoozed do
+    snoozed_until { DateTime.now.utc + 3.days }
   end
 end

spec/finders/conversation_finder_spec.rb

@@ -146,6 +146,30 @@ describe ConversationFinder do
       end
     end
 
+    context 'with updated_within' do
+      let(:params) { { updated_within: 20, assignee_type: 'unassigned', sort_by: 'created_at_asc' } }
+
+      it 'filters based on params, sort order but returns all conversations without pagination with in time range' do
+        # value of updated_within is in seconds
+        # write spec based on that
+        conversations = create_list(:conversation, 50, account: account,
+                                                       inbox: inbox, assignee: nil,
+                                                       updated_at: Time.now.utc - 30.seconds,
+                                                       created_at: Time.now.utc - 30.seconds)
+        # update updated_at of 27 conversations to be with in 20 seconds
+        conversations[0..27].each do |conversation|
+          conversation.update(updated_at: Time.now.utc - 10.seconds)
+        end
+        result = conversation_finder.perform
+        # pagination is not applied
+        # filters are applied
+        # modified conversations + 1 conversation created during set up
+        expect(result[:conversations].length).to be 29
+        # ensure that the conversations are sorted by created_at
+        expect(result[:conversations].first.created_at).to be < result[:conversations].last.created_at
+      end
+    end
+
     context 'with pagination' do
       let(:params) { { status: 'open', assignee_type: 'me', page: 1 } }
 

spec/finders/notification_finder_spec.rb

@@ -1,103 +1,79 @@
 require 'rails_helper'
 
-describe NotificationFinder do
-  subject(:notification_finder) { described_class.new(user, account, params) }
-
+RSpec.describe NotificationFinder do
   let!(:account) { create(:account) }
   let!(:user) { create(:user, account: account) }
+  let(:notification_finder) { described_class.new(user, account, params) }
 
   before do
-    create(:notification, account: account, user: user, updated_at: DateTime.now.utc + 1.day, last_activity_at: DateTime.now.utc + 1.day,
-                          read_at: DateTime.now.utc)
-    create(:notification, account: account, user: user, snoozed_until: DateTime.now.utc + 3.days, updated_at: DateTime.now.utc,
-                          last_activity_at: DateTime.now.utc)
-    create(:notification, account: account, user: user, updated_at: DateTime.now.utc + 2.days, last_activity_at: DateTime.now.utc + 2.days)
-    create(:notification, account: account, user: user, updated_at: DateTime.now.utc + 4.days, last_activity_at: DateTime.now.utc + 4.days,
-                          notification_type: :conversation_creation, read_at: DateTime.now.utc)
-    create(:notification, account: account, user: user, updated_at: DateTime.now.utc + 5.days, last_activity_at: DateTime.now.utc + 5.days,
-                          notification_type: :conversation_mention)
-    create(:notification, account: account, user: user, updated_at: DateTime.now.utc + 6.days, last_activity_at: DateTime.now.utc + 6.days,
-                          notification_type: :participating_conversation_new_message)
+    create(:notification, :snoozed, account: account, user: user)
+    create_list(:notification, 2, :read, account: account, user: user)
+    create_list(:notification, 3, account: account, user: user)
   end
 
-  describe '#perform' do
-    context 'when params are empty' do
+  describe '#notifications' do
+    subject { notification_finder.notifications }
+
+    context 'with default params (empty)' do
       let(:params) { {} }
 
-      it 'returns all the notifications' do
-        result = notification_finder.perform
-        expect(result.length).to be 6
-      end
-
-      it 'orders notifications by last activity at' do
-        result = notification_finder.perform
-        expect(result.first.last_activity_at).to be > result.last.last_activity_at
-      end
-
-      it 'returns unread count' do
-        result = notification_finder.unread_count
-        expect(result).to be 4
-      end
-
-      it 'returns count' do
-        result = notification_finder.count
-        expect(result).to be 6
+      it 'returns all unread and unsnoozed notifications, ordered by last activity' do
+        expect(subject.size).to eq(3)
+        expect(subject).to match_array(subject.sort_by(&:last_activity_at).reverse)
       end
     end
 
-    context 'when snoozed param is passed' do
-      let(:params) { { status: 'snoozed' } }
+    context 'with params including read and snoozed statuses' do
+      let(:params) { { includes: %w[read snoozed] } }
 
-      it 'returns only snoozed notifications' do
-        result = notification_finder.perform
-        expect(result.length).to be 1
-      end
-
-      it 'returns unread count' do
-        result = notification_finder.unread_count
-        expect(result).to be 1
-      end
-
-      it 'returns count' do
-        result = notification_finder.count
-        expect(result).to be 1
+      it 'returns all notifications, including read and snoozed' do
+        expect(subject.size).to eq(6)
       end
     end
 
-    context 'when type read param is passed' do
-      let(:params) { { type: 'read' } }
+    context 'with params including only read status' do
+      let(:params) { { includes: ['read'] } }
 
-      it 'returns only read notifications' do
-        result = notification_finder.perform
-        expect(result.length).to be 2
-      end
-
-      it 'returns count' do
-        result = notification_finder.count
-        expect(result).to be 2
+      it 'returns all notifications expect the snoozed' do
+        expect(subject.size).to eq(5)
       end
     end
 
-    context 'when type read and snoozed param is passed' do
-      let(:params) { { type: 'read', status: 'snoozed' } }
+    context 'with params including only snoozed status' do
+      let(:params) { { includes: ['snoozed'] } }
 
-      it 'returns only read notifications' do
-        result = notification_finder.perform
-        expect(result.length).to be 0
-      end
-
-      it 'returns count' do
-        result = notification_finder.count
-        expect(result).to be 0
+      it 'rreturns all notifications only expect the read' do
+        expect(subject.size).to eq(4)
       end
     end
 
-    context 'when sort order is passed' do
+    context 'with ascending sort order' do
       let(:params) { { sort_order: :asc } }
 
-      it 'returns notifications in ascending order' do
-        result = notification_finder.perform
-        expect(result.first.last_activity_at).to be < result.last.last_activity_at
+      it 'returns notifications in ascending order by last activity' do
+        expect(subject.first.last_activity_at).to be < subject.last.last_activity_at
+      end
+    end
+  end
+
+  describe 'counts' do
+    subject { notification_finder }
+
+    context 'without specific filters' do
+      let(:params) { {} }
+
+      it 'correctly reports unread and total counts' do
+        expect(subject.unread_count).to eq(3)
+        expect(subject.count).to eq(3)
+      end
+    end
+
+    context 'with filters applied' do
+      let(:params) { { includes: %w[read snoozed] } }
+
+      it 'adjusts counts based on included statuses' do
+        expect(subject.unread_count).to eq(4)
+        expect(subject.count).to eq(6)
       end
     end
   end

spec/jobs/notification/reopen_snoozed_notifications_job_spec.rb

@@ -17,6 +17,7 @@ RSpec.describe Notification::ReopenSnoozedNotificationsJob do
       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
     end
   end
 end

spec/models/account_spec.rb

@@ -47,6 +47,56 @@ RSpec.describe Account do
     end
   end
 
+  describe 'inbound_email_domain' do
+    let(:account) { create(:account) }
+
+    it 'returns the domain from inbox if inbox value is present' do
+      account.update(domain: 'test.com')
+      with_modified_env MAILER_INBOUND_EMAIL_DOMAIN: 'test2.com' do
+        expect(account.inbound_email_domain).to eq('test.com')
+      end
+    end
+
+    it 'returns the domain from ENV if inbox value is nil' do
+      account.update(domain: nil)
+      with_modified_env MAILER_INBOUND_EMAIL_DOMAIN: 'test.com' do
+        expect(account.inbound_email_domain).to eq('test.com')
+      end
+    end
+
+    it 'returns the domain from ENV if inbox value is empty string' do
+      account.update(domain: '')
+      with_modified_env MAILER_INBOUND_EMAIL_DOMAIN: 'test.com' do
+        expect(account.inbound_email_domain).to eq('test.com')
+      end
+    end
+  end
+
+  describe 'support_email' do
+    let(:account) { create(:account) }
+
+    it 'returns the support email from inbox if inbox value is present' do
+      account.update(support_email: 'support@chatwoot.com')
+      with_modified_env MAILER_SENDER_EMAIL: 'hello@chatwoot.com' do
+        expect(account.support_email).to eq('support@chatwoot.com')
+      end
+    end
+
+    it 'returns the support email from ENV if inbox value is nil' do
+      account.update(support_email: nil)
+      with_modified_env MAILER_SENDER_EMAIL: 'hello@chatwoot.com' do
+        expect(account.support_email).to eq('hello@chatwoot.com')
+      end
+    end
+
+    it 'returns the support email from ENV if inbox value is empty string' do
+      account.update(support_email: '')
+      with_modified_env MAILER_SENDER_EMAIL: 'hello@chatwoot.com' do
+        expect(account.support_email).to eq('hello@chatwoot.com')
+      end
+    end
+  end
+
   context 'when after_destroy is called' do
     it 'conv_dpid_seq and camp_dpid_seq_ are deleted' do
       account = create(:account)

spec/models/notification_spec.rb

@@ -23,10 +23,9 @@ RSpec.describe Notification do
 
   context 'when push_title is called' do
     it 'returns appropriate title suited for the notification type conversation_creation' do
-      conversation = create(:conversation)
-      message = create(:message, sender: create(:user), content: Faker::Lorem.paragraphs(number: 2), conversation: conversation)
-      notification = create(:notification, notification_type: 'conversation_creation', primary_actor: conversation)
-      expect(notification.push_message_title).to eq "#{message.sender.name}: #{message.content}"
+      notification = create(:notification, notification_type: 'conversation_creation')
+      expect(notification.push_message_title).to eq "[New conversation] - ##{notification.primary_actor.display_id} has\
+ been created in #{notification.primary_actor.inbox.name}"
     end
 
     it 'returns appropriate title suited for the notification type conversation_assignment' do
@@ -40,7 +39,8 @@ RSpec.describe Notification do
       notification = create(:notification, notification_type: 'assigned_conversation_new_message', primary_actor: message.conversation,
                                            secondary_actor: message)
 
-      expect(notification.push_message_title).to eq "#{message.sender.name}: #{message.content.truncate_words(10)}"
+      expect(notification.push_message_title).to eq "[New message] - ##{notification.conversation.display_id} \
+#{message.content.truncate_words(10)}"
     end
 
     it 'returns appropriate title suited for the notification type assigned_conversation_new_message when attachment message' do
@@ -100,7 +100,8 @@ Hey @John, @Alisha Peter can you check this ticket?"
                   content: 'Hey [@John](mention://user/1/john), [@Alisha Peter](mention://user/2/alisha) can you check this ticket?'
       )
       notification = create(:notification, notification_type: 'conversation_mention', primary_actor: message.conversation, secondary_actor: message)
-      expect(notification.push_message_title).to eq "#{message.sender.name}: Hey @John, @Alisha Peter can you check this ticket?"
+
+      expect(notification.push_message_title).to eq "[##{message.conversation.display_id}] Hey @John, @Alisha Peter can you check this ticket?"
     end
 
     it 'returns appropriate title suited for the notification type conversation_mention if username contains white space' do
@@ -110,7 +111,7 @@ Hey @John, @Alisha Peter can you check this ticket?"
                   content: 'Hey [@John Peter](mention://user/1/john%20K) please check this?'
       )
       notification = create(:notification, notification_type: 'conversation_mention', primary_actor: message.conversation, secondary_actor: message)
-      expect(notification.push_message_title).to eq "#{message.sender.name}: Hey @John Peter please check this?"
+      expect(notification.push_message_title).to eq "[##{message.conversation.display_id}] Hey @John Peter please check this?"
     end
 
     it 'calls remove duplicate notification job' do