set member to admin

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