doneit-web/src/app/module/chat/domain/chat-service.service.ts

import { Injectable } from '@angular/core';
import { MessageDeleteLiveUseCaseService, MessageDeleteInputDTO } from 'src/app/module/chat/domain/use-case/message-delete-live-use-case.service'
import { SessionStore } from 'src/app/store/session.service';
import { MessageReactionInput, MessageReactionUseCaseService } from 'src/app/module/chat/domain/use-case/message-reaction-use-case.service';
import { MessageUpdateInput, MessageUpdateUseCaseService } from 'src/app/module/chat/domain/use-case/message-update-use-case.service';
import { MemberAdminUseCaseService, MemberSetAdminDTO } from 'src/app/module/chat/domain/use-case/member-admin-use-case.service';
import { MessageCreateUseCaseService } from 'src/app/module/chat/domain/use-case/message-create-use-case.service';
import { SignalRService } from '../infra/socket/signal-r.service';
import { SocketMessageDeleteUseCaseService } from 'src/app/module/chat/domain/use-case/socket/socket-message-delete-use-case.service';
import { SocketMessageUpdateUseCaseService } from 'src/app/module/chat/domain/use-case/socket/socket-message-update-use-case.service';
import { SocketMessageCreateUseCaseService } from 'src/app/module/chat/domain/use-case/socket/socket-message-create-use-case.service';
import { ListenMessageByRoomIdNewUseCase } from 'src/app/module/chat/domain/use-case/listen-message-by-roomId.service';
import { MemberListUpdateStatusUseCaseService } from 'src/app/module/chat/domain/use-case/socket/member-list-update-status-use-case.service';
import { ListenMessageDeleteByRoomIdService } from './use-case/listene-message-delete-by-roomId.service';
import { ListenMessageUpdateByRoomIdUseCase } from './use-case/listen-message-update-by-roomId.service';
import { ListenSendMessageUseCase } from './use-case/listen-send-message.service'
import { filter } from 'rxjs/operators';
import { v4 as uuidv4 } from 'uuid'
import { MessageEntity } from './entity/message';
import { MessageAttachmentByMessageIdInput, MessageAttachmentByMessageIdUseCase } from './use-case/message-attachment-by-message-id.service';

export const InstanceId = uuidv4();


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

  constructor(
    private MessageDeleteLiveUseCaseService: MessageDeleteLiveUseCaseService,
    private MessageReactionUseCaseService: MessageReactionUseCaseService,
    private MessageUpdateUseCaseService: MessageUpdateUseCaseService,
    private SocketMessageDeleteUseCaseService: SocketMessageDeleteUseCaseService,
    private messageLiveSignalRDataSourceService: SignalRService,
    private SocketMessageUpdateUseCaseService: SocketMessageUpdateUseCaseService,
    private SocketMessageCreateUseCaseService: SocketMessageCreateUseCaseService,
    private MemberListUpdateStatusUseCaseService: MemberListUpdateStatusUseCaseService,
    private MemberAdminUseCaseService: MemberAdminUseCaseService,
    private MessageCreateUseCaseService: MessageCreateUseCaseService,
    private ListenMessageByRoomIdNewUseCase: ListenMessageByRoomIdNewUseCase,
    private ListenMessageDeleteService: ListenMessageDeleteByRoomIdService,
    private ListenMessageUpdateByRoomIdUseCase: ListenMessageUpdateByRoomIdUseCase,
    private ListenSendMessageUseCase: ListenSendMessageUseCase,
    private MessageAttachmentByMessageIdService: MessageAttachmentByMessageIdUseCase
  ) {
    this.messageLiveSignalRDataSourceService.getMessageDelete()
    .pipe()
    .subscribe(async (message) => {
      if(message?.id) {
        this.SocketMessageDeleteUseCaseService.execute(message)
      }
    })

    this.messageLiveSignalRDataSourceService.getMessageUpdate().pipe(
      filter((message) => {
        return !message?.requestId?.startsWith(InstanceId)
      })
    ).subscribe(async (message) => {
      if(message?.id) {
        this.SocketMessageUpdateUseCaseService.execute(message)
      }
    })

    this.messageLiveSignalRDataSourceService.getMessage().pipe(
      filter((message) => {
        if(!message?.requestId?.startsWith(InstanceId) == false) {
          // console.log('exclude my message---')
        }
        return !message?.requestId?.startsWith(InstanceId)
      })
    ).subscribe(async (message) => {

      if(message?.id) {
        console.log('create message')
        this.SocketMessageCreateUseCaseService.execute(message)
      }


    })

    this.messageLiveSignalRDataSourceService.getData().pipe(
      filter((message) => {
        if(message?.method == 'AvailableUsers') {
          // console.log('exclude my message---')
          return true
        }
      })
    ).subscribe(async (message) => {
      console.log('123', message)
      this.MemberListUpdateStatusUseCaseService.execute(message.data as any)
    })

  }

  messageDelete(data: {roomId, messageId}) {

    const params = {
      ...data,
      senderId: SessionStore.user.UserId,
    }

    return this.MessageDeleteLiveUseCaseService.execute(params)
  }

  reactToMessage(input: MessageReactionInput) {
    return this.MessageReactionUseCaseService.execute(input);
  }

  updateMessage(input: MessageUpdateInput) {
    return this.MessageUpdateUseCaseService.execute(input);
  }

  setAdmin(input: MemberSetAdminDTO) {
    return this.MemberAdminUseCaseService.execute(input)
  }

  sendMessage(input: MessageEntity) {
    return this.MessageCreateUseCaseService.execute(input);
  }

  getMessageAttachmentByMessageId(input: MessageAttachmentByMessageIdInput) {
    return this.MessageAttachmentByMessageIdService.execute(input)
  }

  listenToIncomingMessage(roomId:string) {
    return this.ListenMessageByRoomIdNewUseCase.execute({roomId})
  }

  listenToDeleteMessage(roomId: string) {
    return this.ListenMessageDeleteService.execute({roomId})
  }

  listenToUpdateMessage(roomId: string) {
    return this.ListenMessageUpdateByRoomIdUseCase.execute({roomId})
  }


  listenToSendMessage(roomId: string) {
    return this.ListenSendMessageUseCase.execute({roomId})
  }

}