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

import { Injectable } from '@angular/core';
import { RoomListItemOutPutDTO, RoomListOutPutDTO } from '../../dto/room/roomListOutputDTO';
import { Dexie, EntityTable, liveQuery, Observable } from 'Dexie';
import { err, ok, Result } from 'neverthrow';
import { z } from 'zod';

const tableSchema = z.object({
  id: z.string(),
  roomName: z.string(),
  createdBy: z.any(),
  createdAt: z.any(),
  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',
  memberList: '$roomIdUserId, id, user, joinAt, roomId',
});

@Injectable({
  providedIn: 'root'
})
export class RoomLocalDataSourceService {

  private baseUrl = 'https://gdapi-dev.dyndns.info/stage/api/v2/Chat'; // Your base URL

  constructor() {}

  async createRoom(data: TableRoom) {
    try {
      const result = await roomDataSource.room.add(data)
      return ok(result)
    } catch (e) {
      return err(false)
    }
  }

  async updateRoom(data: TableRoom) {
    try {
      const result = await roomDataSource.room.update(data.id, data);

      return ok(result)
    } catch (e) {
      return err(false)
    }
  }

  async createOrUpdateRoom(data: TableRoom) {
    const createResult = await this.createRoom(data)

    if(createResult.isOk()) {
      return this.updateRoom(data)
    } else  {
      return createResult
    }
  }


  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 removeMemberFromRoom($roomIdUserId): Promise<Result<any ,any>> {
    try {

      const member = await roomDataSource.memberList.where({ $roomIdUserId: $roomIdUserId }).first();

      if (member) {
        const result =  await ok(roomDataSource.memberList.delete($roomIdUserId));
        console.log(`Member with $roomIdUserId ${$roomIdUserId} removed from room ${member.roomId}.`);
        return result
      } else {
        console.log(`No member found with $roomIdUserId ${$roomIdUserId}`);
        return
      }

    } catch (e) {
      return err(false)
    }
  }

  async getRoomById(id: any) {
    try {
      const result = await roomDataSource.room.get(id)
      return ok(result)
    } catch (e) {
      return err(false)
    }
  }


  async getRoomList() {
    return await roomDataSource.room.toArray()
  }


  getItemsLive(): Observable<RoomListOutPutDTO[]> {
    return liveQuery(() => roomDataSource.room.toArray()) as any;
  }

  getRoomByIdLive(id: any): Observable<RoomListItemOutPutDTO | undefined> {
    return liveQuery(() => roomDataSource.room.get(id)) as any;
  }

  async getRoomMemberById(roomId: any) {
    return await  roomDataSource.memberList.where('roomId').equals(roomId).toArray()
  }
  getRoomMemberByIdLive(roomId: any) {
    return liveQuery(() => roomDataSource.memberList.where('roomId').equals(roomId).toArray())
  }

}