set last message fix

src/app/module/chat/data/repository/room/room-local-repository.service.ts

@@ -19,14 +19,17 @@ export class RoomLocalRepository extends DexieRepository<RoomTable, RoomTable> i
     //   }
     // });
 
-    // chatDatabase.room.hook('updating', (modifications, primKey, obj, transaction) => {
+    chatDatabase.room.hook('updating', (modifications, primKey, oldValue, transaction) => {
 
-    //   if((modifications as Partial<RoomTable>).messages?.[0].attachments?.[0]) {
-    //     delete (modifications as Partial<RoomTable>).messages[0].attachments[0].file
-    //   }
+      if((modifications as Partial<RoomTable>).messages?.[0].requestId == oldValue.messages?.[0].requestId) {
+        (modifications as Partial<RoomTable>).messages[0].sentAt = oldValue.messages?.[0]?.sentAt;
+      } else if ((modifications as Partial<RoomTable>).messages?.[0].id == oldValue.messages?.[0].id) {
+        (modifications as Partial<RoomTable>).messages[0].sentAt = oldValue.messages?.[0]?.sentAt
+      }
+
+      return modifications
+    });
 
-    //   return modifications
-    // });
   }
 
   getItemsLive() {

src/app/module/chat/domain/chat-service.service.ts

@@ -43,7 +43,22 @@ import { MemberListHttpSyncUseCase } from 'src/app/module/chat/domain/use-case/m
 import { RoomBoldSyncUseCaseService } from 'src/app/module/chat/domain/use-case/room/room-bold-sync-use-case.service'
 import { RoomSetLastMessageService } from 'src/app/module/chat/domain/use-case/room/room-set-last-message.service';
 import { IUserPhotoGetByIdInput, UserPhotoGetByIdUseCase } from 'src/app/module/chat/domain/use-case/user-photo/user-photo-get-by-id-use-case.service'
-export const InstanceId = uuidv4();
+
+
+export const getInstanceId = (): string => {
+  const storageKey = 'instanceId'; // Key for localStorage
+  let instanceId = localStorage.getItem(storageKey);
+
+  // If not found in localStorage, generate and set a new UUID
+  if (!instanceId) {
+    instanceId = uuidv4();
+    localStorage.setItem(storageKey, instanceId);
+  }
+
+  return instanceId;
+};
+
+export const InstanceId = getInstanceId();
 
 @Injectable({
   providedIn: 'root'

src/app/module/chat/domain/use-case/room/room-set-last-message.service.ts

@@ -1,13 +1,13 @@
 import { Injectable } from '@angular/core';
 import { IMessageSocketRepository } from 'src/app/core/chat/repository/message/message-socket-repository';
 import { IRoomLocalRepository } from 'src/app/core/chat/repository/room/room-local-repository';
-import { filter, map } from 'rxjs/operators';
-import { InstanceId } from '../../chat-service.service';
+import { filter, map, tap } from 'rxjs/operators';
 import { MessageEntity } from 'src/app/core/chat/entity/message';
-import { SessionStore } from 'src/app/store/session.service';
 import { HttpAdapter } from 'src/app/infra/http/adapter';
 import { IMessageGetAllByRoomIdOutPut } from 'src/app/core/chat/usecase/message/message-get-all-by-room-Id';
 import { RoomEntity } from 'src/app/core/chat/entity/group';
+import { RoomTable } from 'src/app/infra/database/dexie/instance/chat/schema/room';
+import { IMessageLocalRepository } from 'src/app/core/chat/repository/message/message-local-repository';
 
 @Injectable({
   providedIn: 'root'
@@ -17,61 +17,81 @@ export class RoomSetLastMessageService {
   constructor(
     private roomLocalRepository: IRoomLocalRepository,
     private messageSocketRepository: IMessageSocketRepository,
+    private messageLocalRepository: IMessageLocalRepository,
     private http: HttpAdapter,
   ) {
     this.listenToIncomingMessage()
     this.listenToOnSendDataToSocket()
     this.loadHistory()
     this.listenToUpdateMessage()
-
   }
 
-  private listenToUpdateMessage() {}
+  private listenToUpdateMessage() {
+    let roomList: RoomTable[] = []
+    this.roomLocalRepository.getItemsLive().pipe(
+      tap((_roomList) => {
+
+        roomList = _roomList
+
+      })
+    ).subscribe();
+
+    this.messageSocketRepository.listenToUpdateMessages().subscribe(async(_message) => {
+      const message = {..._message}
+
+      for(const room of roomList) {
+        if(room.messages?.[0]?.id == message.id) {
+          const result = await this.roomLocalRepository.update(message.roomId, {
+            messages: [message]
+          })
+        }
+      }
+    })
+
+    this.messageSocketRepository.listenToDeleteMessages().subscribe(async(_message) => {
+      const message = {..._message}
+
+      for(const room of roomList) {
+        if(room.messages?.[0]?.id == message.id) {
+          console.log({...room.messages?.[0],isDeleted: true})
+          const result = await this.roomLocalRepository.update(message.roomId, {
+            messages: [{...room.messages?.[0],isDeleted: true}]
+          })
+        }
+      }
+    })
+  }
 
   private listenToIncomingMessage() {
     return this.messageSocketRepository.listenToMessages().pipe(
-      filter((message) => !message?.requestId?.startsWith(InstanceId)), // get all message not send by me
       map(message => Object.assign(new MessageEntity(), message))
     ).subscribe(async (message) => {
-      const result = await this.roomLocalRepository.update(message.roomId, {
-        messages: [message]
-      })
+      if(message?.roomId) {
+        const result = await this.roomLocalRepository.update(message.roomId, {
+          messages: [message]
+        })
 
-      if(result.isErr()) {
-        console.log('failed to update last message')
-      } else {
-        console.log('set last message')
+        if(result.isErr()) {
+          console.log('failed to update last message')
+        } else {
+          console.log('set last message')
+        }
       }
 
+
     });
 
   }
 
   private listenToOnSendDataToSocket() {
-    this.messageSocketRepository.listenToSendMessage().subscribe(async (e) => {
+    this.messageLocalRepository.onCreateObservable().subscribe(async (message) => {
+      if(message?.roomId) {
 
-      const message = Object.assign(new MessageEntity(), e.data)
-
-      message.sender  = {
-        userPhoto: '',
-        wxeMail: SessionStore.user.Email,
-        wxFullName: SessionStore.user.FullName,
-        wxUserId: SessionStore.user.UserId
-      }
-      message.sentAt = new Date().toISOString()
-
-      if(e.data.attachment?.fileType) {
-        message.attachments = [ e.data.attachment ]
-      } else {
-        message.attachments = []
-      }
-
-      const result = await this.roomLocalRepository.update(e.data.roomId, {
-        messages: [message]
-      })
-
-      if(result.isErr()) {
-        console.log(result.error)
+        setTimeout(async() => {
+          const result = await this.roomLocalRepository.update(message.roomId, {
+            messages: [message]
+          })
+        }, 100)
       }
 
     })
@@ -103,14 +123,18 @@ export class RoomSetLastMessageService {
             const localLastMessageDate = new Date(room.value.messages[0].sentAt).getTime()
             const loadHistoryLastMessageDate = new Date(loadHistoryFirstMessage.sentAt).getTime()
 
-            if(loadHistoryLastMessageDate>localLastMessageDate) {
+            if(loadHistoryFirstMessage.id == room.value.messages?.[0]?.id) {
+              // do nothing
+            } else if(loadHistoryLastMessageDate>localLastMessageDate) {
               await this.roomLocalRepository.update(loadHistoryFirstMessage.roomId, {
                 messages: [loadHistoryFirstMessage]
               })
             } else if(loadHistoryLastMessageDate == localLastMessageDate) {
-              // console.log('same', loadHistoryFirstMessage, roomEntity)
-            } else {
-              // console.log('bug!', loadHistoryFirstMessage, roomEntity)
+              // do nothing
+            } else if(room.value.messages[0].isDeleted != loadHistoryFirstMessage.isDeleted) {
+              await this.roomLocalRepository.update(loadHistoryFirstMessage.roomId, {
+                messages: [loadHistoryFirstMessage]
+              })
             }
 
           }