doneit-web/src/app/module/chat/data/repository/message/message-live-signalr-data-source.service.ts

import { Injectable } from '@angular/core';
import { err, ok } from 'neverthrow';
import { SignalRService } from '../../../infra/socket/signal-r.service';
import { SessionStore } from 'src/app/store/session.service';
import { MessageDeleteInputDTO } from '../../dto/message/messageDeleteInputDTO';
import { v4 as uuidv4 } from 'uuid'
import { InstanceId } from '../../../domain/chat-service.service';
import { MessageUpdateInput } from '../../../domain/use-case/message/message-update-by-id-use-case.service';
import { MessageOutPutDataDTO } from '../../dto/message/messageOutputDTO';
import { MessageInputDTO } from '../../dto/message/messageInputDtO';
import { MessageReactionInput } from '../../../domain/use-case/message/message-reaction-by-id-use-case.service';

interface msgObj {
  roomId: string;
  senderId: string;
  message:string;
  messageType:1;
  canEdit:Boolean;
  oneShot:Boolean;
  requestId: string;
}

interface sendDeliverAt {
  memberId: number,
 messageId:string,
 roomId: string,
 requestId: string
}


export interface sendReadAt {
 memberId: number,
 messageId:string,
 roomId: string,
 requestId: string
}


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

  constructor(
    private socket: SignalRService
  ) {}

  connect() {
    return this.socket.establishConnection();
  }

  async join() {
    return await this.socket.join()
  }


  async sendGroupMessage(data: MessageInputDTO) {

    if(!data.requestId) {
      data.requestId = InstanceId +'@'+ uuidv4();
    }

    const result =  await this.socket.sendData<MessageOutPutDataDTO>({
      method: 'sendMessage',
      data: data,
    })

    return result;
  }

  async sendDirectMessage(data: MessageInputDTO) {

    if(!data.requestId) {
      data.requestId = InstanceId +'@'+ uuidv4();
    }
    const result =  await this.socket.sendData<MessageOutPutDataDTO>({
      method: 'SendDirectMessage',
      data: data as any,
    })

    return result;
  }

  async sendDeliverAt(data: sendDeliverAt) {
    const result =  await this.socket.sendData<any>({
      method: 'DeliverAt',
      data: data as any,
    })

    return result;
  }

  async sendReadAt(data: sendReadAt) {
    const result =  await this.socket.sendData<any>({
      method: 'ReadAt',
      data: data as any,
    })

    return result;
  }

  async sendDelete(data: MessageDeleteInputDTO) {
    const result =  await this.socket.sendData<any>({
      method: 'ReadAt',
      data: data,
    })

    return result;
  }

  listenToMessages() {
    return this.socket.getMessage()
  }


  listenToDeleteMessages() {
    return this.socket.getMessageDelete()
  }


  listenToUpdateMessages() {
    return this.socket.getMessageUpdate()
  }


  reactToMessageSocket(data: MessageReactionInput) {
    this.socket.sendData({
      method: 'ReactMessage',
      data
    })
  }

  updateMessage(input: MessageUpdateInput) {
    this.socket.sendData({
      method: 'EditMessage',
      data: input,
    })
  }


  sendMessageDelete(data: MessageDeleteInputDTO) {

    data['requestId'] = InstanceId +'@'+ uuidv4();

    const result =  this.socket.sendData<any>({
      method: 'DeleteMessage',
      data: data,
    })

    return result;
  }

}