change room name for direct room

src/app/core/chat/entity/group.ts

@@ -1,4 +1,63 @@
+import { SessionStore } from "src/app/store/session.service";
+import { z } from "zod"
+
 export enum RoomType {
   Group = 1,
   Direct = 2
+}
+
+const UserSchema = z.object({
+  wxUserId: z.number(),
+  wxFullName: z.string(),
+  wxeMail: z.string(),
+  userPhoto: z.string().nullable(),
+});
+
+const MemberSchema = z.object({
+  id: z.string(),
+  user: UserSchema,
+  joinAt: z.string(),
+  isAdmin: z.boolean()
+});
+
+export const RoomEntitySchema = z.object({
+  id: z.string(),
+  roomName: z.string(),
+  createdBy: z.object({
+    wxUserId: z.number(),
+    wxFullName: z.string(),
+    wxeMail: z.string().email(),
+    userPhoto: z.string().nullable().optional()// api check
+  }),
+  createdAt: z.any(),
+  expirationDate: z.any().nullable(),
+  roomType: z.nativeEnum(RoomType),
+  members: z.array(MemberSchema).optional()
+})
+
+export type IRoomEntity = z.infer<typeof RoomEntitySchema>
+
+export class RoomEntity implements IRoomEntity{
+
+  id: typeof RoomEntitySchema._input.id
+  roomName: typeof RoomEntitySchema._input.roomName
+  createdBy: typeof RoomEntitySchema._input.createdBy
+  createdAt: typeof RoomEntitySchema._input.createdAt
+  expirationDate: typeof RoomEntitySchema._input.expirationDate
+  roomType: typeof RoomEntitySchema._input.roomType
+  members: typeof RoomEntitySchema._input.members
+
+  constructor(data: IRoomEntity) {
+    Object.assign(this, data)
+    if(data.roomType == RoomType.Direct) {
+      this.setName()
+    }
+  }
+
+  setName() {
+    const userChatName = this.members?.find((e) => e.user.wxUserId != SessionStore.user.UserId)
+    if(userChatName) {
+      this.roomName = userChatName.user.wxFullName
+    }
+  }
 }

src/app/core/chat/mapper/getRoomByIdMapper.ts

@@ -0,0 +1,17 @@
+import { RoomByIdOutputDTO } from "src/app/module/chat/domain/use-case/room/room-get-by-id-use-case.service";
+import { RoomEntity } from "../entity/group";
+
+export class GetRoomByIdMapper {
+  static toDomain(input: RoomByIdOutputDTO): RoomEntity {
+
+    return new RoomEntity({
+      createdAt: input.data.createdAt,
+      createdBy: input.data.createdBy,
+      expirationDate: input.data.expirationDate,
+      id: input.data.id,
+      members: input.data.members,
+      roomName: input.data.roomName,
+      roomType: input.data.roomType
+    })
+  }
+}

src/app/core/chat/mapper/getRoomListMapper.ts

@@ -0,0 +1,31 @@
+import { RoomListItemOutPutDTO } from "src/app/module/chat/domain/use-case/room/room-get-list-use-case.service";
+import { RoomEntity } from "../entity/group";
+import { captureAndReraiseAsync } from "src/app/services/decorators/captureAndReraiseAsync";
+
+export class GetRoomListMapper{
+
+  // @captureAndReraiseAsync('GetRoomListMapper/toDomain')
+  static toDomain(inputs: RoomListItemOutPutDTO[]): RoomEntity[] {
+
+    return inputs.map((roomData) => new RoomEntity({
+      createdAt: roomData.chatRoom.createdAt,
+      createdBy: roomData.chatRoom.createdBy,
+      expirationDate: roomData.chatRoom.expirationDate,
+      id: roomData.chatRoom.id,
+      roomName: roomData.chatRoom.roomName,
+      roomType: roomData.chatRoom.roomType,
+      members: [roomData.chatRoom.user1, roomData.chatRoom.user2].filter((e) => e?.wxUserId).map((b) => ({
+        id: '',
+        isAdmin: false,
+        joinAt: '',
+        user: {
+          userPhoto: b.userPhoto,
+          wxeMail: b.wxeMail,
+          wxFullName: b.wxFullName,
+          wxUserId: b.wxUserId
+        }
+      }))
+    }));
+
+  }
+}

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

