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