show member toroom

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

@@ -7,6 +7,9 @@ import { RoomOutPutDTO } from '../../dto/room/roomOutputDTO';
 import { AddMemberToRoomInputDTO, AddMemberToRoomInputDTOSchema } from '../../dto/room/addMemberToRoomInputDto';
 import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
 import { DataSourceReturn } from '../../../type';
+import { RoomByIdInputDTO, RoomByIdInputDTOSchema } from '../../dto/room/roomByIdInputDTO';
+import { RoomByIdOutputDTO, RoomByIdOutputDTOSchema } from '../../dto/room/roomByIdOutputDTO';
+import { APIReturn } from 'src/app/services/decorators/api-validate-schema.decorator';
 
 @Injectable({
   providedIn: 'root'
@@ -27,8 +30,10 @@ export class RoomRemoteDataSourceService {
     return await this.httpService.get<RoomListOutPutDTO>(`${this.baseUrl}/Room`);
   }
 
-  async getRoom(id: string): Promise<Result<any ,any>> {
-    return await this.httpService.get<any>(`${this.baseUrl}/Room/${id}`);
+  @ValidateSchema(RoomByIdInputDTOSchema)
+  @APIReturn(RoomByIdOutputDTOSchema)
+  async getRoom(id: RoomByIdInputDTO): DataSourceReturn<RoomByIdOutputDTO> {
+    return await this.httpService.get(`${this.baseUrl}/Room/${id}`);
   }
 
   async updateRoom(id: string, room: any): Promise<Result<any ,any>> {

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

@@ -1,12 +1,10 @@
 import { Injectable } from '@angular/core';
-import { AddMemberToRoomInputDTO } from '../../dto/room/addMemberToRoomInputDto';
 import { RoomListItemOutPutDTO, RoomListOutPutDTO } from '../../dto/room/roomListOutputDTO';
 import { Dexie, EntityTable, liveQuery } from 'Dexie';
 import { err, ok } from 'neverthrow';
 import { Observable } from 'rxjs';
-import { RoomOutPutDTO } from '../../dto/room/roomOutputDTO';
 import { z } from 'zod';
-
+import { UserList } from '../../../contacts/data-source/contacts-data-source.service';
 
 
 const tableSchema = z.object({
@@ -17,20 +15,34 @@ const tableSchema = z.object({
   expirationDate: z.any(),
   roomType: z.any()
 })
+
+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(),
+})
+
 export type TableRoom = z.infer<typeof tableSchema>
+export type TableMemberList = z.infer<typeof TableMemberListSchema>
 
 // Database declaration (move this to its own module also)
 export const roomDataSource = new Dexie('FriendDatabase') as Dexie & {
   room: EntityTable<TableRoom, 'id'>;
+  memberList: EntityTable<TableMemberList, '$roomIdUserId'>;
 };
 
-
-
 roomDataSource.version(1).stores({
-  room: 'id, createdBy, roomName, roomType, expirationDate'
+  room: 'id, createdBy, roomName, roomType, expirationDate',
+  memberList: '$roomIdUserId, id, user, joinAt, roomId',
 });
 
-
 @Injectable({
   providedIn: 'root'
 })
@@ -40,7 +52,6 @@ export class RoomLocalDataSourceService {
 
   constructor() {}
 
-
   async createRoom(data: TableRoom) {
     try {
       const result = await roomDataSource.room.add(data)
@@ -70,6 +81,17 @@ export class RoomLocalDataSourceService {
     }
   }
 
+
+  async addMember(data: TableMemberList) {
+    try {
+      data.$roomIdUserId = data.roomId + data.user.wxUserId
+      const result = await roomDataSource.memberList.add(data)
+      return ok(result)
+    } catch (e) {
+      return err(false)
+    }
+  }
+
   async getRoomById(id: any) {
     try {
       const result = await roomDataSource.room.get(id)
@@ -77,7 +99,6 @@ export class RoomLocalDataSourceService {
     } catch (e) {
       return err(false)
     }
-
   }
 
   getItemsLive(): Observable<RoomListOutPutDTO[]> {
@@ -88,5 +109,9 @@ export class RoomLocalDataSourceService {
     return liveQuery(() => roomDataSource.room.get(id)) as any;
   }
 
+  getRoomMemberByIdLive(roomId: any): Observable<TableMemberList[] | undefined> {
+    return liveQuery(() => roomDataSource.memberList.where('roomId').equals(roomId).toArray()) as any;
+  }
+
 }
 

src/app/services/Repositorys/chat/dto/room/roomByIdInputDTO.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+
+export const RoomByIdInputDTOSchema =  z.string()
+
+
+export type RoomByIdInputDTO = z.infer<typeof RoomByIdInputDTOSchema>

src/app/services/Repositorys/chat/dto/room/roomByIdOutputDTO.ts

@@ -0,0 +1,31 @@
+import { z } from "zod";
+
+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(),
+});
+
+export const RoomByIdOutputDTOSchema = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  data: z.object({
+    id: z.string(),
+    roomName: z.string(),
+    createdBy: UserSchema,
+    createdAt: z.string(),
+    expirationDate: z.string().nullable(),
+    roomType: z.number(),
+    members: z.array(MemberSchema),
+  }),
+});
+
+
+export type RoomByIdOutputDTO = z.infer<typeof RoomByIdOutputDTOSchema>

src/app/services/Repositorys/chat/repository/room-repository.service.ts

@@ -7,6 +7,7 @@ import { AddMemberToRoomInputDTO } from '../dto/room/addMemberToRoomInputDto';
 import { RoomLocalDataSourceService } from '../data-source/room/rooom-local-data-source.service';
 import { HttpErrorResponse } from '@angular/common/http';
 import { ZodError } from 'zod';
+import { RoomByIdInputDTO } from '../dto/room/roomByIdInputDTO';
 
 @Injectable({
   providedIn: 'root'
@@ -30,6 +31,18 @@ export class RoomRepositoryService {
     return result
   }
 
+
+  async getRoomById(id: RoomByIdInputDTO) {
+    const result = await this.roomRemoteDataSourceService.getRoom(id)
+
+    if(result.isOk()) {
+      for (const user of result.value.data.members) {
+        this.roomLocalDataSourceService.addMember({...user, roomId:id})
+      }
+
+    }
+  }
+
   async create(data: RoomInputDTO) {
 
     const result = await this.roomRemoteDataSourceService.createRoom(data)
@@ -56,4 +69,9 @@ export class RoomRepositoryService {
   getItemByIdLive(id: any) {
     return this.roomLocalDataSourceService.getRoomByIdLive(id)
   }
+
+
+  getRoomMemberByIdLive(roomId: any) {
+    return this.roomLocalDataSourceService.getRoomMemberByIdLive(roomId)
+  }
 }