set bold

src/app/module/chat/chat.module.ts

@@ -10,7 +10,7 @@ import { RoomService } from 'src/app/module/chat/domain/service/room.service'
 import { HttpListenToMessageLoadHistoryAdapter } from './domain/adapter';
 import { ISignalRService } from 'src/app/infra/socket/adapter';
 import { HttpModule } from 'src/app/infra/http/http.module';
-import { HttpListenToMessageLoadHistoryUseCase } from 'src/app/core/chat/usecase/message/http-listen-to-message-load-history-use-case';
+import { HttpListenToMessageLoadHistoryUseCase } from 'src/app/core/chat/usecase/message/http-listen-to-message-load-history-by-roomId-use-case';
 import { IMessageLocalRepository } from 'src/app/core/chat/repository/message/message-local-repository';
 import { MessageLocalDataSourceService } from './data/repository/message/message-local-data-source.service';
 import { MessageRemoteDataSourceService } from './data/repository/message/message-remote-data-source.service';
@@ -31,6 +31,12 @@ import { IAttachmentLocalRepository } from 'src/app/core/chat/repository/typing/
 import { AttachmentLocalDataSource } from './data/repository/attachment/attachment-local-repository.service';
 import { IAttachmentRemoteRepository } from 'src/app/core/chat/repository/attachment/attachment-remote-repository';
 import { AttachmentRemoteDataSourceService } from './data/repository/attachment/attachment-remote-repository.service';
