filter

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

@@ -14,7 +14,7 @@ export class RoomLastMessageService {
     private MessageSocketRepositoryService: IMessageSocketRepository,
     private roomLocalRepository: IRoomLocalRepository
   ) {
-    this.listenToIncomingMessage()
+    // this.listenToIncomingMessage()
   }
 
   listenToIncomingMessage() {

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

@@ -5,6 +5,9 @@ import { filter, map } from 'rxjs/operators';
 import { InstanceId } from '../../chat-service.service';
 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';
 
 @Injectable({
   providedIn: 'root'
@@ -13,15 +16,17 @@ export class RoomSetLastMessageService {
 
   constructor(
     private roomLocalRepository: IRoomLocalRepository,
-    private messageSocketRepository: IMessageSocketRepository
+    private messageSocketRepository: IMessageSocketRepository,
+    private http: HttpAdapter,
   ) {
     this.listenToIncomingMessage()
     this.listenToOnSendDataToSocket()
+    this.loadHistory()
   }
 
-  listenToIncomingMessage() {
+  private listenToIncomingMessage() {
     return this.messageSocketRepository.listenToMessages().pipe(
-      filter((message) => !message?.requestId?.startsWith(InstanceId)),
+      filter((message) => !message?.requestId?.startsWith(InstanceId)), // get all message not send by me
       map(message => Object.assign(new MessageEntity(), message))
     ).subscribe(async (message) => {
       this.roomLocalRepository.update(message.roomId, {
@@ -32,7 +37,7 @@ export class RoomSetLastMessageService {
 
   }
 
-  listenToOnSendDataToSocket() {
+  private listenToOnSendDataToSocket() {
     this.messageSocketRepository.listenToSendMessage().subscribe(async (e) => {
 
       e.data['sender']  = {
@@ -52,4 +57,50 @@ export class RoomSetLastMessageService {
 
     })
   }
+
+  private loadHistory() {
+    const regex = new RegExp("Room\\/([0-9a-fA-F]{8})-([0-9a-fA-F]{4})-([0-9a-fA-F]{4})-([0-9a-fA-F]{4})-([0-9a-fA-F]{12})\\/Messages");
+
+    return this.http.listen().pipe(
+      filter((response: any)=> {
+        return response?.isOk() && regex.test(response.value.url)
+      }),
+      map((response: any) => response.value.data as IMessageGetAllByRoomIdOutPut)
+    ).subscribe(async (data)=> {
+      const loadHistoryFirstMessage = data.data[0]
+      if(loadHistoryFirstMessage) {
+
+        const roomId = loadHistoryFirstMessage.roomId
+
+        const room = await this.roomLocalRepository.findOne({id: roomId})
+
+        if(room.isOk()) {
+          const roomEntity = new RoomEntity(room.value)
+          if(!roomEntity.hasLastMessage()) {
+            await this.roomLocalRepository.update(loadHistoryFirstMessage.roomId, {
+              messages: [loadHistoryFirstMessage]
+            })
+          } else if (roomEntity.hasLastMessage()) {
+            const localLastMessageDate = new Date(room.value.messages[0].sentAt).getTime()
+            const loadHistoryLastMessageDate = new Date(loadHistoryFirstMessage.sentAt).getTime()
+
+            if(loadHistoryLastMessageDate>localLastMessageDate) {
+              console.log('update by load history')
+              await this.roomLocalRepository.update(loadHistoryFirstMessage.roomId, {
+                messages: [loadHistoryFirstMessage]
+              })
+            } else if(loadHistoryLastMessageDate == localLastMessageDate) {
+              // console.log('same', loadHistoryFirstMessage, roomEntity)
+            } else {
+              console.log('bug!', loadHistoryFirstMessage, roomEntity)
+            }
+
+          }
+
+        }
+
+      }
+    })
+  }
+
 }