@zenify-omni/chat-ui-react-js 0.1.0

package/utils/chat-actions.js

@@ -0,0 +1,414 @@
+import useChatStore from "../store/chat-store.js";
+import { DistributionLogSource } from "@zenify-omni/chat-js/constants/distribution-log.js";
+import {
+  getClosedSessionPayload,
+  getReceivedSessionPayload,
+  getTabStatusFromChat,
+  getTabStatusFromFilterChat
+} from "../store/chat-store-helpers.js";
+import {
+  buildChatMessage,
+  ChatFilterAssignStatus,
+  MessageType
+} from "@zenify-omni/chat-js/constants/chat-message.js";
+import { queryClient } from "../config/runtime.js";
+import { isChatVisible, navigate } from "../config/navigation.js";
+import { getChatRoomDetail, getChatRoomList } from "@zenify-omni/chat-js/api/chatroom.js";
+import QUERY_KEY from "@zenify-omni/chat-js/constants/use-query-key.js";
+import {
+  createConcurrencyLimiter,
+  createSingleFlight
+} from "@zenify-omni/chat-js/utils/concurrency-limiter.js";
+import { buildQueryParams } from "../components/chat-route/chat-list/util.js";
+import { getUser } from "@zenify-omni/chat-js/utils/auth.js";
+import { PRE_LOGOUT_EVENT } from "@zenify-omni/chat-js/constants/events.js";
+const roomDetailLimiter = createConcurrencyLimiter(4);
+const roomDetailSingleFlight = createSingleFlight();
+const SOURCE_TO_DIST_LOG = {
+  close: DistributionLogSource.CLOSE_CHAT,
+  receive: DistributionLogSource.MARK_RECEIVED,
+  reopen: DistributionLogSource.REOPEN_CHAT
+};
+function appendOptimisticDistributionLog(chatRoomId, action, actorName) {
+  const source = SOURCE_TO_DIST_LOG[action];
+  if (!source || !chatRoomId) return;
+  const entry = {
+    _id: `optimistic-${Date.now()}`,
+    metadata: { source },
+    action_by_name: actorName,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    content: null
+  };
+  queryClient.setQueriesData(
+    { queryKey: [QUERY_KEY.GET_DISTRIBUTION_LOGS, chatRoomId], exact: false },
+    (old) => {
+      if (!old?.pages) return old;
+      return {
+        ...old,
+        pages: [
+          { ...old.pages[0], items: [entry, ...old.pages[0]?.items ?? []] },
+          ...old.pages.slice(1)
+        ]
+      };
+    }
+  );
+}
+const limitedGetChatRoomDetail = (roomId, params) => roomDetailSingleFlight(
+  roomId,
+  () => roomDetailLimiter(() => getChatRoomDetail(roomId, params))
+);
+const isChatListSearching = () => !!useChatStore.getState().filterState?.keyword?.trim();
+const MAX_ROOMS_PER_BATCH = 200;
+const hasSession = () => !!getUser()?.token;
+async function appendChatsByRoomIds(roomIds, patchByRoomId = null) {
+  if (!roomIds?.length) return;
+  if (!hasSession()) return;
+  const chatStore = useChatStore.getState();
+  const params = {
+    ...buildQueryParams(chatStore.filterState || {}),
+    room_ids: roomIds.join(","),
+    // Mặc định của BE là 10 (chat-room.service.ts#findMany) nên phải nói rõ,
+    // không thì batch lớn bị cắt cụt và những room bị cắt sẽ không bao giờ
+    // được thêm vào list.
+    limit: roomIds.length
+  };
+  const { data } = await getChatRoomList({ params });
+  const chats = data?.items || [];
+  if (!chats.length) return;
+  const chatsByTab = /* @__PURE__ */ new Map();
+  chats.forEach((chat) => {
+    const tab = getTabStatusFromFilterChat(chat);
+    if (!chatsByTab.has(tab)) chatsByTab.set(tab, []);
+    chatsByTab.get(tab).push({
+      ...chat,
+      ...tab === ChatFilterAssignStatus.Closed ? getClosedSessionPayload(chat) : getReceivedSessionPayload(chat.is_received),
+      ...patchByRoomId?.get(String(chat._id)) || {}
+    });
+  });
+  chatsByTab.forEach((tabChats, tab) => {
+    chatStore.appendChats({ tab, chats: tabChats });
+  });
+}
+async function addUnhiddenChats(roomIds) {
+  if (!roomIds?.length) return;
+  if (!isChatVisible()) return;
+  if (isChatListSearching()) return;
+  try {
+    await appendChatsByRoomIds(roomIds.slice(0, MAX_ROOMS_PER_BATCH));
+  } catch (error) {
+    console.error("addUnhiddenChats: fetch chat rooms failed", error);
+  }
+}
+const PENDING_ROOMS_FLUSH_MS = 5e3;
+const pendingRooms = /* @__PURE__ */ new Map();
+let pendingRoomsTimer = null;
+const isOnChatRoute = () => isChatVisible();
+const isRoomInList = (roomId) => useChatStore.getState().chatList.some((chat) => chat._id === roomId);
+async function flushPendingRooms() {
+  pendingRoomsTimer = null;
+  if (pendingRooms.size === 0) return;
+  if (!hasSession() || !isOnChatRoute() || isChatListSearching()) {
+    pendingRooms.clear();
+    return;
+  }
+  const batch = /* @__PURE__ */ new Map();
+  for (const [roomId, patch] of pendingRooms) {
+    if (batch.size >= MAX_ROOMS_PER_BATCH) break;
+    batch.set(roomId, patch);
+  }
+  batch.forEach((_, roomId) => pendingRooms.delete(roomId));
+  if (pendingRooms.size > 0 && !pendingRoomsTimer) {
+    pendingRoomsTimer = setTimeout(flushPendingRooms, PENDING_ROOMS_FLUSH_MS);
+  }
+  const roomIds = [...batch.keys()].filter((roomId) => !isRoomInList(roomId));
+  if (!roomIds.length) return;
+  try {
+    await appendChatsByRoomIds(roomIds, batch);
+  } catch (error) {
+    console.error("flushPendingRooms: fetch chat rooms failed", error);
+  }
+}
+function queueRoomForChatList(roomId, patch = null) {
+  if (!roomId) return;
+  if (!hasSession()) return;
+  if (!isOnChatRoute() || isChatListSearching()) return;
+  if (isRoomInList(roomId)) return;
+  pendingRooms.set(roomId, {
+    ...pendingRooms.get(roomId) || {},
+    ...patch || {}
+  });
+  if (!pendingRoomsTimer) {
+    pendingRoomsTimer = setTimeout(flushPendingRooms, PENDING_ROOMS_FLUSH_MS);
+  }
+}
+document.addEventListener(PRE_LOGOUT_EVENT, teardownPendingRoomsOnLogout);
+const handledActions = /* @__PURE__ */ new Map();
+const DEDUP_TTL = 15e3;
+const buildKey = (action, roomId, chatterId) => `${action}::${roomId}::${chatterId}`;
+const markReceiveHandled = (roomId, chatterId) => markActionHandled(MessageType.ACTION_RECEIVE, roomId, chatterId);
+const isReceiveHandled = (roomId, chatterId) => isActionHandled(MessageType.ACTION_RECEIVE, roomId, chatterId);
+const clearReceiveHandled = (roomId, chatterId) => clearActionHandled(MessageType.ACTION_RECEIVE, roomId, chatterId);
+const isJoinHandled = (roomId, chatterId) => isActionHandled(MessageType.ACTION_JOIN, roomId, chatterId);
+async function applyReopenedChat(data) {
+  const chatStore = useChatStore.getState();
+  const roomId = data.room_id;
+  appendOptimisticDistributionLog(roomId, "reopen", data.chatter_name);
+  const chat = chatStore.chatList.find((x) => x._id === roomId);
+  if (!chat) {
+    if (!isChatVisible()) return;
+    const detail = await addNewChat({ chatRoomId: roomId });
+    if (detail && roomId === useChatStore.getState().currentChatId) {
+      chatStore.resetLastRefreshTimeTicketPage();
+    }
+    return;
+  }
+  chatStore.reopenChat(roomId, {
+    is_received: data.session?.is_received || false,
+    last_msg: {
+      text: data.content.text,
+      type: data.content.type,
+      time: data.created_at,
+      session_id: data.session_id
+    }
+  });
+  const currentChatId = chatStore.currentChatId;
+  const isLoaded = roomId === currentChatId || !!chatStore.loadedRooms[roomId];
+  if (isLoaded) {
+    const message = buildChatMessage({
+      id: data._id,
+      roomId: data.room_id,
+      tenantId: data.tenant_id,
+      source: data.source,
+      chatterId: data.chatter_id,
+      chatterName: data.chatter_name,
+      chatterType: data.chatter_type,
+      type: MessageType.ACTION_REOPEN,
+      status: data.status,
+      createdAt: data.created_at,
+      updatedAt: data.updated_at,
+      content: data.content
+    });
+    chatStore.addNewMessage(roomId, message);
+  }
+  if (roomId === currentChatId) {
+    chatStore.resetLastRefreshTimeTicketPage();
+  }
+}
+function getMetricElapsedSeconds(metric, now) {
+  const { started_at, schedule_id } = metric;
+  if (!started_at) return 0;
+  const periods = schedule_id != null ? queryClient.getQueryData([
+    QUERY_KEY.GET_LIST_SCHEDULE_PERIOD,
+    schedule_id
+  ])?.periods || [] : [];
+  return periods.length > 0 ? calculateWorkingSeconds(started_at, now, periods) : Math.floor((now.getTime() - new Date(started_at).getTime()) / 1e3);
+}
+function getStoppedStatusForRunningMetric(metric, now) {
+  const elapsed = getMetricElapsedSeconds(metric, now);
+  return elapsed > (metric.target_value || 0) ? SlaMetricStatus.COMPLETED_LATE : SlaMetricStatus.MET;
+}
+function applyEndedChat(data) {
+  const chatStore = useChatStore.getState();
+  const roomId = data.room_id;
+  clearClosedRoomSla(roomId);
+  appendOptimisticDistributionLog(roomId, "close", data.chatter_name);
+  const chat = chatStore.chatList.find((x) => x._id === roomId);
+  if (!chat) return;
+  chatStore.transitionChatTab(
+    getTabStatusFromChat(chat),
+    ChatFilterAssignStatus.Closed,
+    chat
+  );
+  chatStore.moveChat({
+    roomId,
+    payload: {
+      ...getClosedSessionPayload(),
+      last_msg: {
+        text: data.content.text,
+        type: data.content.type,
+        time: data.created_at,
+        session_id: data.session_id
+      }
+    }
+  });
+  const message = buildChatMessage({
+    id: data._id,
+    roomId: data.room_id,
+    tenantId: data.tenant_id,
+    source: data.source,
+    chatterId: data.chatter_id,
+    chatterName: data.chatter_name,
+    chatterType: data.chatter_type,
+    type: MessageType.ACTION_END,
+    status: data.status,
+    createdAt: data.created_at,
+    updatedAt: data.updated_at,
+    content: data.content
+  });
+  const currentChatId = chatStore.currentChatId;
+  const isLoaded = roomId === currentChatId || !!chatStore.loadedRooms[roomId];
+  if (isLoaded) {
+    chatStore.addNewMessage(roomId, message);
+  }
+  if (currentChatId === roomId && isChatVisible()) {
+    navigate({ to: "/chat" });
+  }
+}
+async function applyJoinedChat(data) {
+  const chatStore = useChatStore.getState();
+  const roomId = data.room_id;
+  const chat = chatStore.chatList.find((x) => x._id === roomId);
+  if (!chat) {
+    if (!isChatVisible()) return;
+    const detail = await addNewChat({ chatRoomId: roomId });
+    if (detail && roomId === useChatStore.getState().currentChatId) {
+      chatStore.resetLastRefreshTimeTicketPage();
+    }
+    return;
+  }
+  chatStore.updateChatDetail(roomId, {
+    last_msg: {
+      text: data.content.text,
+      type: data.content.type,
+      time: data.created_at,
+      session_id: data.session_id
+    }
+  });
+  const message = buildChatMessage({
+    id: data._id,
+    roomId: data.room_id,
+    tenantId: data.tenant_id,
+    source: data.source,
+    chatterId: data.chatter_id,
+    chatterName: data.chatter_name,
+    chatterType: data.chatter_type,
+    type: data.content.type,
+    status: data.status,
+    createdAt: data.created_at,
+    updatedAt: data.updated_at,
+    content: data.content
+  });
+  const currentChatId = chatStore.currentChatId;
+  const isLoaded = roomId === currentChatId || !!chatStore.loadedRooms[roomId];
+  if (isLoaded) {
+    chatStore.addNewMessage(roomId, message);
+  }
+  if (roomId === currentChatId) {
+    chatStore.resetLastRefreshTimeTicketPage();
+  }
+}
+async function addNewChat({ chatRoomId }) {
+  const chatStore = useChatStore.getState();
+  const params = buildQueryParams(chatStore.filterState || {});
+  try {
+    const { data: chatRoomDetail } = await limitedGetChatRoomDetail(
+      chatRoomId,
+      params
+    );
+    if (!chatRoomDetail) return null;
+    const tab = getTabStatusFromChat(chatRoomDetail);
+    chatStore.appendChats({ tab, chats: [chatRoomDetail] });
+    return chatRoomDetail;
+  } catch (error) {
+    console.error("addNewChat: fetch chat detail failed", error);
+    return null;
+  }
+}
+function clearActionHandled(action, roomId, chatterId) {
+  const key = buildKey(action, roomId, chatterId);
+  if (!handledActions.has(key)) return;
+  clearTimeout(handledActions.get(key));
+  handledActions.delete(key);
+}
+function isActionHandled(action, roomId, chatterId) {
+  const key = buildKey(action, roomId, chatterId);
+  if (!handledActions.has(key)) return false;
+  clearTimeout(handledActions.get(key));
+  handledActions.delete(key);
+  return true;
+}
+function markActionHandled(action, roomId, chatterId) {
+  const key = buildKey(action, roomId, chatterId);
+  if (handledActions.has(key)) {
+    clearTimeout(handledActions.get(key));
+  }
+  const timer = setTimeout(() => handledActions.delete(key), DEDUP_TTL);
+  handledActions.set(key, timer);
+}
+function teardownPendingRoomsOnLogout() {
+  clearTimeout(pendingRoomsTimer);
+  pendingRoomsTimer = null;
+  pendingRooms.clear();
+}
+async function applyReceivedChat(data) {
+  const chatStore = useChatStore.getState();
+  const roomId = data.room_id;
+  const chat = chatStore.chatList.find((x2) => x2._id === roomId);
+  if (!chat) {
+    if (!isChatVisible()) return;
+    const detail = await addNewChat({ chatRoomId: roomId });
+    if (detail && roomId === useChatStore.getState().currentChatId) {
+      chatStore.resetLastRefreshTimeTicketPage();
+    }
+    return;
+  }
+  chatStore.transitionChatTab(
+    getTabStatusFromChat(chat),
+    ChatFilterAssignStatus.Received,
+    chat
+  );
+  chatStore.moveChat({
+    roomId,
+    payload: {
+      ...getReceivedSessionPayload(true),
+      last_msg: {
+        text: data.content.text,
+        type: data.content.type,
+        time: data.created_at,
+        session_id: data.session_id
+      }
+    }
+  });
+  const currentChatId = chatStore.currentChatId;
+  const isLoaded = roomId === currentChatId || !!chatStore.loadedRooms[roomId];
+  if (isLoaded) {
+    const message2 = buildChatMessage({
+      id: data._id,
+      roomId: data.room_id,
+      tenantId: data.tenant_id,
+      source: data.source,
+      chatterId: data.chatter_id,
+      chatterName: data.chatter_name,
+      chatterType: data.chatter_type,
+      type: MessageType.ACTION_RECEIVE,
+      status: data.status,
+      createdAt: data.created_at,
+      updatedAt: data.updated_at,
+      content: data.content
+    });
+    chatStore.addNewMessage(roomId, message2);
+  }
+  if (roomId === currentChatId) {
+    chatStore.resetLastRefreshTimeTicketPage();
+  }
+}
+export {
+  addNewChat,
+  addUnhiddenChats,
+  appendOptimisticDistributionLog,
+  applyEndedChat,
+  applyJoinedChat,
+  applyReceivedChat,
+  applyReopenedChat,
+  clearActionHandled,
+  clearReceiveHandled,
+  isActionHandled,
+  isChatListSearching,
+  isJoinHandled,
+  isReceiveHandled,
+  limitedGetChatRoomDetail,
+  markActionHandled,
+  markReceiveHandled,
+  queueRoomForChatList,
+  teardownPendingRoomsOnLogout
+};