code refactoring

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

@@ -1,26 +1,38 @@
 import { Injectable } from '@angular/core';
-import { MessageDeleteLiveUseCaseService, MessageDeleteInputDTO } from 'src/app/module/chat/domain/use-case/message-delete-live-use-case.service'
+import { MessageDeleteLiveUseCaseService } from 'src/app/module/chat/domain/use-case/message-delete-by-id-live-use-case.service'
 import { SessionStore } from 'src/app/store/session.service';
-import { MessageReactionInput, MessageReactionUseCaseService } from 'src/app/module/chat/domain/use-case/message-reaction-use-case.service';
-import { MessageUpdateInput, MessageUpdateUseCaseService } from 'src/app/module/chat/domain/use-case/message-update-use-case.service';
+import { MessageReactionInput, MessageReactionUseCaseService } from 'src/app/module/chat/domain/use-case/message-reaction-by-id-use-case.service';
+import { MessageUpdateInput, MessageUpdateUseCaseService } from 'src/app/module/chat/domain/use-case/message-update-by-id-use-case.service';
 import { MemberAdminUseCaseService, MemberSetAdminDTO } from 'src/app/module/chat/domain/use-case/member-admin-use-case.service';
 import { MessageCreateUseCaseService } from 'src/app/module/chat/domain/use-case/message-create-use-case.service';
 import { SignalRService } from '../infra/socket/signal-r.service';
 import { SocketMessageDeleteUseCaseService } from 'src/app/module/chat/domain/use-case/socket/socket-message-delete-use-case.service';
 import { SocketMessageUpdateUseCaseService } from 'src/app/module/chat/domain/use-case/socket/socket-message-update-use-case.service';
 import { SocketMessageCreateUseCaseService } from 'src/app/module/chat/domain/use-case/socket/socket-message-create-use-case.service';
-import { DownloadMessageAttachmentUserCaseService } from 'src/app/module/chat/domain/use-case/download-message-attachment-user-case.service';
+import { DownloadMessageAttachmentUserCaseService } from 'src/app/module/chat/domain/use-case/message-download-attachment-user-case.service';
 import { ListenMessageByRoomIdNewUseCase } from 'src/app/module/chat/domain/use-case/listen-message-by-roomId.service';
 import { MemberListUpdateStatusUseCaseService } from 'src/app/module/chat/domain/use-case/socket/member-list-update-status-use-case.service';
 import { ListenMessageDeleteByRoomIdService } from './use-case/listene-message-delete-by-roomId.service';
 import { ListenMessageUpdateByRoomIdUseCase } from './use-case/listen-message-update-by-roomId.service';
+import { GetRoomByIdUseCaseService } from './use-case/room-get-by-id-use-case.service';
+import { DeleteRoomUseCaseService } from './use-case/room-delete-by-id-use-case.service';
+import { CreateRoomUseCaseService } from './use-case/room-create-use-case.service';
+import { RoomLeaveUseCase } from './use-case/room-leave-by-id-use-case.service';
 import { SyncAllRoomMessagesService } from './use-case/sync-all-room-messages.service';
 import { ListenSendMessageUseCase } from './use-case/listen-send-message.service'
-import { GetMessageAttachmentLocallyUseCaseService } from 'src/app/module/chat/domain/use-case/get-message-attachment-localy-use-case.service';
+import { RemoveMemberUseCaseService } from './use-case/member/-use-case.service'
+import { AddMemberUseCaseService } from './use-case/member-add-use-case.service'
+import { UpdateRoomByIdUseCaseService } from './use-case/room-update-by-id-use-case.service'
+import { GetMessageAttachmentLocallyUseCaseService } from 'src/app/module/chat/domain/use-case/message-get-attachment-localy-use-case.service';
+import { GetRoomListUseCaseService } from 'src/app/module/chat/domain/use-case/room-get-list-use-case.service';
 import { filter } from 'rxjs/operators';
 import { v4 as uuidv4 } from 'uuid'
 import { MessageEntity } from './entity/message';
 import { MessageAttachmentByMessageIdInput, MessageAttachmentByMessageIdUseCase } from './use-case/message-attachment-by-message-id.service';
+import { RoomInputDTO } from '../data/dto/room/roomInputDTO';
+import { UserRemoveListInputDTO } from '../data/dto/room/userRemoveListInputDTO';
+import { AddMemberToRoomInputDTO } from '../data/dto/room/addMemberToRoomInputDto';
+import { RoomUpdateInputDTO } from '../data/dto/room/roomUpdateInputDTO';
 
 export const InstanceId = uuidv4();
 
