remove duplicate

src/app/module/chat/data/repository/message/message-live-signalr-data-source.service.ts

@@ -49,6 +49,10 @@ export class MessageSocketRepositoryService implements IMessageSocketRepository
       data: data,
     })
 
+    if(result.isOk()) {
+      console.log('recieve', result.value)
+    }
+
     return result;
   }
 

src/app/module/chat/data/repository/message/message-local-data-source.service.ts

@@ -6,6 +6,8 @@ import { Observable as  DexieObservable, PromiseExtended } from 'Dexie';
 import { MessageTable, MessageTableSchema } from 'src/app/infra/database/dexie/instance/chat/schema/message';
 import { chatDatabase } from 'src/app/infra/database/dexie/service';
 import { IMessageLocalRepository } from 'src/app/core/chat/repository/message/message-local-repository';
+import { combineLatest, from, Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
 
 @Injectable({
   providedIn: 'root'
@@ -49,5 +51,25 @@ export class MessageLocalDataSourceService extends DexieRepository<MessageTable,
       console.error('Error fetching messages:', error);
     }
   }
+
+
+
+  getLastMessageForRooms(roomIds: string[]): Observable<any[]> {
+    const observables = roomIds.map(roomId =>
+      from (liveQuery(async() =>{
+        const messages = await chatDatabase.message
+          .where('roomId')
+          .equals(roomId)
+          .reverse()
+          .sortBy('timestamp')
+
+        return messages[0] || null; // Return the first item (latest message) or null if no message
+      })).pipe(
+        map((message) => ({ roomId, message: message || null })) // Attach roomId to the result
+      )
+    );
+
+    return combineLatest(observables); // Combine all observables into one array of results
+  }
 }
 

src/app/module/chat/data/repository/room/room-local-repository.service.ts

@@ -20,7 +20,7 @@ export class RoomLocalRepository extends DexieRepository<RoomTable, RoomTable> i
   }
 
   getRoomByIdLive(id: any) {
-    return liveQuery(() => chatDatabase.room.get(id));
+    return from(liveQuery(() => chatDatabase.room.get(id)));
   }
 
 }

src/app/module/chat/data/repository/room/room-remote-repository.service.ts

@@ -12,6 +12,7 @@ import { RoomByIdOutputDTO } from 'src/app/module/chat/domain/use-case/room/room
 import { RoomUpdateInputDTO, RoomUpdateOutputDTO } from 'src/app/module/chat/domain/use-case/room/room-update-by-id-use-case.service';
 import { RoomListOutPutDTO } from '../../../domain/use-case/room/room-get-list-use-case.service';
 import { z } from 'zod';
+import { HttpAdapter } from 'src/app/infra/http/adapter';
 
 const RoomByIdInputDTOSchema =  z.string()
 type RoomByIdInputDTO = z.infer<typeof RoomByIdInputDTOSchema>
@@ -27,6 +28,7 @@ export class RoomRemoteDataSourceService implements IRoomRemoteRepository {
   constructor(
     private httpService: HttpService,
     private socket: SignalRService,
+    private Http: HttpAdapter
   ) {}
 
 
@@ -39,13 +41,17 @@ export class RoomRemoteDataSourceService implements IRoomRemoteRepository {
 
   //@APIReturn(RoomListOutPutDTOSchema, 'get/Room')
   async getRoomList(): Promise<DataSourceReturn<RoomListOutPutDTO>> {
-    return await this.httpService.get<RoomListOutPutDTO>(`${this.baseUrl}/Room?userId=${SessionStore.user.UserId}`);
+    const result = await this.Http.get<RoomListOutPutDTO>(`${this.baseUrl}/Room?userId=${SessionStore.user.UserId}`);
+
+    return result.map((e)=> e.data)
   }
 
   //@ValidateSchema(RoomByIdInputDTOSchema)
  //@APIReturn(RoomByIdOutputDTOSchema,'get/Room/${id}')
   async getRoom(id: RoomByIdInputDTO): DataSourceReturn<RoomByIdOutputDTO> {
-    return await this.httpService.get(`${this.baseUrl}/Room/${id}`);
+    const result = await this.Http.get(`${this.baseUrl}/Room/${id}`);
+
+    return result.map((e)=> e.data)
   }
 
   //@ValidateSchema(RoomUpdateInputDTOSchema)

src/app/module/chat/data/repository/typing/user-typing-live-data-source.service.ts

@@ -5,6 +5,8 @@ import { filter, map } from 'rxjs/operators';
 import { SocketMessage } from 'src/app/infra/socket/signalR/signalR';
 import { ITypingRemoteRepository } from 'src/app/core/chat/repository/typing/typing-remote-repository';
 import { z } from "zod"
+import { InstanceId } from '../../../domain/chat-service.service';
+import { v4 as uuidv4 } from 'uuid'
 
 export const UserTypingDTOSchema = z.object({
   requestId: z.string(),
@@ -29,10 +31,10 @@ export class UserTypingRemoteRepositoryService implements ITypingRemoteRepositor
     return this.socket.sendData({
       method: 'Typing',
       data: {
-        roomId, 
+        roomId,
         UserName:SessionStore.user.FullName,
         userId:SessionStore.user.UserId,
-        requestId: '',
+        requestId: InstanceId +'@'+ uuidv4(),
       },
     })
   }

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() {
+
+  }
+}