set member to admin

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

@@ -12,8 +12,8 @@ export function roomListDetermineChanges(serverRooms: RoomListItemOutPutDTO[], l
       room.chatRoom.roomName !== localRoom.roomName ||
       room.chatRoom.createdBy.wxUserId !== localRoom.createdBy.wxUserId ||
       room.chatRoom.createdAt !== localRoom.createdAt ||
-      room.chatRoom.expirationDate !== localRoom.expirationDate ||
-      room.chatRoom.roomType !== localRoom.roomType
+      room.chatRoom.expirationDate !== localRoom.expirationDate // ||
+      // room.chatRoom.roomType !== localRoom.roomType
     );
   });
   const roomsToDelete = localRooms.filter(room => !serverRoomMap.has(room.id));

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

@@ -18,9 +18,10 @@ export function roomMemberListDetermineChanges(____serverRooms: RoomByIdMemberIt
   const membersToUpdate = PServerRooms.filter(room => {
   const localRoom = localRoomMap.get(room.$roomIdUserId);
     return localRoom && (
-      room.user.wxUserId !== localRoom.user.wxUserId ||
-      room.user.userPhoto !== localRoom.user.userPhoto ||
-      room.joinAt  !== localRoom.joinAt
+      room.user.wxUserId !== localRoom.wxUserId ||
+      room.user.userPhoto !== localRoom.userPhoto ||
+      room.joinAt  !== localRoom.joinAt,
+      room.isAdmin !== localRoom.isAdmin
     )
   });
 

src/app/module/chat/data/data-source/member-list/member-list-local-data-source.service.ts

@@ -0,0 +1,49 @@
+import { Injectable } from '@angular/core';
+import { RoomListItemOutPutDTO, RoomListOutPutDTO } from '../../dto/room/roomListOutputDTO';
+import { Dexie, EntityTable, liveQuery, Observable } from 'Dexie';
+import { z } from 'zod';
+import { DexieRepository } from 'src/app/infra/repository/dexie/dexie-repository.service';
+
+
+const TableMemberListSchema = z.object({
+  $roomIdUserId: z.string().optional(),
+  id: z.string(),
+  roomId: z.string(),
+  user: z.object({
+    wxUserId: z.number(),
+    wxFullName: z.string(),
+    wxeMail: z.string(),
+    userPhoto: z.string().nullable(),
+  }),
+  joinAt: z.string(),
+  status: z.string()
+})
+
+export type ITableMemberList = z.infer<typeof TableMemberListSchema>
+
+type ITableMemberListSchema = EntityTable<ITableMemberList, '$roomIdUserId'> 
+// Database declaration (move this to its own module also)
+export const roomMemberList = new Dexie('roomMemberList') as Dexie & {
+  memberList: EntityTable<ITableMemberList, '$roomIdUserId'>;
+};
+
+roomMemberList.version(1).stores({
+  memberList: '$roomIdUserId, id, user, joinAt, roomId, status',
+});
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MemberListLocalDataSourceService extends DexieRepository<ITableMemberListSchema, ITableMemberList> {
+
+  constructor() {
+    super(roomMemberList.memberList);
+
+    // messageDataSource.message.hook('creating', (primKey, obj, trans) => {
+    //   // const newMessage = await trans.table('message').get(primKey);
+    //   this.messageSubject.next(obj);
+    //   // return newMessage
+    // })
+
+  }
+}

src/app/module/chat/data/data-source/member-list/member-list-remote-data-source.service.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@angular/core';
+import { Result } from 'neverthrow';
+import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
+import { HttpService } from 'src/app/services/http.service';
+import { DataSourceReturn } from 'src/app/services/Repositorys/type';
+import { AddMemberToRoomInputDTOSchema, AddMemberToRoomInputDTO } from '../../dto/room/addMemberToRoomInputDto';
+import { UserRemoveListInputDTOSchema, UserRemoveListInputDTO } from '../../dto/room/userRemoveListInputDTO';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MemberListRemoteDataSourceService {
+
+  private baseUrl = 'https://gdapi-dev.dyndns.info/stage/api/v2/Chat'; // Your base URL
+
+  constructor(private httpService: HttpService) { }
+
+
+  @ValidateSchema(AddMemberToRoomInputDTOSchema)
+  async addMemberToRoom(data: AddMemberToRoomInputDTO): DataSourceReturn<AddMemberToRoomInputDTO> {
+    return await this.httpService.post<any>(`${this.baseUrl}/Room/${data.id}/Member`, { members:data.members });
+  }
+
+
+  @ValidateSchema(UserRemoveListInputDTOSchema)
+  async removeMemberFromRoom(data: UserRemoveListInputDTO): Promise<Result<any ,any>> {
+    return await this.httpService.delete<any>(`${this.baseUrl}/Room/${data.id}/Member`, {members:data.members});
+  }
+
+}

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

@@ -8,8 +8,8 @@ import { MessageInputDTO } from '../../dto/message/messageInputDtO';
 
 
 const tableSchema = z.object({
-  id: z.any().optional(),
-  messageId: z.string().optional(),
+  $id: z.any().optional(),
+  id: z.string().optional(),
   roomId: z.string().uuid(),
   message: z.string(),
   messageType: z.number(),
@@ -49,11 +49,11 @@ export type TableMessage = z.infer<typeof tableSchema>
 
 // Database declaration (move this to its own module also)
 export const messageDataSource = new Dexie('chat-message') as Dexie & {
-  message: EntityTable<TableMessage, 'id'>;
+  message: EntityTable<TableMessage, '$id'>;
 };
 
 messageDataSource.version(1).stores({
-  message: '++id, roomId, message, messageType, canEdit, oneShot, requireUnlock, messageId, info'
+  message: '++$id, id, roomId, message, messageType, canEdit, oneShot, requireUnlock, messageId, info'
 });
 
 @Injectable({
@@ -88,12 +88,12 @@ export class MessageLocalDataSourceService {
     }
   }
 
-  async deleteByMessageId(messageId: string): Promise<Result<undefined|TableMessage, any>> {
+  async deleteByMessageId(id: string): Promise<Result<undefined|TableMessage, any>> {
     try {
-      console.log(messageId)
+      console.log(id)
       const lastMessage = await messageDataSource.message
-        .where('messageId')
-        .equals(messageId).delete()
+        .where('id')
+        .equals(id).delete()
 
       return ok(lastMessage[0]); // Get the last message
     } catch (error) {
@@ -134,14 +134,14 @@ export class MessageLocalDataSourceService {
   }
 
 
-  async messageExist({messageId}) {
+  async messageExist({id}) {
     try {
 
-      console.log({messageId});
+      console.log({id});
 
       const existingMessage = await messageDataSource.message
-      .where('messageId')
-      .equals(messageId)
+      .where('id')
+      .equals(id)
       .first();
 
       if (existingMessage) {
@@ -159,7 +159,7 @@ export class MessageLocalDataSourceService {
   async update(data: TableMessage ) {
 
     try {
-      const result = await messageDataSource.message.update(data.id, data)
+      const result = await messageDataSource.message.update(data.$id, data)
       return ok(result)
     } catch (e) {
       return err(false)
@@ -181,7 +181,7 @@ export class MessageLocalDataSourceService {
 
 
   async findOrUpdate(data: TableMessage) {
-    const findResult = await this.findMessageById(data.messageId)
+    const findResult = await this.findMessageById(data.id)
 
     if(findResult.isOk()) {
       return this.update({...findResult.value, ...data})
@@ -192,14 +192,14 @@ export class MessageLocalDataSourceService {
 
   getItemsLive(roomId: string) {
     return liveQuery(() =>
-      messageDataSource.message.where('roomId').equals(roomId).sortBy('id')
+      messageDataSource.message.where('roomId').equals(roomId).sortBy('$id')
     )
   }
 
 
-  async findMessageById(messageId: string) {
+  async findMessageById(id: string) {
     try {
-      const a = await messageDataSource.message.where('messageId').equals(messageId).first()
+      const a = await messageDataSource.message.where('id').equals(id).first()
 
       if(a) {
         return ok(a)

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

@@ -14,6 +14,7 @@ import { RoomUpdateInputDTO, RoomUpdateInputDTOSchema } from '../../dto/room/roo
 import { RoomUpdateOutputDTO } from '../../dto/room/roomUpdateOutputDTO';
 import { DataSourceReturn } from 'src/app/services/Repositorys/type';
 import { SessionStore } from 'src/app/store/session.service';
+import { MemberSetAdminDTO } from '../../../domain/use-case/member-admin-use-case.service';
 
 @Injectable({
   providedIn: 'root'
@@ -66,4 +67,8 @@ export class RoomRemoteDataSourceService {
     return await this.httpService.delete<any>(`${this.baseUrl}/Room/${data.id}/Member`, {members:data.members});
   }
 
+  async setAmin(data: MemberSetAdminDTO): Promise<Result<any ,any>> {
+    return await this.httpService.patch<any>(`${this.baseUrl}/Room/${data.roomId}/Member/${data.memberId}/admin`);
+  }
+
 }

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

@@ -4,6 +4,7 @@ import { Dexie, EntityTable, liveQuery, Observable } from 'Dexie';
 import { err, ok, Result } from 'neverthrow';
 import { z } from 'zod';
 import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
+import { MemberListUPdateStatusInputDTO } from '../../../domain/use-case/socket/member-list-update-status-use-case.service';
 
 const tableSchema = z.object({
   id: z.string(),
@@ -15,29 +16,20 @@ const tableSchema = z.object({
     userPhoto: z.string().nullable().optional()// api check
   }),
   createdAt: z.any(),
-  expirationDate: z.any(),
-  roomType: z.any(),
-  // lastMessage: z.object({
-  //   sentAt: z.string(),
-  //   message: z.string(),
-  //   sender: z.object({
-  //     wxUserId: z.any(),
-  //     wxFullName: z.any(),
-  //   }).optional(),s
-  // })
+  expirationDate: z.any().nullable(),
 })
 
 const TableMemberListSchema = z.object({
   $roomIdUserId: z.string().optional(),
   id: z.string(),
   roomId: z.string(),
-  user: z.object({
-    wxUserId: z.number(),
-    wxFullName: z.string(),
-    wxeMail: z.string(),
-    userPhoto: z.string().nullable(),
-  }),
-  joinAt: z.string()
+  wxUserId: z.number(),
+  wxFullName: z.string(),
+  wxeMail: z.string(),
+  userPhoto: z.string().nullable(),
+  joinAt: z.string(),
+  status: z.string(),
+  isAdmin: z.boolean()
 })
 
 
@@ -62,8 +54,8 @@ export const roomDataSource = new Dexie('FriendDatabase') as Dexie & {
 
 roomDataSource.version(1).stores({
   room: 'id, createdBy, roomName, roomType, expirationDate, lastMessage',
-  memberList: '$roomIdUserId, id, user, joinAt, roomId',
-  TypingList: '++id, userId, roomId, entryDate'
+  memberList: '$roomIdUserId, userId, id, user, joinAt, roomId, status, wxUserId, isAdmin',
+  TypingList: '++id, userId, roomId, entryDate',
 });
 
 @Injectable({
@@ -137,7 +129,7 @@ export class RoomLocalDataSourceService {
 
   async addMember(data: TableMemberList) {
     try {
-      data.$roomIdUserId = data.roomId + data.user.wxUserId
+      data.$roomIdUserId = data.roomId + data.wxUserId
       const result = await roomDataSource.memberList.add(data)
       return ok(result)
     } catch (e) {
@@ -145,6 +137,44 @@ export class RoomLocalDataSourceService {
     }
   }
 
+  async updateMemberRole(data: TableMemberList) {
+    try {  
+      const result = await roomDataSource.memberList.where({
+        wxUserId:data.wxUserId,
+        roomId: data.roomId,
+      }).modify(data);
+
+      return ok(result)
+    } catch (e) {
+      return err(false)
+    }
+  }
+
+  async updateMembersStatus(data: MemberListUPdateStatusInputDTO) {
+    try {
+      await roomDataSource.memberList.toCollection().modify({ status: 'offline' });
+      for (const item of data) {
+        const wxUserId = item.value.userId; // Extract wxUserId
+        await roomDataSource.memberList.where('wxUserId').equals(wxUserId).modify({ status: 'online' });
+      }
+      return ok(true)
+    } catch (error) {
+      console.error("Error updating user statuses:", error);
+      return err(error)
+    }
+  }
+
+  allMemberOnline(roomId:string) {
+    return liveQuery(async () => {
+
+      const allMessages = await roomDataSource.memberList
+        .where('roomId')
+        .equals(roomId)
+        .toArray();
+
+      return allMessages.every(message => message?.status === "online");
+    });
+  }
 
   async removeMemberFromRoom($roomIdUserId): Promise<Result<any ,any>> {
     try {
@@ -193,10 +223,17 @@ export class RoomLocalDataSourceService {
   }
 
   async getRoomMemberById(roomId: any) {
-    return await  roomDataSource.memberList.where('roomId').equals(roomId).toArray()
+    return await  roomDataSource.memberList.where({roomId}).toArray()
   }
   getRoomMemberByIdLive(roomId: any) {
-    return liveQuery(() => roomDataSource.memberList.where('roomId').equals(roomId).toArray())
+    return liveQuery(() => roomDataSource.memberList.where({roomId}).toArray())
+  }
+
+  getRoomMemberNoneAdminByIdLive(roomId: any) {
+    return liveQuery(async() => {
+      const members = await roomDataSource.memberList.where({roomId}).toArray()
+      return members.filter(e => e.isAdmin != true)
+    })
   }
 
 }

src/app/module/chat/data/dto/room/roomInputDTO.ts

@@ -4,7 +4,7 @@ export const RoomInputDTOSchema = z.object({
   roomName: z.string(),
   createdBy: z.number(),
   roomType: z.number(),
-  expirationDate: z.string().datetime().nullable(),
+  expirationDate: z.string().nullable().optional(),
   members: z.array(z.number())
 });
 

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

@@ -59,8 +59,8 @@ export class MessageRepositoryService {
 
         let clone: TableMessage = {
           ...sendMessageResult.value,
-          messageId: sendMessageResult.value.id,
-          id : localActionResult.value
+          id: sendMessageResult.value.id,
+          $id : localActionResult.value
         }
 
         // console.log({clone})
@@ -89,7 +89,7 @@ export class MessageRepositoryService {
     if(result.isOk()) {
       if(result.value) {
 
-        return await this.messageLiveSignalRDataSourceService.sendReadAt({roomId, memberId: SessionStore.user.UserId, chatMessageId: result.value.messageId})
+        return await this.messageLiveSignalRDataSourceService.sendReadAt({roomId, memberId: SessionStore.user.UserId, chatMessageId: result.value.id})
       }
       return ok(true)
     }
@@ -117,10 +117,7 @@ export class MessageRepositoryService {
 
       for(const message of result.value.data) {
         let clone: TableMessage = message
-        clone.messageId = message.id
         clone.roomId = id
-        delete clone.id
-
         await this.messageLocalDataSourceService.findOrUpdate(clone)
       }
     }

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

@@ -13,6 +13,9 @@ import { SessionStore } from 'src/app/store/session.service';
 import { RoomLiveDataSourceService } from '../data-source/room/room-live-data-source.service';
 import { isHttpResponse } from 'src/app/services/http.service';
 import { MessageLiveDataSourceService } from '../data-source/message/message-live-data-source.service';
+import { MemberListUPdateStatusInputDTO } from '../../domain/use-case/socket/member-list-update-status-use-case.service';
+import { MemberSetAdminDTO } from '../../domain/use-case/member-admin-use-case.service';
+import { MemberListMapper } from '../../domain/mapper/memberLIstMapper';
 
 
 function date(isoDateString) {
@@ -54,46 +57,36 @@ export class RoomRepositoryService {
      const { roomsToDelete, roomsToInsert, roomsToUpdate } = roomListDetermineChanges(result.value.data, localList)
 
       for( const roomData of  roomsToInsert) {
-
-        // roomData["lastMessage"] = {
-        //   sentAt: date(roomData.createdAt),
-        //   message: "",
-        //   sender: {
-        //     wxUserId: "",
-        //     wxFullName: "",
-        //   },
-        // }
-
         this.roomLocalDataSourceService.createRoom(roomData.chatRoom)
       }
 
       for( const roomData of  roomsToUpdate) {
-
-        // roomData["lastMessage"] = {
-        //   sentAt: date(roomData.createdAt),
-        //   message: "",
-        //   sender: {
-        //     wxUserId: "",
-        //     wxFullName: "",
-        //   },
-        // }
-
         this.roomLocalDataSourceService.updateRoom(roomData.chatRoom)
       }
 
       for( const roomData of  roomsToDelete) {
-
-        // roomData["lastMessage"] = {
-        //   sentAt: date(roomData.createdAt),
-        //   message: "",
-        //   sender: {
-        //     wxUserId: 0,
-        //     wxFullName: "",
-        //   },
-        // }
-
         this.roomLocalDataSourceService.deleteRoomById(roomData.id)
       }
+
+      try {
+        const rooms = roomsToInsert.concat(roomsToUpdate)
+
+        for(const room of rooms) {
+          const expirationDate = new Date(room.chatRoom.expirationDate);
+          const now = new Date();
+          if (room.chatRoom.expirationDate != null && expirationDate.getTime() >= now.getTime()) {
+            const timeRemaining = expirationDate.getTime() - now.getTime();
+            setTimeout(() => {
+              this.list()
+            }, timeRemaining)
+          }
+          
+        }
+      } catch (error) {
+        console.log(error)
+      }
+
+  
     }
     return result
   }
@@ -142,20 +135,17 @@ export class RoomRepositoryService {
       const { membersToInsert, membersToUpdate, membersToDelete } = roomMemberListDetermineChanges(result.value.data.members, localList, id)
 
       for (const user of membersToInsert) {
-        await this.roomLocalDataSourceService.addMember({...user, roomId:id})
+        await this.roomLocalDataSourceService.addMember(MemberListMapper(user, id))
+      }
+
+      for (const user of membersToUpdate) {
+        await this.roomLocalDataSourceService.updateMemberRole(MemberListMapper(user, id))
       }
 
       for(const user of membersToDelete) {
         await this.roomLocalDataSourceService.removeMemberFromRoom(user.$roomIdUserId)
       }
 
-      const __localListRoom = await this.roomLocalDataSourceService.getRoomList()
-
-      // this.roomLiveDataSourceService.getRoomById({
-      //   type:'memberList',
-      //   payload: __localListRoom
-      // })
-
     } else if (isHttpResponse(result.error) ) {
       if(result.error.status == 404) {
         await this.roomLocalDataSourceService.deleteRoomById(id)
@@ -238,6 +228,12 @@ export class RoomRepositoryService {
     return result
   }
 
+  async updateMemberStatus(data: MemberListUPdateStatusInputDTO) {
+    const result = await this.roomLocalDataSourceService.updateMembersStatus(data)
+
+    return result
+  }
+
 
   @captureAndReraiseAsync('RoomRepositoryService/removeMemberToRoom')
   async removeMemberToRoom(data: UserRemoveListInputDTO) {
@@ -246,6 +242,11 @@ export class RoomRepositoryService {
     return result
   }
 
+  setAdmin(input: MemberSetAdminDTO) {
+    return this.roomRemoteDataSourceService.setAmin(input);
+  }
+
+
 
   async leaveRoom(data: UserRemoveListInputDTO) {
     const result = await this.roomRemoteDataSourceService.removeMemberFromRoom(data)
@@ -280,4 +281,13 @@ export class RoomRepositoryService {
     return this.roomLocalDataSourceService.getRoomMemberById(roomId)
   }
 
+
+  getRoomStatus(roomId:string) {
+    return this.roomLocalDataSourceService.allMemberOnline(roomId);
+  }
+
+
+  getRoomMemberNoneAdminByIdLive(roomId) {
+    return this.roomLocalDataSourceService.getRoomMemberNoneAdminByIdLive(roomId)
+  }
 }

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

@@ -3,10 +3,12 @@ import { MessageDeleteLiveUseCaseService, MessageDeleteInputDTO } from 'src/app/
 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 { MemberAdminUseCaseService, MemberSetAdminDTO } from 'src/app/module/chat/domain/use-case/member-admin-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 { MemberListUpdateStatusUseCaseService } from 'src/app/module/chat/domain/use-case/socket/member-list-update-status-use-case.service';
 import { filter } from 'rxjs/operators';
 import { InstanceId } from '../data/repository/message-respository.service';
 
@@ -22,7 +24,9 @@ export class ChatServiceService {
     private SocketMessageDeleteUseCaseService: SocketMessageDeleteUseCaseService,
     private messageLiveSignalRDataSourceService: SignalRService,
     private SocketMessageUpdateUseCaseService: SocketMessageUpdateUseCaseService,
-    private SocketMessageCreateUseCaseService: SocketMessageCreateUseCaseService
+    private SocketMessageCreateUseCaseService: SocketMessageCreateUseCaseService,
+    private MemberListUpdateStatusUseCaseService: MemberListUpdateStatusUseCaseService,
+    private MemberAdminUseCaseService: MemberAdminUseCaseService
   ) {
     this.messageLiveSignalRDataSourceService.getMessageDelete()
     .pipe()
@@ -30,7 +34,6 @@ export class ChatServiceService {
       if(message?.id) {
         this.SocketMessageDeleteUseCaseService.execute(message)
       }
-
     })
 
     this.messageLiveSignalRDataSourceService.getMessageUpdate().pipe(
@@ -38,7 +41,6 @@ export class ChatServiceService {
         return !message?.requestId?.startsWith(InstanceId)
       })
     ).subscribe(async (message) => {
-
       if(message?.id) {
         this.SocketMessageUpdateUseCaseService.execute(message)
       }
@@ -61,6 +63,18 @@ export class ChatServiceService {
 
     })
 
+    this.messageLiveSignalRDataSourceService.getData().pipe(
+      filter((message) => {
+        if(message?.method == 'AvailableUsers') {
+          // console.log('exclude my message---')
+          return true
+        }
+      })
+    ).subscribe(async (message) => {
+      console.log('123', message)
+      this.MemberListUpdateStatusUseCaseService.execute(message.data as any)
+    })
+
   }
 
   messageDelete(data: {roomId, messageId}) {
@@ -80,5 +94,9 @@ export class ChatServiceService {
   updateMessage(input: MessageUpdateInput) {
     return this.MessageUpdateUseCaseService.execute(input);
   }
+
+  setAdmin(input: MemberSetAdminDTO) {
+    return this.MemberAdminUseCaseService.execute(input)
+  }
 }
 

src/app/module/chat/domain/mapper/memberLIstMapper.ts

@@ -0,0 +1,14 @@
+import { TableMemberList } from "../../data/data-source/room/rooom-local-data-source.service";
+import { RoomByIdMemberItemOutputDTO } from "../../data/dto/room/roomByIdOutputDTO";
+
+export function MemberListMapper(outputDto: RoomByIdMemberItemOutputDTO, roomId: string): TableMemberList {
+  return {
+    roomId: roomId,
+    wxUserId: outputDto.user.wxUserId,
+    wxFullName: outputDto.user.wxFullName,
+    wxeMail: outputDto.user.wxFullName,
+    userPhoto: outputDto.user.userPhoto,
+    joinAt: outputDto.joinAt,
+    isAdmin: outputDto.isAdmin
+  }
+}

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

@@ -0,0 +1,29 @@
+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';
+
+// Define the schema for the entire response
+const MemberSetAdminDTOSchema = z.object({
+  roomId: z.string(),
+  memberId: z.string()
+});
+
+export type MemberSetAdminDTO = z.infer<typeof MemberSetAdminDTOSchema>
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MemberAdminUseCaseService {
+
+  constructor(
+    public repository: RoomRepositoryService
+  ) { }
+
+  @ValidateSchema(MemberSetAdminDTOSchema)
+  execute(input: MemberSetAdminDTO) {
+
+    return this.repository.setAdmin(input)
+  }
+}

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

@@ -1,9 +1,10 @@
 import { Injectable } from '@angular/core';
 import { z } from 'zod';
 import { MessageRepositoryService } from '../../data/repository/message-respository.service';
+import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
 
 export const MessageDeleteInputDTOSchema = z.object({
-  requestId: z.string(),
+  requestId: z.string().optional(),
   roomId: z.string(),
   messageId: z.string(),
   senderId: z.number(),
@@ -19,6 +20,7 @@ export class MessageDeleteLiveUseCaseService {
     public repository: MessageRepositoryService
   ) { }
 
+  @ValidateSchema(MessageDeleteInputDTOSchema)
   async execute(data: MessageDeleteInputDTO) {
     return this.repository.sendMessageDelete(data)
   }

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

@@ -1,6 +1,7 @@
 import { Injectable } from '@angular/core';
 import { MessageRepositoryService } from '../../data/repository/message-respository.service';
 import { object, z } from 'zod';
+import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
 
 
 const MessageReactionInputDTOSchema = z.object({
@@ -8,7 +9,7 @@ const MessageReactionInputDTOSchema = z.object({
   messageId: z.string(),
   roomId: z.string(),
   reaction: z.string(),
-  requestId: z.string()
+  requestId: z.string().optional()
 })
 
 export type MessageReactionInput = z.infer< typeof MessageReactionInputDTOSchema>
@@ -22,6 +23,7 @@ export class MessageReactionUseCaseService {
     public repository: MessageRepositoryService
   ) { }
 
+  @ValidateSchema(MessageReactionInputDTOSchema)
   execute(input: MessageReactionInput) {
     return this.repository.reactToMessage(input)
   }

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

@@ -1,13 +1,14 @@
 import { Injectable } from '@angular/core';
 import { z } from 'zod';
 import { MessageRepositoryService } from '../../data/repository/message-respository.service';
+import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
 
 const MessageUpdateInputDTOSchema = z.object({
   memberId: z.number(),
   messageId: z.string(),
   roomId: z.string(),
   message: z.string(),
-  requestId: z.string()
+  requestId: z.string().optional()
 })
 
 export type MessageUpdateInput = z.infer< typeof MessageUpdateInputDTOSchema>
@@ -22,8 +23,9 @@ export class MessageUpdateUseCaseService {
     public repository: MessageRepositoryService
   ) { }
 
+  @ValidateSchema(MessageUpdateInputDTOSchema)
   execute(input: MessageUpdateInput) {
-    this.repository.updateMessage(input);
+    return this.repository.updateMessage(input);
   }
 
 }

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

@@ -0,0 +1,31 @@
+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';
+
+export const MemberListUPdateStatus = z.object({
+  key: z.string(),
+  value: z.object({
+    userId: z.number(),
+    userName: z.string()
+  })
+}).array();
+export type MemberListUPdateStatusInputDTO = z.infer<typeof MemberListUPdateStatus>
+
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MemberListUpdateStatusUseCaseService {
+
+  constructor(
+    private RoomRepositoryService: RoomRepositoryService
+  ) { }
+
+
+  @ValidateSchema(MemberListUPdateStatus)
+  execute(input: MemberListUPdateStatusInputDTO) {
+    console.log
+    return this.RoomRepositoryService.updateMemberStatus(input)
+  }
+}

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

@@ -12,16 +12,14 @@ export class SocketMessageCreateUseCaseService {
 
   async execute(input: any) {
 
-  const id = input.id + ''
-  delete input.id;
-
     const incomingMessage =  {
       ...input,
-      messageId: id,
       sending: false,
       roomId:input.chatRoomId
     }
 
+    delete input.chatRoomId
+
     const result = await this.messageLocalDataSourceService.sendMessage(incomingMessage)
 
     if(result.isOk()) {

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

@@ -13,19 +13,16 @@ export class SocketMessageUpdateUseCaseService {
 
 
   async execute(data: MessageOutPutDataDTO) {
-    const result = await this.messageLocalDataSourceService.messageExist({messageId: data.id})
-
-
-    const id = data.id + ''
-    delete data.id;
+    const result = await this.messageLocalDataSourceService.messageExist({id: data.id})
 
     const incomingMessage =  {
       ...data,
-      messageId: id,
       sending: false,
       roomId:data.chatRoomId
     }
 
+    // delete data.chatRoomId
+
     if(result.isOk()) {
       console.log('message exist')
       return this.messageLocalDataSourceService.update({...result.value, ...incomingMessage})

src/app/module/chat/infra/socket/signal-r.service.ts

@@ -31,7 +31,7 @@ export class SignalRService {
   private connectingSubject: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(null);
   private messageDelete: BehaviorSubject<MessageOutPutDataDTO> = new BehaviorSubject<MessageOutPutDataDTO>(null);
   private messageUpdateSubject: BehaviorSubject<MessageOutPutDataDTO> = new BehaviorSubject<MessageOutPutDataDTO>(null);
-  private sendDataSubject: BehaviorSubject<Object> = new BehaviorSubject<Object>(false);
+  private sendDataSubject: BehaviorSubject<{method: string, data: any}> = new BehaviorSubject<{method: string, data: any}>(null);
 
   private deadConnectionBackGround: Subject<any>;
 
@@ -129,7 +129,7 @@ export class SignalRService {
   }
 
   getData() {
-    return this.getData()
+    return this.sendDataSubject.asObservable()
   }
 
   async sendMessage(data: Object) {

src/app/module/chat/infra/socket/signalR.ts

@@ -24,7 +24,7 @@ export class SignalRConnection {
   private sendLaterSubject: BehaviorSubject<Object> = new BehaviorSubject<Object>(false);
   private reconnect = true
 
-  private sendDataSubject: BehaviorSubject<Object> = new BehaviorSubject<Object>(false);
+  private sendDataSubject: BehaviorSubject<{method: string, data: any}> = new BehaviorSubject<{method: string, data: any}>(null);
 
   url: string
 
@@ -264,6 +264,15 @@ export class SignalRConnection {
       })
     });
 
+    this.hubConnection.on('AvailableUsers', (data: any) => {
+      console.log('AvailableUsers', data)
+      this.typingSubject.next(data);
+      this.sendDataSubject.next({
+        method: 'AvailableUsers',
+        data: data
+      })
+    });
+
     this.hubConnection.on('ReadAt', (_message) => {
       console.log('ReadAt', _message)
       this.readAtSubject.next(_message);