l-min-components 1.6.1245 → 1.6.1248

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "l-min-components",
-  "version": "1.6.1245",
+  "version": "1.6.1248",
   "type": "module",
   "files": [
     "src/assets",

package/src/hooks/messaging-kit/index.jsx

@@ -279,6 +279,7 @@ const useMessageKit = (/*affiliatesActive*/) => {
   const [state, setState] = useState({
     roomsByCourses: [],
     chats: {},
+    loadingRoomIds: new Set(), // Track which rooms are currently loading
   });
   // State for rooms that should be automatically marked as read
   const [autoReadRoomIds, setAutoReadRoomIds] = useState(() => new Set());
@@ -370,119 +371,161 @@ const useMessageKit = (/*affiliatesActive*/) => {
   const getIndividualChats = async (nextPage, roomId, limit = 1000) => {
     if (!selectedAccount) return;
 
-    let response;
-    if (String(selectedAccount.type).toLowerCase() === "enterprise") {
-      response = await request({
-        url: nextPage || "/notify/v1/enterprise/chats/",
-        params: {
-          _account: selectedAccount.id,
-          room_id: roomId,
-          limit,
-        },
-      });
-    }
+    // Add roomId to loading state
+    setState((prevState) => ({
+      ...prevState,
+      loadingRoomIds: new Set([...prevState.loadingRoomIds, roomId]),
+    }));
 
-    if (
-      String(selectedAccount.type).toLowerCase() === "instructor" &&
-      affiliateAccount
-      //  &&
-      // affiliatesActive
-    ) {
-      response = await request({
-        url: nextPage || `/notify/v1/instructor/${affiliateAccount}/chats/`,
-        params: {
-          _account: selectedAccount.id,
-          room_id: roomId,
-          limit,
-        },
-      });
-    }
-    if (!response?.data) return;
+    try {
+      let response;
+      if (String(selectedAccount.type).toLowerCase() === "enterprise") {
+        response = await request({
+          url: nextPage || "/notify/v1/enterprise/chats/",
+          params: {
+            _account: selectedAccount.id,
+            room_id: roomId,
+            limit,
+          },
+        });
+      }
 
-    /** @type {MessageApiResponseData} */
-    const responseData = response.data;
-    const { results: newDateGroups } = responseData;
-
-    // --- Find the latest message ID from the current fetch ---
-    let latestMessageIdFromFetch = null;
-    if (newDateGroups && newDateGroups.length > 0) {
-      const allNewMessages = newDateGroups.flatMap((group) => group.messages);
-      if (allNewMessages.length > 0) {
-        allNewMessages.sort(
-          (a, b) => new Date(b.created_at) - new Date(a.created_at)
-        );
-        latestMessageIdFromFetch = allNewMessages[0];
+      if (
+        String(selectedAccount.type).toLowerCase() === "instructor" &&
+        affiliateAccount
+        //  &&
+        // affiliatesActive
+      ) {
+        response = await request({
+          url: nextPage || `/notify/v1/instructor/${affiliateAccount}/chats/`,
+          params: {
+            _account: selectedAccount.id,
+            room_id: roomId,
+            limit,
+          },
+        });
       }
-    }
-    // --- End Find latest message ID ---
 
-    setState((prevState) => {
-      // --- Update chats ONLY ---
-      // Retrieve existing date groups directly from the array mapped to roomId
-      // Count updates are now handled by readRoomMessages
-      const existingDateGroups = prevState.chats[roomId] || [];
-      const allDateGroups = [...existingDateGroups, ...newDateGroups];
-
-      // Group messages by date and de-duplicate messages within each date using their ID (existing logic)
-      const messagesGroupedByDate = {};
-      allDateGroups.forEach((dateGroup) => {
-        if (!messagesGroupedByDate[dateGroup.date]) {
-          // Use a Map for efficient de-duplication by message ID
-          messagesGroupedByDate[dateGroup.date] = {
-            date: dateGroup.date, // Store the date string
-            messagesMap: new Map(),
-          };
-        }
-        dateGroup.messages.forEach((message) => {
-          messagesGroupedByDate[dateGroup.date].messagesMap.set(
-            message.id,
-            message
+      if (String(selectedAccount.type).toLowerCase() === "personal") {
+        response = await request({
+          url: nextPage || `/notify/v1/chats/`,
+          params: {
+            _account: selectedAccount.id,
+            room_id: roomId,
+            limit,
+          },
+        });
+      }
+      if (!response?.data) return;
+
+      /** @type {MessageApiResponseData} */
+      const responseData = response.data;
+      const { results: newDateGroups } = responseData;
+
+      // --- Find the latest message ID from the current fetch ---
+      let latestMessageIdFromFetch = null;
+      if (newDateGroups && newDateGroups.length > 0) {
+        const allNewMessages = newDateGroups.flatMap((group) => group.messages);
+        if (allNewMessages.length > 0) {
+          allNewMessages.sort(
+            (a, b) => new Date(b.created_at) - new Date(a.created_at)
           );
+          latestMessageIdFromFetch = allNewMessages[0];
+        }
+      }
+      // --- End Find latest message ID ---
+
+      setState((prevState) => {
+        // --- Update chats ONLY ---
+        // Retrieve existing date groups directly from the array mapped to roomId
+        // Count updates are now handled by readRoomMessages
+        const existingDateGroups = prevState.chats[roomId] || [];
+        const allDateGroups = [...existingDateGroups, ...newDateGroups];
+
+        // Group messages by date and de-duplicate messages within each date using their ID (existing logic)
+        const messagesGroupedByDate = {};
+        allDateGroups.forEach((dateGroup) => {
+          if (!messagesGroupedByDate[dateGroup.date]) {
+            // Use a Map for efficient de-duplication by message ID
+            messagesGroupedByDate[dateGroup.date] = {
+              date: dateGroup.date, // Store the date string
+              messagesMap: new Map(),
+            };
+          }
+          dateGroup.messages.forEach((message) => {
+            messagesGroupedByDate[dateGroup.date].messagesMap.set(
+              message.id,
+              message
+            );
+          });
         });
-      });
 
-      // Reconstruct the final array of date groups with unique messages
-      const finalDateGroups = Object.values(messagesGroupedByDate).map(
-        (group) => ({
-          date: group.date,
-          // Convert Map values back to an array and sort messages by creation time
-          messages: Array.from(group.messagesMap.values()).sort(
-            (a, b) => new Date(a.created_at) - new Date(b.created_at)
-          ),
-        })
-      );
+        // Reconstruct the final array of date groups with unique messages
+        const finalDateGroups = Object.values(messagesGroupedByDate).map(
+          (group) => ({
+            date: group.date,
+            // Convert Map values back to an array and sort messages by creation time
+            messages: Array.from(group.messagesMap.values()).sort(
+              (a, b) => new Date(a.created_at) - new Date(b.created_at)
+            ),
+          })
+        );
 
-      // Optional: Sort the date groups themselves if needed (e.g., chronologically)
-      // finalDateGroups.sort((a, b) => /* comparison logic based on date */);
+        // Optional: Sort the date groups themselves if needed (e.g., chronologically)
+        // finalDateGroups.sort((a, b) => /* comparison logic based on date */);
 
-      // --- Return combined state update (only updating chats here) ---
-      return {
-        ...prevState,
-        // roomsByCourses is NOT updated here anymore
-        chats: {
-          ...prevState.chats,
-          // Update the structure: Map roomId directly to the array of finalDateGroups
-          [roomId]: finalDateGroups,
-        },
-      };
-    });
+        // --- Return combined state update (only updating chats here) ---
+        return {
+          ...prevState,
+          // roomsByCourses is NOT updated here anymore
+          chats: {
+            ...prevState.chats,
+            // Update the structure: Map roomId directly to the array of finalDateGroups
+            [roomId]: finalDateGroups,
+          },
+        };
+      });
 
-    // Call readRoomMessages only on the first page fetch, if a latest message ID was found and is its not read
-    if (
-      !nextPage &&
-      latestMessageIdFromFetch?.id && // Optional chaining for safety
-      !latestMessageIdFromFetch?.is_read // Optional chaining for safety
-    ) {
-      // Pass both message ID and room ID to readRoomMessages
-      await readRoomMessages({
-        latestMessageId: latestMessageIdFromFetch.id,
-        roomId: roomId,
+      // Call readRoomMessages only on the first page fetch, if a latest message ID was found and is its not read
+      if (
+        !nextPage &&
+        latestMessageIdFromFetch?.id && // Optional chaining for safety
+        !latestMessageIdFromFetch?.is_read // Optional chaining for safety
+      ) {
+        // Pass both message ID and room ID to readRoomMessages
+        await readRoomMessages({
+          latestMessageId: latestMessageIdFromFetch.id,
+          roomId: roomId,
+        });
+      }
+
+      // Only remove from loading state if this is the last page or there was an error
+      if (!responseData.next) {
+        setState((prevState) => {
+          const updatedLoadingRoomIds = new Set(prevState.loadingRoomIds);
+          updatedLoadingRoomIds.delete(roomId);
+          return {
+            ...prevState,
+            loadingRoomIds: updatedLoadingRoomIds,
+          };
+        });
+      }
+
+      // Pass roomId correctly in the recursive call
+      if (responseData.next) getIndividualChats(responseData.next, roomId);
+      return responseData;
+    } catch (error) {
+      // Remove from loading state in case of error
+      setState((prevState) => {
+        const updatedLoadingRoomIds = new Set(prevState.loadingRoomIds);
+        updatedLoadingRoomIds.delete(roomId);
+        return {
+          ...prevState,
+          loadingRoomIds: updatedLoadingRoomIds,
+        };
       });
+      throw error; // Re-throw to allow error handling upstream
     }
-
-    // Pass roomId correctly in the recursive call
-    if (responseData.next) getIndividualChats(responseData.next, roomId);
-    return responseData;
   };
 
   // read messages (using the latest message ID passed) and update counts
@@ -497,13 +540,16 @@ const useMessageKit = (/*affiliatesActive*/) => {
       if (
         String(selectedAccount.type).toLowerCase() === "instructor" &&
         affiliateAccount
-        //  &&
-        // affiliatesActive
       ) {
         await request({
           url: `/notify/v1/instructor/${affiliateAccount}/chats/${latestMessageId}/read_message/`,
         });
       }
+      if (String(selectedAccount.type).toLowerCase() === "personal") {
+        await request({
+          url: `/notify/v1/chats/${latestMessageId}/read_message/`,
+        });
+      }
       // 2. If API call is successful, update the local state counts
       setState((prevState) => {
         let unreadCountToSubtract = 0;
@@ -618,6 +664,21 @@ const useMessageKit = (/*affiliatesActive*/) => {
         method: "Post",
       });
     }
+    if (selectedAccount.type.toLowerCase() === "personal") {
+      response = await request({
+        url: `/notify/v1/chats/`,
+        params: {
+          _account: selectedAccount.id,
+          course_id: courseId,
+          account_id: accountId,
+        },
+        data: {
+          text,
+          media,
+        },
+        method: "Post",
+      });
+    }
 
     if (!response?.data) return; // Added optional chaining for safety
 
@@ -847,6 +908,13 @@ const useMessageKit = (/*affiliatesActive*/) => {
           method: "patch",
         });
       } // incomplete
+
+      if (selectedAccount.type.toLowerCase() === "personal") {
+        response = await request({
+          url: `/notify/v1/chats/${roomId}/change_pin_status/`,
+          method: "patch",
+        });
+      }
     } catch (err) {
       // Revert optimistic update on failure (optional, depends on desired UX)
       // You might want to implement more specific error handling here
@@ -920,6 +988,12 @@ const useMessageKit = (/*affiliatesActive*/) => {
           method: "delete",
         });
       } // incomplete
+      if (selectedAccount.type.toLowerCase() === "personal") {
+        response = await request({
+          url: `/notify/v1/chats/${roomId}/`,
+          method: "delete",
+        });
+      }
     } catch (err) {
       console.error("Error deleting room:", err);
       // Revert the optimistic update on error
@@ -957,12 +1031,25 @@ const useMessageKit = (/*affiliatesActive*/) => {
         data,
       });
     }
+    if (selectedAccount.type.toLowerCase() === "personal") {
+      response = await request({
+        url: `/notify/v1/chats/reports/`,
+        method: "post",
+        data,
+      });
+    }
     return response;
   };
   // Initial data fetch effect
   useEffect(() => {
     (async () => {
       await getMessageRoomsByCourses();
+      // reportChat({
+      //   reasons: ["Verbal harassment"],
+      //   accountId: "24dbaeede1",
+      //   messageIds: ["438745c081564ee9aeb76ed29052bd4b"],
+      //   // others: "",
+      // });
       // await deleteRoom("5be9b48281ac4c2885d3b719654ed59d");
       // await pinRoom("5be9b48281ac4c2885d3b719654ed59d");
       // Example: Fetch initial chat for a specific room if needed on load
@@ -1186,6 +1273,8 @@ const useMessageKit = (/*affiliatesActive*/) => {
     pinRoom,
     deleteRoom,
     reportChat,
+    // Helper method to check if a specific room is loading
+    isRoomLoading: (roomId) => state.loadingRoomIds.has(roomId),
   };
 };