Merge branch 'develop' into feat/read-only-token

app/javascript/dashboard/store/modules/contacts/actions.js

@@ -312,10 +312,14 @@ export const actions = {
     commit(types.CLEAR_CONTACT_FILTERS);
   },
 
-  initiateCall: async ({ commit }, { contactId, inboxId }) => {
+  initiateCall: async ({ commit }, { contactId, inboxId, conversationId }) => {
     commit(types.SET_CONTACT_UI_FLAG, { isInitiatingCall: true });
     try {
-      const response = await ContactAPI.initiateCall(contactId, inboxId);
+      const response = await ContactAPI.initiateCall(
+        contactId,
+        inboxId,
+        conversationId
+      );
       commit(types.SET_CONTACT_UI_FLAG, { isInitiatingCall: false });
       return response.data;
     } catch (error) {

app/javascript/dashboard/store/modules/conversationStats.js

@@ -25,7 +25,7 @@ const fetchMetaData = async (commit, params) => {
   }
 };
 
-const debouncedFetchMetaData = debounce(fetchMetaData, 500, false, 1500);
+const debouncedFetchMetaData = debounce(fetchMetaData, 500, false, 2000);
 const longDebouncedFetchMetaData = debounce(fetchMetaData, 5000, false, 10000);
 const superLongDebouncedFetchMetaData = debounce(
   fetchMetaData,
@@ -36,7 +36,7 @@ const superLongDebouncedFetchMetaData = debounce(
 
 export const actions = {
   get: async ({ commit, state: $state }, params) => {
-    if ($state.allCount > 5000) {
+    if ($state.allCount > 2000) {
       superLongDebouncedFetchMetaData(commit, params);
     } else if ($state.allCount > 100) {
       longDebouncedFetchMetaData(commit, params);

app/javascript/dashboard/store/modules/conversationUnreadCounts.js

@@ -0,0 +1,70 @@
+import ConversationAPI from '../../api/conversations';
+import types from '../mutation-types';
+
+export const state = {
+  inboxes: {},
+  labels: {},
+  teams: {},
+};
+
+const normalizeCounts = counts => {
+  return Object.entries(counts || {}).reduce((result, [id, count]) => {
+    const parsedCount = Number(count);
+    if (Number.isFinite(parsedCount) && parsedCount > 0) {
+      result[String(id)] = parsedCount;
+    }
+
+    return result;
+  }, {});
+};
+
+export const getters = {
+  getInboxUnreadCount: $state => inboxId => {
+    return $state.inboxes[String(inboxId)] || 0;
+  },
+  getLabelUnreadCount: $state => labelId => {
+    return $state.labels[String(labelId)] || 0;
+  },
+  getTeamUnreadCount: $state => teamId => {
+    return $state.teams[String(teamId)] || 0;
+  },
+  getInboxUnreadCounts($state) {
+    return $state.inboxes;
+  },
+  getLabelUnreadCounts($state) {
+    return $state.labels;
+  },
+  getTeamUnreadCounts($state) {
+    return $state.teams;
+  },
+};
+
+export const actions = {
+  get: async function getUnreadCounts({ commit }) {
+    try {
+      const response = await ConversationAPI.getUnreadCounts();
+      commit(types.SET_CONVERSATION_UNREAD_COUNTS, response.data.payload);
+    } catch (error) {
+      // Ignore errors so the sidebar can continue rendering without badges.
+    }
+  },
+  clear({ commit }) {
+    commit(types.SET_CONVERSATION_UNREAD_COUNTS, {});
+  },
+};
+
+export const mutations = {
+  [types.SET_CONVERSATION_UNREAD_COUNTS]($state, payload = {}) {
+    $state.inboxes = normalizeCounts(payload.inboxes);
+    $state.labels = normalizeCounts(payload.labels);
+    $state.teams = normalizeCounts(payload.teams);
+  },
+};
+
+export default {
+  namespaced: true,
+  state,
+  getters,
+  actions,
+  mutations,
+};

app/javascript/dashboard/store/modules/conversations/actions.js

@@ -329,12 +329,21 @@ const actions = {
       });
       commit(types.ADD_CONVERSATION_ATTACHMENTS, message);
     }
-    handleVoiceCallCreated(message, rootGetters?.getCurrentUserID);
+    handleVoiceCallCreated(
+      message,
+      rootGetters?.getCurrentUserID,
+      rootGetters?.getCurrentUserAvailability
+    );
   },
 
   updateMessage({ commit, rootGetters }, message) {
     commit(types.ADD_MESSAGE, message);
-    handleVoiceCallUpdated(commit, message, rootGetters?.getCurrentUserID);
+    handleVoiceCallUpdated(
+      commit,
+      message,
+      rootGetters?.getCurrentUserID,
+      rootGetters?.getCurrentUserAvailability
+    );
   },
 
   deleteMessage: async function deleteLabels(

app/javascript/dashboard/store/modules/specs/conversationUnreadCounts/actions.spec.js

@@ -0,0 +1,53 @@
+import axios from 'axios';
+import { actions } from '../../conversationUnreadCounts';
+import types from '../../../mutation-types';
+
+const commit = vi.fn();
+global.axios = axios;
+vi.mock('axios');
+
+describe('#actions', () => {
+  beforeEach(() => {
+    commit.mockClear();
+    axios.get.mockReset();
+  });
+
+  describe('#get', () => {
+    it('commits unread counts when API is successful', async () => {
+      const payload = {
+        inboxes: { 1: '2' },
+        labels: { 3: 4 },
+        teams: { 5: 6 },
+      };
+      axios.get.mockResolvedValue({ data: { payload } });
+
+      await actions.get({ commit });
+
+      expect(axios.get).toHaveBeenCalledWith(
+        '/api/v1/conversations/unread_counts'
+      );
+      expect(commit.mock.calls).toEqual([
+        [types.SET_CONVERSATION_UNREAD_COUNTS, payload],
+      ]);
+    });
+
+    it('does not commit when API fails', async () => {
+      axios.get.mockRejectedValue({ message: 'Incorrect header' });
+
+      await actions.get({ commit });
+
+      expect(commit).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('#clear', () => {
+    it('clears unread counts', () => {
+      actions.clear({ commit });
+
+      expect(commit).toHaveBeenCalledWith(
+        types.SET_CONVERSATION_UNREAD_COUNTS,
+        {}
+      );
+    });
+  });
+});

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

@@ -0,0 +1,51 @@
+import { getters } from '../../conversationUnreadCounts';
+
+describe('#getters', () => {
+  it('returns inbox unread count by id', () => {
+    const state = {
+      inboxes: { 1: 2 },
+      labels: {},
+      teams: {},
+    };
+
+    expect(getters.getInboxUnreadCount(state)(1)).toBe(2);
+    expect(getters.getInboxUnreadCount(state)('1')).toBe(2);
+    expect(getters.getInboxUnreadCount(state)(2)).toBe(0);
+  });
+
+  it('returns label unread count by id', () => {
+    const state = {
+      inboxes: {},
+      labels: { 3: 4 },
+      teams: {},
+    };
+
+    expect(getters.getLabelUnreadCount(state)(3)).toBe(4);
+    expect(getters.getLabelUnreadCount(state)('3')).toBe(4);
+    expect(getters.getLabelUnreadCount(state)(4)).toBe(0);
+  });
+
+  it('returns team unread count by id', () => {
+    const state = {
+      inboxes: {},
+      labels: {},
+      teams: { 5: 6 },
+    };
+
+    expect(getters.getTeamUnreadCount(state)(5)).toBe(6);
+    expect(getters.getTeamUnreadCount(state)('5')).toBe(6);
+    expect(getters.getTeamUnreadCount(state)(6)).toBe(0);
+  });
+
+  it('returns unread count maps', () => {
+    const state = {
+      inboxes: { 1: 2 },
+      labels: { 3: 4 },
+      teams: { 5: 6 },
+    };
+
+    expect(getters.getInboxUnreadCounts(state)).toEqual({ 1: 2 });
+    expect(getters.getLabelUnreadCounts(state)).toEqual({ 3: 4 });
+    expect(getters.getTeamUnreadCounts(state)).toEqual({ 5: 6 });
+  });
+});

app/javascript/dashboard/store/modules/specs/conversationUnreadCounts/mutations.spec.js

@@ -0,0 +1,48 @@
+import types from '../../../mutation-types';
+import { mutations } from '../../conversationUnreadCounts';
+
+describe('#mutations', () => {
+  describe('#SET_CONVERSATION_UNREAD_COUNTS', () => {
+    it('normalizes unread count payload', () => {
+      const state = { inboxes: {}, labels: {}, teams: {} };
+
+      mutations[types.SET_CONVERSATION_UNREAD_COUNTS](state, {
+        inboxes: {
+          1: '2',
+          2: 0,
+          3: 'invalid',
+        },
+        labels: {
+          4: 5,
+          5: -1,
+        },
+        teams: {
+          6: '7',
+          7: 0,
+        },
+      });
+
+      expect(state).toEqual({
+        inboxes: { 1: 2 },
+        labels: { 4: 5 },
+        teams: { 6: 7 },
+      });
+    });
+
+    it('clears counts when payload is empty', () => {
+      const state = {
+        inboxes: { 1: 2 },
+        labels: { 4: 5 },
+        teams: { 6: 7 },
+      };
+
+      mutations[types.SET_CONVERSATION_UNREAD_COUNTS](state, {});
+
+      expect(state).toEqual({
+        inboxes: {},
+        labels: {},
+        teams: {},
+      });
+    });
+  });
+});