l-min-components 1.6.1247 → 1.6.1248

package/package.json

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

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

@@ -374,148 +374,159 @@ const useMessageKit = (/*affiliatesActive*/) => {
     // Add roomId to loading state
     setState((prevState) => ({
       ...prevState,
-      loadingRoomIds: new Set([...prevState.loadingRoomIds, roomId])
+      loadingRoomIds: new Set([...prevState.loadingRoomIds, roomId]),
     }));
 
     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,
-        },
-      });
-    }
-
-    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;
+      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 ---
 
-      // 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)
-          ),
-        })
-      );
+      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
+            );
+          });
+        });
 
-      // Optional: Sort the date groups themselves if needed (e.g., chronologically)
-      // finalDateGroups.sort((a, b) => /* comparison logic based on date */);
+        // 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)
+            ),
+          })
+        );
 
-      // --- 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,
-        },
-      };
-    });
+        // Optional: Sort the date groups themselves if needed (e.g., chronologically)
+        // finalDateGroups.sort((a, b) => /* comparison logic based on date */);
 
-    // 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,
+        // --- 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,
+          },
+        };
       });
-    }
 
-    // Only remove from loading state if this is the last page or there was an error
-    if (!responseData.next) {
+      // 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
+          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;
-  } 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
-  }
-};
+  };
 
   // read messages (using the latest message ID passed) and update counts
   const readRoomMessages = async ({ latestMessageId, roomId }) => {
@@ -529,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;
@@ -650,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
 
@@ -879,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
@@ -952,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
@@ -989,6 +1031,13 @@ 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