+import { IDistributionLocalRepository } from 'src/app/core/chat/repository/distribution/distribution-local-repository';
+import { DistributionLocalRepository } from './data/repository/destribution/destribution-local-repository';
+import { DistributionService } from './domain/service/distribution.service'
+import { BoldLocalRepository } from './data/repository/bold/bold-local-repository';
+import { IBoldLocalRepository } from 'src/app/core/chat/repository/bold/bold-local-repository';
+import { BoldService } from 'src/app/module/chat/domain/service/bold.service'
 @NgModule({
   imports: [HttpModule],
   providers: [
@@ -86,6 +92,15 @@ import { AttachmentRemoteDataSourceService } from './data/repository/attachment/
       provide: IAttachmentRemoteRepository,
       useClass: AttachmentRemoteDataSourceService
     },
+    //
+    {
+      provide: IDistributionLocalRepository,
+      useClass: DistributionLocalRepository
+    },
+    {
+      provide: IBoldLocalRepository,
+      useClass: BoldLocalRepository
+    }
   ],
   declarations: [],
   schemas: [],
@@ -101,7 +116,9 @@ export class ChatModule {
     private signalR: SignalRService,
     private localDataSource: UserTypingLocalRepository,
     private UserTypingRemoteRepositoryService: UserTypingRemoteRepositoryService,
-    private RoomService: RoomService
+    private RoomService: RoomService,
+    private DistributionService: DistributionService,
+    private BoldService: BoldService
   ) {
 
     this.RoomService.init()

src/app/module/chat/data/async/list/rooms/distributionListChangedetector.ts

@@ -0,0 +1,29 @@
+
+import { DistributionTable } from "src/app/infra/database/dexie/instance/chat/schema/destribution";
+import { DistributionOutPutDTO } from "src/app/module/chat/domain/service/distribution.service";
+
+export function distributionListDetermineChanges(____serverDistributions: DistributionOutPutDTO[], localDistributions: DistributionTable[], messageId: string) {
+
+  const serverDistribution = ____serverDistributions.map( e=> {
+    return {
+      ...e,
+      $messageIdMemberId: messageId + e.memberId
+    }
+  })
+
+  const serverDistributionMap = new Map(serverDistribution.map(distribution => [distribution.$messageIdMemberId, distribution]));
+  const localDistributionMap = new Map(localDistributions.map(distribution => [distribution.$messageIdMemberId, distribution]));
+
+  const distributionToInsert = serverDistribution.filter(distribution => !localDistributionMap.has(distribution.$messageIdMemberId));
+  const distributionToUpdate = serverDistribution.filter(distribution => {
+  const localDistribution = localDistributionMap.get(distribution.$messageIdMemberId);
+    return localDistribution && (
+      distribution.deliverAt !== localDistribution.deliverAt ||
+      distribution.readAt !== localDistribution.readAt
+    )
+  });
+
+  const distributionToDelete = localDistributions.filter(distribution => !serverDistributionMap.has(distribution.$messageIdMemberId));
+
+  return { distributionToInsert, distributionToUpdate, distributionToDelete };
+}

src/app/module/chat/data/async/list/rooms/roomByIdChangeDetector.ts

@@ -0,0 +1,33 @@
+import { RoomTable } from "src/app/infra/database/dexie/instance/chat/schema/room";
+import { RoomByIdOutputDTO } from "src/app/module/chat/domain/use-case/room/room-get-by-id-use-case.service";
+import { RoomListItemOutPutDTO } from "src/app/module/chat/domain/use-case/room/room-get-list-use-case.service";
+
+export function roomByIdDetermineChanges(serverResponse: RoomByIdOutputDTO, localRooms: RoomTable[]) {
+
+  const localRoomMap = new Map(localRooms.map(room => [room.id, room]));
+
+  let roomsToInsert:RoomByIdOutputDTO | undefined;
+  let roomsToUpdate: RoomByIdOutputDTO | undefined;
+
+  const fond = localRooms.filter(room => !localRoomMap.has(serverResponse.data.id));
+  if(!fond) {
+    roomsToInsert = serverResponse
+  }
+
+  const needToUpdate = localRooms.filter(room => {
+    const localRoom = localRoomMap.get(room.id);
+    return localRoom && (
+      room.roomName !== serverResponse.data.roomName ||
+      room.createdBy.wxUserId !== serverResponse.data.createdBy.wxUserId ||
+      room.createdAt !== serverResponse.data.createdAt ||
+      room.expirationDate !== serverResponse.data.expirationDate // ||
+      // room.chatRoom.roomType !== localRoom.roomType
+    );
+  });
+
+  if(needToUpdate) {
+    roomsToUpdate = serverResponse
+  }
+
+  return { roomsToInsert, roomsToUpdate };
+}

src/app/module/chat/data/async/list/rooms/roomListChangeDetector.ts

@@ -1,3 +1,4 @@
+import { RoomType } from "src/app/core/chat/entity/group";
 import { RoomTable } from "src/app/infra/database/dexie/instance/chat/schema/room";
 import { RoomListItemOutPutDTO } from "src/app/module/chat/domain/use-case/room/room-get-list-use-case.service";
 
@@ -8,8 +9,9 @@ export function roomListDetermineChanges(serverRooms: RoomListItemOutPutDTO[], l
   const roomsToInsert = serverRooms.filter(room => !localRoomMap.has(room.chatRoom.id));
   const roomsToUpdate = serverRooms.filter(room => {
     const localRoom = localRoomMap.get(room.chatRoom.id);
+
     return localRoom && (
-      room.chatRoom.roomName !== localRoom.roomName ||
+      room.chatRoom.roomName !== localRoom.roomName && room.chatRoom.roomType == RoomType.Group  ||
       room.chatRoom.createdBy.wxUserId !== localRoom.createdBy.wxUserId ||
       room.chatRoom.createdAt !== localRoom.createdAt ||
       room.chatRoom.expirationDate !== localRoom.expirationDate // ||

src/app/module/chat/data/repository/bold/bold-local-repository.ts

@@ -0,0 +1,20 @@
+import { Injectable } from '@angular/core';
+import { from } from "rxjs";
+import { DexieRepository } from "src/app/infra/repository/dexie/dexie-repository.service";
+import { Dexie, EntityTable, liveQuery, Observable } from 'Dexie';
+import { BoldTable, BoldTableSchema } from "src/app/infra/database/dexie/instance/chat/schema/bold";
+import { chatDatabase } from "src/app/infra/database/dexie/service";
+import { IBoldLocalRepository } from "src/app/core/chat/repository/bold/bold-local-repository";
+
+@Injectable({
+  providedIn: 'root'
+})
+export class  BoldLocalRepository extends DexieRepository<BoldTable, BoldTable> implements IBoldLocalRepository  {
+  constructor() {
+    super(chatDatabase.bold, BoldTableSchema)
+  }
+
+  listen() {
+    return from(liveQuery(() => chatDatabase.bold.toArray()))
+  }
+} 

src/app/module/chat/data/repository/destribution/destribution-local-repository.ts

@@ -0,0 +1,14 @@
+import { DistributionTable, DistributionTableSchema } from "src/app/infra/database/dexie/instance/chat/schema/destribution";
+import { chatDatabase } from "src/app/infra/database/dexie/service";
+import { DexieRepository } from "src/app/infra/repository/dexie/dexie-repository.service";
+
+
+export class  DistributionLocalRepository extends DexieRepository<DistributionTable, DistributionTable>  {
+  constructor() {
+    super(chatDatabase.distribution, DistributionTableSchema)
+
+    chatDatabase.distribution.hook("creating", function (primKey, obj, transaction) {
+      obj.$messageIdMemberId = `${obj.messageId}${obj.memberId}`
+    });
+  }
+} 

src/app/module/chat/domain/adapter.ts

@@ -2,7 +2,7 @@ import { HttpErrorResponse } from "@angular/common/http";
 import { Result } from "neverthrow";
 import { Observable } from "rxjs";
 import { MessageEntity } from "src/app/core/chat/entity/message";
-import { HttpListenToMessageLoadHistoryUseCaseInput } from "src/app/core/chat/usecase/message/http-listen-to-message-load-history-use-case";
+import { HttpListenToMessageLoadHistoryUseCaseInput } from "src/app/core/chat/usecase/message/http-listen-to-message-load-history-by-roomId-use-case";
 import { HttpResult } from "src/app/infra/http/type";
 import { UseCase } from "src/app/utils/use-case-interface";
 import { IMessageGetAllByRoomIdOutPut } from 'src/app/core/chat/usecase/message/message-get-all-by-room-Id'

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

@@ -36,10 +36,10 @@ import { MessageAttachmentByMessageIdInput, MessageAttachmentByMessageIdUseCase
 import { AddMemberToRoomInputDTO, AddMemberToRoomInputDTOSchema } from '../domain/use-case/member/member-add-use-case.service';
 import { RoomType } from "src/app/core/chat/entity/group";
 import { HttpListenToMessageLoadHistoryAdapter } from './adapter'
-import { HttpListenToMessageLoadHistoryUseCaseInput } from 'src/app/core/chat/usecase/message/http-listen-to-message-load-history-use-case';
+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'
 export const InstanceId = uuidv4();
 
 @Injectable({
@@ -80,6 +80,7 @@ export class ChatServiceService {
     private MessageMarkAllMessageAsReadByRoomIdService: MessageMarkAllMessageAsReadByRoomIdService,
     private HttpListenToMessageLoadHistory: HttpListenToMessageLoadHistoryAdapter,
     private MessageSocketRepositoryService: MessageSocketRepositoryService,
+    private BoldRemoveByRoomIdService: BoldRemoveByRoomIdService
   ) {
     this.MessageSocketRepositoryService.listenToDeleteMessages()
     .pipe()
@@ -182,6 +183,9 @@ export class ChatServiceService {
   //   return this.GetMessageAttachmentLocallyUseCaseService.execute(input)
   // }
 
+  removeBoldFromRoom(input: BoldRemoveByRoomIdInput) {
+    return this.BoldRemoveByRoomIdService.execute(input)
+  }
 
   listenToMessageLoadHistory(input: HttpListenToMessageLoadHistoryUseCaseInput) {
     return this.HttpListenToMessageLoadHistory.execute(input)

src/app/module/chat/domain/service/bold.service.spec.ts

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

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

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { filter, map } from 'rxjs/operators';
+import { IMessageSocketRepository } from 'src/app/core/chat/repository/message/message-socket-repository';
+import { InstanceId } from '../chat-service.service';
+import { MessageEntity } from 'src/app/core/chat/entity/message';
+import { IBoldLocalRepository } from 'src/app/core/chat/repository/bold/bold-local-repository';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class BoldService {
+
+  constructor(
+    private MessageSocketRepositoryService: IMessageSocketRepository,
+    private boldLocalRepository: IBoldLocalRepository
+  ) {
+    this.listenToIncomingMessage();
+   }
+
+  listenToIncomingMessage() {
+    return this.MessageSocketRepositoryService.listenToMessages().pipe(
+      filter((message) => !message?.requestId?.startsWith(InstanceId)),
+      map(message => Object.assign(new MessageEntity(), message))
+    ).subscribe(async (message) => {
+      
+      const result = await this.boldLocalRepository.findOne({roomId: message.roomId})
+
+      if(result.isOk() && !result.value) {
+        const result = await this.boldLocalRepository.insert({roomId: message.roomId, bold: 1})
+      } else if(result.isOk() && result.value.bold == 0) {
+        const result = await this.boldLocalRepository.update(message.roomId, {bold: 1})
+      }
+
+    });
+
+  }
+}

src/app/module/chat/domain/service/distribution.service.spec.ts

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

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

@@ -0,0 +1,87 @@
+import { Injectable } from '@angular/core';
+import { filter, map } from 'rxjs/operators';
+import { IMessageGetAllByRoomIdOutPut } from 'src/app/core/chat/usecase/message/message-get-all-by-room-Id';
+import { HttpAdapter } from 'src/app/infra/http/adapter';
+import { IDistributionLocalRepository } from 'src/app/core/chat/repository/distribution/distribution-local-repository'
+import { z } from 'zod';
+import { distributionListDetermineChanges } from '../../data/async/list/rooms/distributionListChangedetector';
+import { DistributionEntity } from 'src/app/core/chat/entity/distribution';
+
+export const DistributionOutPutDTOSchema = z.object({
+  $messageIdMemberId: z.string(),
+  memberId: z.number(),
+  readAt: z.string().nullable(),
+  deliverAt: z.string().nullable()
+})
+export type  DistributionOutPutDTO = z.infer<typeof DistributionOutPutDTOSchema>
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DistributionService {
+
+  constructor(
+    private http: HttpAdapter,
+    private distributionLocalRepository: IDistributionLocalRepository
+  ) {
+    // this.listenToLoadHistory()
+  }
+
+  listenToLoadHistory() {
+    return this.http.listen().pipe(
+      filter((response)=> {
+        if(response?.isOk()) {
+          return response.value.url.endsWith('Messages')
+        }
+        
+        return false
+      }),
+      map((response: any) => response.value.data as IMessageGetAllByRoomIdOutPut)
+    )
+    .subscribe(async (data) => {
+      
+      const localList = await this.distributionLocalRepository.find({roomId: data.data[0].roomId})
+
+      data.data.map(async (message) => {
+        const serverList = message.info
+
+        if(localList.isOk() && localList.value) {
+
+          // const localListForCurrentMessage = localList.value.filter((e) => e.messageId == message.id)
+
+          // console.log('localListForCurrentMessage', localListForCurrentMessage)
+          
+          // const { distributionToInsert, distributionToUpdate, distributionToDelete } = await distributionListDetermineChanges(serverList, localListForCurrentMessage, message.id)
+          // console.log({distributionToInsert, distributionToUpdate, distributionToDelete})
+
+          // const map = distributionToInsert.map((e) => {
+          //   e.
+          // })
+
+          // this.distributionLocalRepository.insertMany(distributionToInsert)
+
+          // const distributionEntityToInsert = distributionToInsert.map((ee)=> {
+          //   return new DistributionEntity({
+          //     roomId: message.roomId,
+          //     deliverAt: ee.deliverAt,
+          //     memberId: ee.memberId,
+          //     messageId: message.roomId,
+          //     readAt: ee.readAt,
+          //   })
+
+          //   console.log('create')
+          // })
+
+          // if(distributionEntityToInsert.length >= 0) {
+          //   // console.log('distributionEntityToInsert', distributionEntityToInsert)
+          //   //this.distributionLocalRepository.insertMany(distributionEntityToInsert)
+          // }
+
+          
+        }
+        
+      })
+
+    })
+  }
+}

src/app/module/chat/domain/use-case/bold/bold-remove-by-room-id.service.spec.ts

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

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

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { IBoldLocalRepository } from 'src/app/core/chat/repository/bold/bold-local-repository';
+import { TracingType, XTracerAsync } from 'src/app/services/monitoring/opentelemetry/tracer';
+import { zodSafeValidation } from 'src/app/utils/zodValidation';
+import { z } from 'zod';
+
+
+const BoldRemoveByRoomIdInputSchema = z.object({
+  roomId: z.string()
+})
+export type BoldRemoveByRoomIdInput = z.infer<typeof BoldRemoveByRoomIdInputSchema>
+@Injectable({
+  providedIn: 'root'
+})
+export class BoldRemoveByRoomIdService {
+
+  constructor(
+    private boldLocalRepository: IBoldLocalRepository
+  ) { }
+
+  @XTracerAsync({name:'BoldRemoveByRoomIdService', module:'chat',  bugPrint: true})
+  async execute(input: BoldRemoveByRoomIdInput, tracing?: TracingType) {
+
+    const validation = zodSafeValidation<any>(BoldRemoveByRoomIdInputSchema, input)
+
+    if(validation.isOk()) {
+      return await this.boldLocalRepository.delete(input.roomId)
+    } else {
+      tracing.hasError("invalid parameter")
+    }
+    
+  }
+}

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

@@ -10,8 +10,11 @@ import { IRoomRemoteRepository } from 'src/app/core/chat/repository/room/room-re
 import { IMemberLocalRepository } from 'src/app/core/chat/repository/member/member-local-repository';
 import { IRoomLocalRepository } from 'src/app/core/chat/repository/room/room-local-repository';
 import { GetRoomByIdMapper } from 'src/app/core/chat/mapper/getRoomByIdMapper';
-import { RoomEntity } from 'src/app/core/chat/entity/group';
+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';
 
 const UserSchema = z.object({
   wxUserId: z.number(),
@@ -56,7 +59,6 @@ export class GetRoomByIdUseCaseService {
 
   constructor(
     private roomRemoteDataSourceService: IRoomRemoteRepository,
-    // private roomMemoryDataSourceService: Store<RoomRemoteDataSourceState>,
     private roomLocalDataSourceService: IRoomLocalRepository,
     private MemberListLocalRepository: IMemberLocalRepository
   ) { }
@@ -64,71 +66,63 @@ 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)
 
-      const localListRoom = await this.roomLocalDataSourceService.findAll()
-      if(localListRoom.isOk()) {
-        const object = {
-          chatRoom: result.value.data
-        }
-        const { roomsToInsert, roomsToUpdate } = roomListDetermineChanges([object], localListRoom.value)
-
-        if(roomsToUpdate) {
-
-          const roomsToUpdateEntity = GetRoomListMapper.toDomain(roomsToUpdate)
-          for( const room of  roomsToUpdateEntity) {
-            this.roomLocalDataSourceService.update(room.id, room)
-            if(room.expirationDate) {
-              console.log('room expiration date schedule')
-              // this.CronJobService.createCronJob('remove expired room', new Date(room.expirationDate), this.execute)
-            }
-          }
-        }
-
-        if(roomsToInsert) {
-          
-          const roomsToInsertEntity = GetRoomListMapper.toDomain(roomsToInsert)
-          for( const room of  roomsToInsertEntity) {
-            this.roomLocalDataSourceService.insert(room)
-            if(room.expirationDate) {
-              console.log('room expiration date schedule')
-              // this.CronJobService.createCronJob('remove expired room', new Date(room.expirationDate), this.execute)
-            }
-          }
-        }
-        
-        // for( const roomData of  roomsToUpdate) {
-        //   const room = new RoomEntity({
-        //     createdAt: result.value.data.createdAt,
-        //     createdBy: result.value.data.createdBy,
-        //     expirationDate: result.value.data.expirationDate,
-        //     id: result.value.data.id,
-        //     members: result.value.data.members,
-        //     roomName: result.value.data.roomName,
-        //     roomType: result.value.data.roomType,
-        //   })
+      if(validData.isOk()) {
+        const localListRoom = await this.roomLocalDataSourceService.findAll()
+        if(localListRoom.isOk()) {
   
-        //   this.roomLocalDataSourceService.update(room.id, room)
-        // }
-
-        // ============================
-        const localList = await this.MemberListLocalRepository.getRoomMemberById(id)
-
-        const { membersToInsert, membersToUpdate, membersToDelete } = roomMemberListDetermineChanges(result.value.data.members, localList, id)
-
-        for (const user of membersToInsert) {
-          await this.MemberListLocalRepository.addMember(MemberListMapper(user, id))
+          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 {
 
-        for (const user of membersToUpdate) {
-          await this.MemberListLocalRepository.updateMemberRole(MemberListMapper(user, id))
-        }
-
-        for(const user of membersToDelete) {
-          await this.MemberListLocalRepository.removeMemberFromRoom(user.$roomIdUserId)
-        }
       }
+     
 
 
     } else if (isHttpResponse(result.error) ) {
@@ -140,4 +134,4 @@ export class GetRoomByIdUseCaseService {
 
     return result
   }
-}
+}

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

@@ -80,9 +80,7 @@ export class GetRoomListUseCaseService {
         }
         
         const roomsToUpdateEntity = GetRoomListMapper.toDomain(roomsToUpdate)
-        for( const room of  roomsToUpdateEntity) {
-          this.roomLocalDataSourceService.update(room.id, room)
-        }
+        this.roomLocalDataSourceService.updateMany(roomsToUpdateEntity)
 
         for( const room of  roomsToDelete) {
           this.roomLocalDataSourceService.delete(room.id)