set bold

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)