@@ -36,63 +36,49 @@ export class SyncAllRoomMessagesService {
       }
 
       let n =0
-      for(const room of allRooms.value) {
+      const roomPromises = allRooms.value.map(async (room) => {
-
+        const [result, localResult] = await Promise.all([
-        const result = await this.messageRemoteDataSourceService.getMessagesFromRoom(room.id)
+          this.messageRemoteDataSourceService.getMessagesFromRoom(room.id),
-        const localResult = await this.messageLocalDataSourceService.getItems(room.id)
+          this.messageLocalDataSourceService.getItems(room.id)
-
+        ]);
-        tracing.addEvent('async n '+ n)
+      
-        n++
+        tracing.addEvent('async n ' + n);
-
+        n++;
-        if(result.isOk()) {
+      
-
+        if (result.isOk()) {
-          const { addedItems, changedItems, deletedItems } = messageListDetermineChanges(result.value.data, localResult)
+          const { addedItems, changedItems, deletedItems } = messageListDetermineChanges(result.value.data, localResult);
-
+      
-
+          for (const message of changedItems) {
-          for(const message of changedItems) {
+            let clone: MessageTable = { ...message, roomId: room.id };
-            let clone: MessageTable = message
+            await this.messageLocalDataSourceService.update(clone.$id, clone);
-            clone.roomId = room.id
+      
-
+            const me = message.info.find(e => e.memberId === SessionStore.user.UserId && typeof e.deliverAt === 'string');
-            this.messageLocalDataSourceService.update(clone.$id, clone)
+      
-
+            if (!me) {
-            const me = message.info.find(e => e.memberId == SessionStore.user.UserId && typeof e.deliverAt == 'string' )
-
-            if(!me) {
               this.MessageSocketRepositoryService.sendDeliverAt({
                 memberId: SessionStore.user.UserId,
                 messageId: message.id,
                 roomId: message.roomId,
                 requestId: uuidv4()
-              })
+              });
-
+      
-              tracing.addEvent('send delever roomId'+ room.id)
+              tracing.addEvent('send deliver roomId ' + room.id);
             }
           }
-
+      
-          for(const message of addedItems) {
+          for (const message of addedItems) {
-            let clone: MessageTable = message
+            let clone: MessageTable = { ...message, roomId: room.id };
-            clone.roomId = room.id
+            // You can perform operations with addedItems here if needed
-
-            // const me = message.info.find(e => e.memberId == SessionStore.user.UserId && typeof e.deliverAt == 'string' )
-            // if(!me) {
-            //   this.MessageSocketRepositoryService.sendDeliverAt({
-            //     memberId: SessionStore.user.UserId,
-            //     messageId: message.id,
-            //     roomId: message.roomId,
-            //     requestId: uuidv4()
-            //   })
-
-            //   tracing.addEvent('send delever roomId'+ room.id)
-
-            // }
           }
-
+      
-        this.messageLocalDataSourceService.insertMany(addedItems.reverse())
+          await this.messageLocalDataSourceService.insertMany(addedItems.reverse());
-
         } else {
-          Logger.error('failed to get room message '+room.id)
+          Logger.error('failed to get room message ' + room.id);
         }
-      }
+      });
+      
+      // Wait for all the promises to resolve
+      await Promise.all(roomPromises);
 
       return ok(true)
     } else {

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

@@ -9,6 +9,7 @@ import { z } from 'zod';
 import { IRoomRemoteRepository } from 'src/app/core/chat/repository/room/room-remote-repository';
 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';
 
 const UserSchema = z.object({
   wxUserId: z.number(),
@@ -72,6 +73,7 @@ export class GetRoomByIdUseCaseService {
         const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges([object], localListRoom.value)
 
         for( const roomData of  roomsToUpdate) {
+          // const room = GetRoomByIdMapper.toDomain(roomData)
           this.roomLocalDataSourceService.update(roomData.chatRoom.id, roomData.chatRoom)
         }
 
@@ -81,6 +83,7 @@ export class GetRoomByIdUseCaseService {
         const { membersToInsert, membersToUpdate, membersToDelete } = roomMemberListDetermineChanges(result.value.data.members, localList, id)
 
         for (const user of membersToInsert) {
+          
           await this.MemberListLocalRepository.addMember(MemberListMapper(user, id))
         }
 

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

@@ -5,6 +5,9 @@ import { CronJobService } from 'src/app/utils/task-scheduler'
 import { z } from "zod";
 import { IRoomRemoteRepository } from 'src/app/core/chat/repository/room/room-remote-repository';
 import { IRoomLocalRepository } from 'src/app/core/chat/repository/room/room-local-repository';
+import { MessageEntitySchema } from 'src/app/core/chat/entity/message';
+import { RoomEntity, RoomType } from 'src/app/core/chat/entity/group';
+import { GetRoomListMapper } from 'src/app/core/chat/mapper/getRoomListMapper';
 
 
 const CreatedBySchema = z.object({
@@ -15,14 +18,16 @@ const CreatedBySchema = z.object({
 });
 
 const RoomListItemOutPutDTOSchema = z.object({
-
   chatRoom: z.object({
     id: z.string(),
     roomName: z.string(),
     createdBy: CreatedBySchema,
     createdAt: z.string(),
     expirationDate: z.string().nullable(), // api check
-    roomType: z.number()
+    roomType: z.number(),
+    messages: MessageEntitySchema.array(),
+    user1: CreatedBySchema.nullable(),
+    user2: CreatedBySchema.nullable()
   }),
   joinAt: z.string()
 })
@@ -60,29 +65,31 @@ export class GetRoomListUseCaseService {
 
     if(localList.isOk()) {
       if(result.isOk()) {
+        
         const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges(result.value.data, localList.value)
 
-          for( const roomData of  roomsToInsert) {
+        if(roomsToInsert) {
-            this.roomLocalDataSourceService.insert(roomData.chatRoom)
+          const roomsToInsertEntity = GetRoomListMapper.toDomain(roomsToInsert)
-
+          for( const room of  roomsToInsertEntity) {
-            if(roomData.chatRoom.expirationDate) {
+            this.roomLocalDataSourceService.insert(room)
+            if(room.expirationDate) {
               console.log('room expiration date schedule')
-              this.CronJobService.createCronJob('remove expired room', new Date(roomData.chatRoom.expirationDate), this.execute)
+              this.CronJobService.createCronJob('remove expired room', new Date(room.expirationDate), this.execute)
             }
-
           }
+        }
+        
+        const roomsToUpdateEntity = GetRoomListMapper.toDomain(roomsToUpdate)
+        for( const room of  roomsToUpdateEntity) {
+          this.roomLocalDataSourceService.update(room.id, room)
+        }
 
-          for( const roomData of  roomsToUpdate) {
+        for( const room of  roomsToDelete) {
-            this.roomLocalDataSourceService.update(roomData.chatRoom.id, roomData.chatRoom)
+          this.roomLocalDataSourceService.delete(room.id)
-          }
+        }
-
-          for( const roomData of  roomsToDelete) {
-            this.roomLocalDataSourceService.delete(roomData.id)
-          }
 
       }
     }
-
     return result
   }
 

src/assets/js/shared-worker.js

@@ -1,12 +0,0 @@
-// src/shared-worker.js
-self.onconnect = function (event) {
-  const port = event.ports[0];
-  
-  port.onmessage = function (e) {
-    const message = e.data;
-    console.log('Received from client:', message);
-    
-    // Echo the message back to all connected clients
-    port.postMessage('Echo: ' + message);
-  }
-}

workspace.code-workspace

@@ -2,6 +2,9 @@
     "folders": [
 		{
 			"path": "."
+		},
+		{
+			"path": "../../../Downloads/nestjs-microservice-boilerplate-api-master"
 		}
 	],
     "settings": {