remove duplicate

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

@@ -38,7 +38,8 @@ import { HttpListenToMessageLoadHistoryAdapter } from './adapter'
 import { HttpListenToMessageLoadHistoryUseCaseInput } from 'src/app/core/chat/usecase/message/http-listen-to-message-load-history-by-roomId-use-case';
 import { MessageSocketRepositoryService } from 'src/app/module/chat/data/repository/message/message-live-signalr-data-source.service'
 import { MessageMarkAsReadInput } from "src/app/module/chat/domain/use-case/message/message-mark-as-read-use-case.service";
-import { BoldRemoveByRoomIdInput, BoldRemoveByRoomIdService } from 'src/app/module/chat/domain/use-case/bold/bold-remove-by-room-id.service'
+import { BoldRemoveByRoomIdInput, BoldRemoveByRoomIdService } from 'src/app/module/chat/domain/use-case/bold/bold-remove-by-room-id.service';
+import { MemberListHttpSyncUseCase } from 'src/app/module/chat/domain/use-case/member/member-list-http-sync-use-case.ts.service'
 export const InstanceId = uuidv4();
 
 @Injectable({
@@ -78,7 +79,8 @@ export class ChatServiceService {
     private MessageMarkAllMessageAsReadByRoomIdService: MessageMarkAllMessageAsReadByRoomIdService,
     private HttpListenToMessageLoadHistory: HttpListenToMessageLoadHistoryAdapter,
     private MessageSocketRepositoryService: MessageSocketRepositoryService,
-    private BoldRemoveByRoomIdService: BoldRemoveByRoomIdService
+    private BoldRemoveByRoomIdService: BoldRemoveByRoomIdService,
+    private MemberListHttpSyncUseCase: MemberListHttpSyncUseCase
   ) {
     this.MessageSocketRepositoryService.listenToDeleteMessages()
     .pipe()

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

@@ -13,11 +13,10 @@ export class RoomLastMessageService {
   constructor(
     private MessageSocketRepositoryService: IMessageSocketRepository,
     private roomLocalRepository: IRoomLocalRepository
-  ) { 
+  ) {
     this.listenToIncomingMessage()
   }
 
-  
   listenToIncomingMessage() {
     return this.MessageSocketRepositoryService.listenToMessages().pipe(
       filter((message) => !message?.requestId?.startsWith(InstanceId)),
@@ -26,7 +25,7 @@ export class RoomLastMessageService {
       this.roomLocalRepository.update(message.roomId, {
         messages: [message]
       })
-      
+
     });
 
   }

src/app/module/chat/domain/use-case/member/member-list-http-sync-use-case.ts.service.ts

@@ -0,0 +1,61 @@
+import { Injectable } from '@angular/core';
+import { filter, map } from 'rxjs/operators';
+import { HttpAdapter } from 'src/app/infra/http/adapter';
+import { RoomByIdOutputDTO } from '../../../domain/use-case/room/room-get-by-id-use-case.service';
+import { IMemberLocalRepository } from 'src/app/core/chat/repository/member/member-local-repository';
+import { MemberListMapper } from '../../../domain/mapper/memberLIstMapper';
+import { roomMemberListDetermineChanges } from '../../../data/async/list/rooms/roomMembersChangeDetector';
+@Injectable({
+  providedIn: 'root'
+})
+export class MemberListHttpSyncUseCase {
+
+  constructor(
+    private http: HttpAdapter,
+    private memberLocalRepository: IMemberLocalRepository
+  ) {
+
+    // this.http.listen().pipe(
+    //   filter((response)=> {
+    //     if(response?.isOk()) {
+    //       return response.value.url.includes('/Room/') && typeof response.value?.data?.data?.roomName == 'string'
+    //     }
+
+    //     return false
+    //   }),
+    //   map((response: any) => response.value.data as RoomByIdOutputDTO)
+    // )
+    // .subscribe(async (data) => {
+
+    //   this.syncMembers(data)
+    // })
+  }
+
+  private async syncMembers(roomData: RoomByIdOutputDTO): Promise<void> {
+    const roomId = roomData.data.id;
+
+    // Fetch local members and determine changes
+    const localList = await this.memberLocalRepository.getRoomMemberById(roomId);
+    const { membersToInsert, membersToUpdate, membersToDelete } = roomMemberListDetermineChanges(roomData.data.members, localList, roomId);
+
+    // Sync members
+    // for (const user of membersToInsert) {
+    //   await this.memberLocalRepository.addMember(MemberListMapper(user, roomId));
+    // }
+    // for (const user of membersToUpdate) {
+    //   await this.memberLocalRepository.updateMemberRole(MemberListMapper(user, roomId));
+    // }
+    // for (const user of membersToDelete) {
+    //   await this.memberLocalRepository.removeMemberFromRoom(user.$roomIdUserId);
+    // }
+
+    // console.log({membersToInsert, membersToUpdate, membersToDelete})
+
+    await Promise.all([
+      ...membersToInsert.map(user => this.memberLocalRepository.addMember(MemberListMapper(user, roomId))),
+      ...membersToUpdate.map(user => this.memberLocalRepository.updateMemberRole(MemberListMapper(user, roomId))),
+      ...membersToDelete.map(user => this.memberLocalRepository.removeMemberFromRoom(user.$roomIdUserId))
+    ]);
+
+  }
+}

src/app/module/chat/domain/use-case/message/message-create-use-case.service.ts

@@ -161,6 +161,8 @@ export class MessageCreateUseCaseService {
 
         if(sendMessageResult.isOk()) {
 
+          console.log('sendMessageResult', sendMessageResult.value.id)
+
           if(sendMessageResult.value.sender == undefined || sendMessageResult.value.sender == null) {
 
             delete sendMessageResult.value.sender
@@ -172,7 +174,15 @@ export class MessageCreateUseCaseService {
             $id : message.$id
           }
 
-          this.messageLocalDataSourceService.update(message.$id, {...clone, sending: false, roomId: message.roomId})
+          this.messageLocalDataSourceService.update(message.$id, {...clone, sending: false, roomId: message.roomId}).then((data)=> {
+            if(data.isOk()) {
+
+            } else {
+              tracing.hasError('failed to update send message')
+              console.log(sendMessageResult)
+              console.log(data.error)
+            }
+          })
 
           return sendMessageResult
         } else {

src/app/module/chat/domain/use-case/room/room-create-use-case.service.ts

@@ -48,24 +48,10 @@ export class CreateRoomUseCaseService {
 
     console.log('history', result)
     // const result = await this.roomRemoteDataSourceService.createRoom(data)
-  
+
     if(result.isOk()) {
 
-      console.log('create rooms',result.value)
-      if(!result?.value?.createdBy) {
-
-        let dataObject;
-
-        result.value.createdBy = {
-          wxeMail: SessionStore.user.Email,
-          wxFullName: SessionStore.user.FullName,
-          wxUserId: SessionStore.user.UserId,
-        }
-        dataObject = result.value
-      }
-
-      const localResult = await this.roomLocalDataSourceService.insert(result.value)
-      return localResult.map(e => result.value)
+      return result
     } else {
       tracing.hasError("socket close");
       console.log(result.error)

src/app/module/chat/domain/use-case/room/room-get-by-id-use-case.service.ts

@@ -1,9 +1,5 @@
 import { Injectable } from '@angular/core';
-import { id } from 'date-fns/locale';
 import { isHttpResponse } from 'src/app/services/http.service';
-import { roomListDetermineChanges } from '../../../data/async/list/rooms/roomListChangeDetector';
-import { roomMemberListDetermineChanges } from '../../../data/async/list/rooms/roomMembersChangeDetector';
-import { MemberListMapper } from '../../mapper/memberLIstMapper';
 import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
 import { z } from 'zod';
 import { IRoomRemoteRepository } from 'src/app/core/chat/repository/room/room-remote-repository';
@@ -11,8 +7,6 @@ import { IMemberLocalRepository } from 'src/app/core/chat/repository/member/memb
 import { IRoomLocalRepository } from 'src/app/core/chat/repository/room/room-local-repository';
 import { GetRoomByIdMapper } from 'src/app/core/chat/mapper/getRoomByIdMapper';
 import { RoomEntity, RoomType } from 'src/app/core/chat/entity/group';
-import { GetRoomListMapper } from 'src/app/core/chat/mapper/getRoomListMapper';
-import { roomByIdDetermineChanges } from '../../../data/async/list/rooms/roomByIdChangeDetector';
 import { diff, addedDiff, deletedDiff, updatedDiff, detailedDiff } from 'deep-object-diff';
 import { zodSafeValidation } from 'src/app/utils/zodValidation';
 
@@ -66,63 +60,46 @@ export class GetRoomByIdUseCaseService {
   @captureAndReraiseAsync('RoomRepositoryService/getRoomById')
   async execute(id: RoomByIdInputDTO) {
     const result = await this.roomRemoteDataSourceService.getRoom(id)
-   
+
     if(result.isOk()) {
       const validData = zodSafeValidation<RoomByIdOutputDTO>(RoomByIdOutputDTOSchema, result.value)
 
       if(validData.isOk()) {
         const localListRoom = await this.roomLocalDataSourceService.findAll()
         if(localListRoom.isOk()) {
-  
+
           const getRoomById = await this.roomLocalDataSourceService.findOne({id:validData.value.data.id})
           if(getRoomById.isOk() && getRoomById.value) {
             console.log(validData.value)
             const room  = GetRoomByIdMapper.toDomain(validData.value)
-  
+
             const added: Partial<RoomEntity> = addedDiff(getRoomById.value, room);
             const deleted: Partial<RoomEntity> = deletedDiff(getRoomById.value, room);
             const updated: Partial<RoomEntity> = updatedDiff(getRoomById.value, room);
-  
+
             delete added.members
             if(room.roomType == RoomType.Direct) {
               delete updated.roomName
             }
-            
+
             if(Object.keys(added).length >= 1 || Object.keys(updated).length >= 1) {
               console.log('added', added);
               console.log('deleted', deleted);
               console.log('updated', updated);
               this.roomLocalDataSourceService.update(room.id, room)
             }
-  
+
           } else if (getRoomById.isOk() && !getRoomById.value) {
             console.log(validData.value)
             const room  = GetRoomByIdMapper.toDomain(validData.value)
             this.roomLocalDataSourceService.insert(room)
           }
-          
-  
-          // ============================
-          const localList = await this.MemberListLocalRepository.getRoomMemberById(id)
-  
-          const { membersToInsert, membersToUpdate, membersToDelete } = roomMemberListDetermineChanges(validData.value.data.members, localList, id)
-  
-          for (const user of membersToInsert) {
-            await this.MemberListLocalRepository.addMember(MemberListMapper(user, id))
-          }
-  
-          for (const user of membersToUpdate) {
-            await this.MemberListLocalRepository.updateMemberRole(MemberListMapper(user, id))
-          }
-  
-          for(const user of membersToDelete) {
-            await this.MemberListLocalRepository.removeMemberFromRoom(user.$roomIdUserId)
-          }
+
         }
       } else {
 
       }
-     
+
 
 
     } else if (isHttpResponse(result.error) ) {
@@ -134,4 +111,4 @@ export class GetRoomByIdUseCaseService {
 
     return result
   }
-}
+}

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

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { RoomSetLastMessageService } from './room-set-last-message.service';
+
+describe('RoomSetLastMessageService', () => {
+  let service: RoomSetLastMessageService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(RoomSetLastMessageService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

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

@@ -0,0 +1,36 @@
+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 { MessageEntity } from 'src/app/core/chat/entity/message';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class RoomSetLastMessageService {
+
+  constructor(
+    private MessageSocketRepositoryService: IMessageSocketRepository,
+    private roomLocalRepository: IRoomLocalRepository
+  ) {
+    // this.listenToIncomingMessage()
+  }
+
+  listenToIncomingMessage() {
+    return this.MessageSocketRepositoryService.listenToMessages().pipe(
+      filter((message) => !message?.requestId?.startsWith(InstanceId)),
+      map(message => Object.assign(new MessageEntity(), message))
+    ).subscribe(async (message) => {
+      this.roomLocalRepository.update(message.roomId, {
+        messages: [message]
+      })
+
+    });
+
+  }
+
+  listenToOnSendDataToSocket() {
+
+  }
+}