doneit-web/src/app/module/chat/domain/use-case/message-create-use-case.service.ts

import { Injectable } from '@angular/core';
import { MessageEntity, MessageEntitySchema,  } from '../entity/message';
import { MessageRepositoryService } from "src/app/module/chat/data/repository/message-respository.service";
import { AttachmentRepositoryService } from "src/app/module/chat/data/repository/attachment-repository.service";
import { z } from 'zod';
import { v4 as uuidv4 } from 'uuid';
import { InstanceId } from '../chat-service.service';
import { createDataURL } from 'src/app/utils/ToBase64';
import { zodSafeValidation } from 'src/app/utils/zodValidation';
import { Logger } from 'src/app/services/logger/main/service';
import { MessageAttachmentSource } from '../../data/dto/message/messageOutputDTO';

const MessageInputUseCaseSchema = z.object({
  memberId: z.number(),
  roomId: z.string(),
  message: z.string()
})

export type MessageInputUseCase = z.infer< typeof MessageInputUseCaseSchema>

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

  constructor(
    private MessageRepositoryService: MessageRepositoryService,
    private AttachmentRepositoryService: AttachmentRepositoryService,
  ) { }


  async execute(message: MessageEntity) {

    const validation = zodSafeValidation<MessageEntity>(MessageEntitySchema, message)

    if(validation.isOk()) {
      message.sendAttemp++;

      message.requestId = InstanceId +'@'+ uuidv4();

      const createMessageLocally = await this.MessageRepositoryService.createMessageLocally(message)

      if(createMessageLocally.isOk()) {
        if(message.hasAttachment) {

          for (const attachment of message.attachments) {

            if(attachment.source != MessageAttachmentSource.Webtrix) {

              this.AttachmentRepositoryService.create({
                $messageId: createMessageLocally.value.$id,
                file: createDataURL(attachment.file, attachment.mimeType)
              }).then((e) => {
                if(e.isErr()) {
                  Logger.error('failed to create attachment locally on send message', {
                    error: e.error,
                    data: createDataURL(attachment.file, attachment.mimeType).slice(0, 100) +'...'
                  })
                }

              })

              attachment.safeFile = createDataURL(attachment.file, attachment.mimeType)
            }
          }

        }

        const sendToServer = await this.MessageRepositoryService.sendMessage(message)

        if(!sendToServer.isOk()) {
          Logger.error('failed to send message to the server', {
            error: sendToServer.error
          })
        }

        return sendToServer
      }

      const result = await this.MessageRepositoryService.sendMessage(message)

      return result
    } else {

      if(validation.error.formErrors.fieldErrors.attachments) {
        Logger.error('failed to send message doe to invalid attachment', {
          zodErrorList: validation.error.errors,
          data: message.attachments
        })
      }

    }

  }
}