@@ -48,7 +60,15 @@ export class ChatServiceService {
     private MessageAttachmentByMessageIdService: MessageAttachmentByMessageIdUseCase,
     private SyncAllRoomMessagesService: SyncAllRoomMessagesService,
     private DownloadMessageAttachmentUserCaseService: DownloadMessageAttachmentUserCaseService,
-    private GetMessageAttachmentLocallyUseCaseService: GetMessageAttachmentLocallyUseCaseService
+    private GetMessageAttachmentLocallyUseCaseService: GetMessageAttachmentLocallyUseCaseService,
+    private GetRoomListUseCaseService: GetRoomListUseCaseService,
+    private GetRoomByIdUseCaseService: GetRoomByIdUseCaseService,
+    private DeleteRoomUseCaseService: DeleteRoomUseCaseService,
+    private CreateRoomUseCaseService: CreateRoomUseCaseService,
+    private RoomLeaveUseCase: RoomLeaveUseCase,
+    private AddMemberUseCaseService: AddMemberUseCaseService,
+    private UpdateRoomByIdUseCaseService: UpdateRoomByIdUseCaseService,
+    private RemoveMemberUseCaseService: RemoveMemberUseCaseService
   ) {
     this.messageLiveSignalRDataSourceService.getMessageDelete()
     .pipe()
@@ -76,13 +96,10 @@ export class ChatServiceService {
         return !message?.requestId?.startsWith(InstanceId)
       })
     ).subscribe(async (message) => {
-
       if(message?.id) {
         console.log('create message')
         this.SocketMessageCreateUseCaseService.execute(message)
       }
-
-
     })
 
     this.messageLiveSignalRDataSourceService.getData().pipe(
@@ -99,6 +116,15 @@ export class ChatServiceService {
 
   }
 
+  async start() {
+    await this.getRoomList();
+    this.asyncAllRoomMessage();
+  }
+
+  removeMemberToRoom(data: UserRemoveListInputDTO) {
+    return this.RemoveMemberUseCaseService.execute(data)
+  }
+
   messageDelete(data: {roomId, messageId}) {
 
     const params = {
@@ -142,6 +168,39 @@ export class ChatServiceService {
   }
 
 
+  getRoomList() {
+    return this.GetRoomListUseCaseService.execute()
+  }
+
+  getRoomById(id: string) {
+    return this.GetRoomByIdUseCaseService.execute(id)
+  }
+
+
+  deleteRoomById(id: string) {
+    return this.DeleteRoomUseCaseService.execute(id)
+  }
+
+  createRoom(data: RoomInputDTO) {
+    return this.CreateRoomUseCaseService.execute(data)
+  }
+
+  leaveRoom(data: UserRemoveListInputDTO) {
+    return this.RoomLeaveUseCase.execute(data)
+  }
+
+  addMemberToRoom(data: AddMemberToRoomInputDTO) {
+    return this.AddMemberUseCaseService.execute(data)
+  }
+
+  updateRoomById(data: RoomUpdateInputDTO) {
+    return this.UpdateRoomByIdUseCaseService.execute(data)
+  }
+
+  removeMember() {
+
+  }
+
   listenToIncomingMessage(roomId:string) {
     return this.ListenMessageByRoomIdNewUseCase.execute({roomId})
   }

src/app/module/chat/domain/use-case/member-add-use-case.service.ts

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
+import { AddMemberToRoomInputDTO } from '../../data/dto/room/addMemberToRoomInputDto';
+import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class AddMemberUseCaseService {
+
+  constructor(
+    private roomRemoteDataSourceService: RoomRemoteDataSourceService,
+  ) { }
+
+
+
+  @captureAndReraiseAsync('RoomRepositoryService/addMemberToRoom')
+  async execute(data: AddMemberToRoomInputDTO) {
+
+    // return this.roomLiveSignalRDataSourceService.addMemberToRoom(data)
+
+    const result = await this.roomRemoteDataSourceService.addMemberToRoom(data)
+
+    return result
+  }
+
+}

src/app/module/chat/domain/use-case/member-admin-use-case.service.ts

@@ -1,7 +1,7 @@
 import { Injectable } from '@angular/core';
 import { z } from "zod";
-import { RoomRepositoryService } from '../../data/repository/room-repository.service';
 import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
+import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
 
 // Define the schema for the entire response
 const MemberSetAdminDTOSchema = z.object({
@@ -18,12 +18,12 @@ export type MemberSetAdminDTO = z.infer<typeof MemberSetAdminDTOSchema>
 export class MemberAdminUseCaseService {
 
   constructor(
-    public repository: RoomRepositoryService
+    public repository: RoomRemoteDataSourceService
   ) { }
 
   @ValidateSchema(MemberSetAdminDTOSchema)
   execute(input: MemberSetAdminDTO) {
 
-    return this.repository.setAdmin(input)
+    return this.repository.setAmin(input)
   }
 }

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

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
+import { UserRemoveListInputDTO } from '../../../data/dto/room/userRemoveListInputDTO';
+import { RoomRemoteDataSourceService } from '../../../data/repository/room-remote-repository.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class RemoveMemberUseCaseService {
+
+  constructor(
+    private roomRemoteDataSourceService: RoomRemoteDataSourceService,
+  ) { }
+
+
+  @captureAndReraiseAsync('RoomRepositoryService/removeMemberToRoom')
+  async execute(data: UserRemoveListInputDTO) {
+    const result = await this.roomRemoteDataSourceService.removeMemberFromRoom(data)
+
+    return result
+  }
+}

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

@@ -8,7 +8,12 @@ import { InstanceId } from '../chat-service.service';
 import { createDataURL } from 'src/app/utils/ToBase64';
 import { zodSafeValidation } from 'src/app/utils/zodValidation';
 import { Logger } from 'src/app/services/logger/main/service';
-import { MessageAttachmentSource } from '../../data/dto/message/messageOutputDTO';
+import { MessageAttachmentSource, MessageOutPutDataDTO } from '../../data/dto/message/messageOutputDTO';
+import { MessageLocalDataSourceService } from '../../data/data-source/message/message-local-data-source.service';
+import { err } from 'neverthrow';
+import { MessageTable } from '../../infra/database/dexie/schema/message';
+import { MessageMapper } from '../mapper/messageMapper';
+import { SignalRService } from '../../infra/socket/signal-r.service';
 
 const MessageInputUseCaseSchema = z.object({
   memberId: z.number(),
@@ -26,6 +31,8 @@ export class MessageCreateUseCaseService {
   constructor(
     private MessageRepositoryService: MessageRepositoryService,
     private AttachmentRepositoryService: AttachmentRepositoryService,
+    private messageLocalDataSourceService: MessageLocalDataSourceService,
+    private messageLiveSignalRDataSourceService: SignalRService,
   ) { }
 
 
@@ -38,9 +45,13 @@ export class MessageCreateUseCaseService {
 
       message.requestId = InstanceId +'@'+ uuidv4();
 
-      const createMessageLocally = await this.MessageRepositoryService.createMessageLocally(message)
+
+      const createMessageLocally = await this.messageLocalDataSourceService.sendMessage(message)
 
       if(createMessageLocally.isOk()) {
+
+        message.$id = createMessageLocally.value
+
         if(message.hasAttachment) {
 
           for (const attachment of message.attachments) {
@@ -48,7 +59,7 @@ export class MessageCreateUseCaseService {
             if(attachment.source != MessageAttachmentSource.Webtrix) {
 
               this.AttachmentRepositoryService.create({
-                $messageId: createMessageLocally.value.$id,
+                $messageId: createMessageLocally.value,
                 file: createDataURL(attachment.file, attachment.mimeType),
                 fileType: attachment.fileType,
                 source: attachment.source,
@@ -72,20 +83,36 @@ export class MessageCreateUseCaseService {
 
         }
 
-        const sendToServer = await this.MessageRepositoryService.sendMessage(message)
+        //====================
+        message.sending = true
 
-        if(!sendToServer.isOk()) {
+        const DTO = MessageMapper.fromDomain(message, message.requestId)
+        const sendMessageResult = await this.messageLiveSignalRDataSourceService.sendMessage<MessageOutPutDataDTO>(DTO)
+        // return this sendMessageResult
+
+        if(sendMessageResult.isOk()) {
+
+          if(sendMessageResult.value.sender == undefined || sendMessageResult.value.sender == null) {
+
+            delete sendMessageResult.value.sender
+          }
+
+          let clone: MessageTable = {
+            ...sendMessageResult.value,
+            id: sendMessageResult.value.id,
+            $id : message.$id
+          }
+
+          return this.messageLocalDataSourceService.update(message.$id, {...clone, sending: false, roomId: message.roomId})
+        } else {
           Logger.error('failed to send message to the server', {
-            error: sendToServer.error
+            error: sendMessageResult.error
           })
+          await this.messageLocalDataSourceService.update(message.$id, {sending: false, $id: message.$id})
+          return err('no connection')
         }
-
-        return sendToServer
+        
       }
-
-      const result = await this.MessageRepositoryService.sendMessage(message)
-
-      return result
     } else {
 
       if(validation.error.formErrors.fieldErrors.attachments) {

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

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { create } from 'domain';
+import { SessionStore } from 'src/app/store/session.service';
+import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
+import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
+import { RoomInputDTO } from '../../data/dto/room/roomInputDTO';
+import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class CreateRoomUseCaseService {
+
+  constructor(
+    private roomRemoteDataSourceService: RoomRemoteDataSourceService,
+    private roomLocalDataSourceService: RoomLocalRepository,
+  ) { }
+
+
+  @captureAndReraiseAsync('RoomRepositoryService/create')
+  async execute(data: RoomInputDTO) {
+
+    const result = await this.roomRemoteDataSourceService.createRoom(data)
+    if(result.isOk()) {
+
+      if(!result.value.data.createdBy) {
+
+        let dataObject;
+
+        result.value.data.createdBy = {
+          wxeMail: SessionStore.user.Email,
+          wxFullName: SessionStore.user.FullName,
+          wxUserId: SessionStore.user.UserId,
+        }
+
+        dataObject = result.value.data
+      }
+
+
+      const localResult = await this.roomLocalDataSourceService.createRoom(result.value.data)
+      return localResult.map(e => result.value)
+    }
+
+    return result
+  }
+
+}

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

@@ -0,0 +1,42 @@
+import { Injectable } from '@angular/core';
+import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
+import { isHttpResponse } from 'src/app/services/http.service';
+import { RoomByIdInputDTO } from '../../data/dto/room/roomByIdInputDTO';
+import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
+import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DeleteRoomUseCaseService {
+
+  constructor(
+    private roomRemoteDataSourceService: RoomRemoteDataSourceService,
+    // private roomMemoryDataSourceService: Store<RoomRemoteDataSourceState>,
+    private roomLocalDataSourceService: RoomLocalRepository,
+  ) { }
+
+
+  @captureAndReraiseAsync('RoomRepositoryService/deleteRoomById')
+  async execute(id: RoomByIdInputDTO) {
+    const result = await this.roomRemoteDataSourceService.deleteRoom(id)
+
+    if(result.isOk()) {
+
+      const  result =  await this.roomLocalDataSourceService.deleteRoomById(id)
+      // this.messageLiveDataSourceService.sendMessage({
+      //   type: 'createRoom',
+      //   payload: {a: '5'}
+      // })
+
+      return result
+    } else if (isHttpResponse(result.error)) {
+      if(result.error.status == 404) {
+        await this.roomLocalDataSourceService.deleteRoomById(id)
+      }
+      // this.httpErrorHandle.httpStatusHandle(result.error)
+    }
+
+    return result
+  }
+}

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

@@ -0,0 +1,69 @@
+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 { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
+import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
+import { MemberListLocalRepository } from '../../data/repository/member-list-local-repository.service';
+import { MemberListMapper } from '../mapper/memberLIstMapper';
+import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class GetRoomByIdUseCaseService {
+
+  constructor(
+    private roomRemoteDataSourceService: RoomRemoteDataSourceService,
+    // private roomMemoryDataSourceService: Store<RoomRemoteDataSourceState>,
+    private roomLocalDataSourceService: RoomLocalRepository,
+    private MemberListLocalRepository: MemberListLocalRepository
+  ) { }
+
+  @captureAndReraiseAsync('RoomRepositoryService/getRoomById')
+  async execute(id: string) {
+    const result = await this.roomRemoteDataSourceService.getRoom(id)
+
+    if(result.isOk()) {
+
+      const localListRoom = await this.roomLocalDataSourceService.getRoomList()
+      if(localListRoom.isOk()) {
+        const object = {
+          chatRoom: result.value.data
+        }
+        const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges([object], localListRoom.value)
+
+        for( const roomData of  roomsToUpdate) {
+          this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
+        }
+
+        // ============================
+        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))
+        }
+
+        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) ) {
+      if(result.error.status == 404) {
+        await this.roomLocalDataSourceService.deleteRoomById(id)
+      }
+      // this.httpErrorHandle.httpStatusHandle(result.error)
+    }
+
+    return result
+  }
+}

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

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { roomListDetermineChanges } from '../../data/async/list/rooms/roomListChangeDetector';
+import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
+import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
+import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
+import { isHttpResponse } from 'src/app/services/http.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class GetRoomListUseCaseService {
+
+  constructor(
+    private roomRemoteDataSourceService: RoomRemoteDataSourceService,
+    // private roomMemoryDataSourceService: Store<RoomRemoteDataSourceState>,
+    private roomLocalDataSourceService: RoomLocalRepository,
+  ) { }
+
+  @captureAndReraiseAsync('RoomRepositoryService/list')
+  async execute() {
+    const result = await this.roomRemoteDataSourceService.getRoomList()
+
+    const localList = await this.roomLocalDataSourceService.getRoomList()
+
+    if(localList.isOk()) {
+      if(result.isOk()) {
+        const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges(result.value.data, localList.value)
+
+          for( const roomData of  roomsToInsert) {
+            this.roomLocalDataSourceService.createRoom(roomData.chatRoom)
+          }
+
+          for( const roomData of  roomsToUpdate) {
+            this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
+          }
+
+          for( const roomData of  roomsToDelete) {
+            this.roomLocalDataSourceService.deleteRoomById(roomData.id)
+          }
+
+      }
+    }
+
+    return result
+  }
+
+}

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

@@ -0,0 +1,34 @@
+import { Injectable } from '@angular/core';
+import { UserRemoveListInputDTO } from '../../data/dto/room/userRemoveListInputDTO';
+import { isHttpResponse } from 'src/app/services/http.service';
+import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
+import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class RoomLeaveUseCase {
+
+  constructor(
+    private roomRemoteDataSourceService: RoomRemoteDataSourceService,
+    private roomLocalDataSourceService: RoomLocalRepository,
+  ) { }
+
+
+
+  async execute(data: UserRemoveListInputDTO) {
+    const result = await this.roomRemoteDataSourceService.removeMemberFromRoom(data)
+
+    if(result.isOk()) {
+      this.roomLocalDataSourceService.leaveRoom(data.id)
+    } else if (isHttpResponse(result.error)) {
+      if(result.error.status == 404) {
+        await this.roomLocalDataSourceService.deleteRoomById(data.id)
+
+      }
+      // this.httpErrorHandle.httpStatusHandle(result.error)
+    }
+
+    return result
+  }
+}

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

@@ -0,0 +1,39 @@
+import { Injectable } from '@angular/core';
+import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
+import { RoomUpdateInputDTO } from '../../data/dto/room/roomUpdateInputDTO';
+import { RoomRemoteDataSourceService } from '../../data/repository/room-remote-repository.service';
+import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class UpdateRoomByIdUseCaseService {
+
+  constructor(
+    private roomRemoteDataSourceService: RoomRemoteDataSourceService,
+    private roomLocalDataSourceService: RoomLocalRepository,
+  ) { }
+
+
+  @captureAndReraiseAsync('RoomRepositoryService/updateRoomBy')
+  async execute(data: RoomUpdateInputDTO) {
+
+    const result = await this.roomRemoteDataSourceService.updateRoom(data)
+
+    if(result.isOk()) {
+      const localList = await this.roomLocalDataSourceService.getRoomList()
+      // const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges([result.value.data], localList)
+
+      // for( const roomData of  roomsToUpdate) {
+      //   if(!roomData.chatRoom.createdBy?.wxUserId) {
+      //     delete roomData.chatRoom.createdBy;
+      //   }
+
+      //   this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
+      // }
+
+    }
+
+    return result
+  }
+}

src/app/module/chat/domain/use-case/socket/member-list-update-status-use-case.service.ts

@@ -1,7 +1,7 @@
 import { Injectable } from '@angular/core';
 import { z } from 'zod';
-import { RoomRepositoryService } from 'src/app/module/chat/data/repository/room-repository.service'
 import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
+import { MemberListLocalRepository } from 'src/app/module/chat/data/repository/member-list-local-repository.service'
 
 export const MemberListUPdateStatus = z.object({
   key: z.string(),
@@ -19,13 +19,12 @@ export type MemberListUPdateStatusInputDTO = z.infer<typeof MemberListUPdateStat
 export class MemberListUpdateStatusUseCaseService {
 
   constructor(
-    private RoomRepositoryService: RoomRepositoryService
+    private MemberListLocalRepository: MemberListLocalRepository
   ) { }
 
 
   @ValidateSchema(MemberListUPdateStatus)
   execute(input: MemberListUPdateStatusInputDTO) {
-    console.log
-    return this.RoomRepositoryService.updateMemberStatus(input)
+    return this.MemberListLocalRepository.updateMembersStatus(input)
   }
 }

src/app/module/chat/domain/use-case/sync-all-room-messages.service.ts

@@ -1,7 +1,10 @@
 import { Injectable } from '@angular/core';
-import { RoomRepositoryService } from 'src/app/module/chat/data/repository/room-repository.service'
-import { MessageRepositoryService } from 'src/app/module/chat/data/repository/message-respository.service'
-import { RoomTable } from '../../infra/database/dexie/schema/room';
+import { MessageLocalDataSourceService } from '../../data/data-source/message/message-local-data-source.service';
+import { messageListDetermineChanges } from '../../data/async/list/rooms/messageListChangedetector';
+import { MessageTable } from '../../infra/database/dexie/schema/message';
+import { MessageRemoteDataSourceService } from '../../data/data-source/message/message-remote-data-source.service';
+import { ok } from 'neverthrow';
+import { RoomLocalRepository } from '../../data/repository/room-local-repository.service';
 
 @Injectable({
   providedIn: 'root'
@@ -9,24 +12,54 @@ import { RoomTable } from '../../infra/database/dexie/schema/room';
 export class SyncAllRoomMessagesService {
 
   constructor(
-    private RoomRepositoryService: RoomRepositoryService,
-    private MessageRepositoryService: MessageRepositoryService
+    private messageLocalDataSourceService: MessageLocalDataSourceService,
+    private messageRemoteDataSourceService: MessageRemoteDataSourceService,
+    private roomLocalDataSourceService: RoomLocalRepository,
   ) { }
 
   async execute() {
 
-    await this.RoomRepositoryService.list()
-    const allRooms: RoomTable[] = await this.RoomRepositoryService.getRoomList()
+    const allRooms = await this.roomLocalDataSourceService.findAll()
 
-    if(allRooms) {
-      if(allRooms.length == 0) {
+    if(allRooms.isOk()) {
+      if(allRooms.value.length == 0) {
         console.log('no room to sync')
+      } else {
+        console.log('sync '+ allRooms.value.length)
       }
-      for(const room of allRooms) {
-        this.MessageRepositoryService.listAllMessagesByRoomId(room.id)
+      for(const room of allRooms.value) {
+        const result = await this.messageRemoteDataSourceService.getMessagesFromRoom(room.id)
+        const localResult = await this.messageLocalDataSourceService.getItems(room.id)
+
+        if(result.isOk()) {
+
+          const { addedItems, changedItems, deletedItems } = messageListDetermineChanges(result.value.data, localResult)
+
+          for(const message of changedItems) {
+            let clone: MessageTable = message
+            clone.roomId = room.id
+            this.messageLocalDataSourceService.findOrUpdate(clone)
+          }
+
+          for(const message of addedItems) {
+            let clone: MessageTable = message
+            clone.roomId = room.id
+          }
+
+
+          this.messageLocalDataSourceService.createManyMessage(addedItems.reverse())
+
+
+          for(const message of deletedItems) {
+            this.messageLocalDataSourceService.deleteByMessageId(message.id)
+          }
+
+        }
       }
+
+      return ok(true)
     } else {
-      console.log('get all error', allRooms)
+      console.log('sync all error', allRooms)
     }
 
   }

src/app/module/chat/domain/use-case/typing-send-use-case.service.ts

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { SignalRService } from '../../infra/socket/signal-r.service';
+import { SessionStore } from 'src/app/store/session.service';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class SendTypingUseCaseService {
+
+  constructor(
+    private messageLiveSignalRDataSourceService: SignalRService,
+  ) { }
+
+
+  execute(roomId) {
+    return this.messageLiveSignalRDataSourceService.sendTyping({
+      roomId,
+      UserName:SessionStore.user.FullName,
+      userId: SessionStore.user.UserId
+    })
+  }
+}