add interface

src/app/module/chat/domain/adapter.ts

@@ -5,8 +5,7 @@ import { MessageEntity } from "src/app/core/chat/entity/message";
 import { HttpListenToMessageLoadHistoryUseCaseInput } from "src/app/core/chat/usecase/message/http-listen-to-message-load-history-use-case";
 import { HttpResult } from "src/app/infra/http/type";
 import { UseCase } from "src/app/utils/use-case-interface";
-import { MessageOutPutDTO } from "../data/dto/message/messageOutputDTO";
-
+import { IMessageGetAllByRoomIdOutPut } from 'src/app/core/chat/usecase/message/message-get-all-by-room-Id'
 export abstract class ITemplateCreateAdapter implements UseCase<MessageEntity, any> {
   execute(input: MessageEntity): Promise<any> {
     throw new Error("Method not implemented.");
@@ -18,5 +17,5 @@ export abstract class SocketOnReconnectAdapter {
 }
 
 export abstract class HttpListenToMessageLoadHistoryAdapter {
-  abstract execute(input: HttpListenToMessageLoadHistoryUseCaseInput): Observable<MessageOutPutDTO>
+  abstract execute(input: HttpListenToMessageLoadHistoryUseCaseInput): Observable<IMessageGetAllByRoomIdOutPut>
 }

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

@@ -35,13 +35,13 @@ import { MessageEntity } from '../../../core/chat/entity/message';
 import { MessageAttachmentByMessageIdInput, MessageAttachmentByMessageIdUseCase } from './use-case/message/message-attachment-by-message-id.service';
 import { RoomInputDTO } from '../data/dto/room/roomInputDTO';
 import { UserRemoveListInputDTO } from '../data/dto/room/userRemoveListInputDTO';
-import { AddMemberToRoomInputDTO } from '../data/dto/room/addMemberToRoomInputDto';
+import { AddMemberToRoomInputDTO, AddMemberToRoomInputDTOSchema } from '../domain/use-case/member/member-add-use-case.service';
 import { RoomUpdateInputDTO } from '../data/dto/room/roomUpdateInputDTO';
 import { RoomType } from "src/app/core/chat/entity/group";
-import { sendReadAt } from "src/app/module/chat/data/repository/message/message-live-signalr-data-source.service";
 import { HttpListenToMessageLoadHistoryAdapter } from './adapter'
 import { HttpListenToMessageLoadHistoryUseCaseInput } from 'src/app/core/chat/usecase/message/http-listen-to-message-load-history-use-case';
 import { MessageSocketRepositoryService } from 'src/app/module/chat/data/repository/message/message-live-signalr-data-source.service'
+import { MessageMarkAsReadInput } from "src/app/module/chat/domain/use-case/message/message-mark-as-read-use-case.service";
 
 export const InstanceId = uuidv4();
 
@@ -230,7 +230,7 @@ export class ChatServiceService {
 
   }
 
-  sendReadAt(sendReadAt: sendReadAt) {
+  sendReadAt(sendReadAt: MessageMarkAsReadInput) {
     return this.MessageMarkAsReadUseCaseService.execute(sendReadAt)
   }
 

src/app/module/chat/domain/use-case/member/member-add-use-case.service.ts

@@ -1,7 +1,16 @@
 import { Injectable } from '@angular/core';
 import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
-import { AddMemberToRoomInputDTO } from '../../../data/dto/room/addMemberToRoomInputDto';
 import { RoomRemoteDataSourceService } from '../../../data/repository/room/room-remote-repository.service';
+import { z } from 'zod';
+
+
+export const AddMemberToRoomInputDTOSchema = z.object({
+  id: z.string(),
+  members: z.array(z.number()),
+});
+
+export type AddMemberToRoomInputDTO = z.infer<typeof AddMemberToRoomInputDTOSchema>
+
 
 @Injectable({
   providedIn: 'root'

src/app/module/chat/domain/use-case/message/listen-message-by-roomId.service.ts

@@ -3,7 +3,14 @@ import { filter, map } from 'rxjs/operators';
 import { InstanceId } from '../../chat-service.service';
 import { MessageSocketRepositoryService } from 'src/app/module/chat/data/repository/message/message-live-signalr-data-source.service'
 import { MessageEntity } from '../../../../../core/chat/entity/message';
-import { UseCase } from 'src/app/utils/use-case-interface';
+import { z } from 'zod';
+
+
+export const ListenMessageByRoomIdNewInputDTOSchema = z.object({
+  roomId: z.string(),
+});
+export type ListenMessageByRoomIdNewInputDTO = z.infer<typeof ListenMessageByRoomIdNewInputDTOSchema>
+
 
 @Injectable({
   providedIn: 'root'
@@ -14,10 +21,10 @@ export class ListenMessageByRoomIdNewUseCase {
     private MessageSocketRepositoryService: MessageSocketRepositoryService
   ) { }
 
-  execute({roomId}: {roomId: string}) {
+  execute(data: ListenMessageByRoomIdNewInputDTO) {
 
     return this.MessageSocketRepositoryService.listenToMessages().pipe(
-      filter((message) => !message?.requestId?.startsWith(InstanceId) && message?.roomId == roomId),
+      filter((message) => !message?.requestId?.startsWith(InstanceId) && message?.roomId == data.roomId),
       map(message => Object.assign(new MessageEntity(), message))
     )
 

src/app/module/chat/domain/use-case/message/listen-message-update-by-roomId.service.ts

@@ -1,6 +1,14 @@
 import { Injectable } from '@angular/core';
 import { filter } from 'rxjs/operators';
 import { MessageSocketRepositoryService } from '../../../data/repository/message/message-live-signalr-data-source.service';
+import { z } from 'zod';
+
+export const ListenMessageUpdateByRoomIdInputDTOSchema = z.object({
+  roomId: z.string(),
+});
+export type ListenMessageUpdateByRoomIdInputDTO = z.infer<typeof ListenMessageUpdateByRoomIdInputDTOSchema>
+
+
 
 @Injectable({
   providedIn: 'root'
@@ -11,9 +19,9 @@ export class ListenMessageUpdateByRoomIdUseCase {
     private messageLiveSignalRDataSourceService: MessageSocketRepositoryService,
   ) { }
 
-  execute({roomId}) {
+  execute(input: ListenMessageUpdateByRoomIdInputDTO) {
     return this.messageLiveSignalRDataSourceService.listenToUpdateMessages().pipe(
-      filter((message) => roomId == message?.roomId )
+      filter((message) => input.roomId == message?.roomId )
     )
   }
 }

src/app/module/chat/domain/use-case/message/listen-send-message.service.ts

@@ -2,6 +2,14 @@ import { Injectable } from '@angular/core';
 import { MessageSocketRepositoryService } from 'src/app/module/chat/data/repository/message/message-live-signalr-data-source.service'
 import { InstanceId } from '../../chat-service.service';
 import { filter, map } from 'rxjs/operators';
+import { z } from 'zod';
+
+export const ListenSendMessageInputDTOSchema = z.object({
+  roomId: z.string(),
+});
+export type ListenSendMessageInputDTO = z.infer<typeof ListenSendMessageInputDTOSchema>
+
+
 
 @Injectable({
   providedIn: 'root'

src/app/module/chat/domain/use-case/message/listene-message-delete-by-roomId.service.ts

@@ -2,6 +2,14 @@ import { Injectable } from '@angular/core';
 import { filter } from 'rxjs/operators';
 import { SignalRService } from 'src/app/infra/socket/signalR/signal-r.service';
 import { MessageSocketRepositoryService } from 'src/app/module/chat/data/repository/message/message-live-signalr-data-source.service'
+import { z } from 'zod';
+
+export const ListenMessageDeleteByRoomIdInputDTOSchema = z.object({
+  roomId: z.string(),
+});
+export type ListenMessageDeleteByRoomIdInputDTO = z.infer<typeof ListenMessageDeleteByRoomIdInputDTOSchema>
+
+
 @Injectable({
   providedIn: 'root'
 })
@@ -11,7 +19,7 @@ export class ListenMessageDeleteByRoomIdService {
     private MessageSocketRepositoryService: MessageSocketRepositoryService,
   ) { }
 
-  execute({roomId}) {
+  execute({roomId}: ListenMessageDeleteByRoomIdInputDTO) {
     return this.MessageSocketRepositoryService.listenToDeleteMessages().pipe(
       filter((message) => {
         return roomId == message?.roomId

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

@@ -17,19 +17,54 @@ import { TracingType, XTracerAsync } from 'src/app/services/monitoring/opentelem
 import { MemberListLocalRepository } from 'src/app/module/chat/data/repository/member/member-list-local-repository.service'
 import { SessionStore } from 'src/app/store/session.service';
 import { MessageTable } from 'src/app/infra/database/dexie/instance/chat/schema/message';
+import { MessageAttachmentFileType } from 'src/app/core/chat/repository/dto/messageOutputDTO';
 
-const MessageInputUseCaseSchema = z.object({
-  memberId: z.number(),
-  roomId: z.string(),
-  message: z.string()
-})
 
 export enum MessageEnum {
   Direct = 1,
   group = 2
 }
 
-export type MessageInputUseCase = z.infer< typeof MessageInputUseCaseSchema>
+
+export const MessageCreatePutDataDTOSchema = z.object({
+  id: z.string(),
+  roomId: z.string(),
+  sender: z.object({
+    wxUserId: z.number(),
+    wxFullName: z.string(),
+    wxeMail: z.string(),
+    userPhoto: z.string().optional()
+  }),
+  message: z.string().nullable().optional(),
+  messageType: z.number(),
+  sentAt: z.string(),
+  canEdit: z.boolean(),
+  oneShot: z.boolean(),
+  requireUnlock: z.boolean(),
+  requestId: z.string().optional().nullable(),
+  reactions: z.object({
+    id: z.string(),
+    reactedAt: z.string(),
+    reaction: z.string(),
+    sender: z.object({}),
+  }).array(),
+  info: z.array(z.object({
+    memberId: z.number(),
+    readAt: z.string().nullable(),
+    deliverAt: z.string().nullable()
+  })),
+  attachments: z.array(z.object({
+    fileType: z.nativeEnum(MessageAttachmentFileType),
+    source: z.nativeEnum(MessageAttachmentSource),
+    file: z.string().optional(),
+    fileName: z.string().optional(),
+    applicationId: z.number().optional(),
+    docId: z.string().optional(),
+    id: z.string().optional()
+  }))
+});
+
+export type MessageCreateOutPutDataDTO = z.infer<typeof MessageCreatePutDataDTOSchema>
 
 @Injectable({
   providedIn: 'root'

src/app/module/chat/domain/use-case/message/message-delete-by-id-live-use-case.service.ts

@@ -1,7 +1,5 @@
 import { Injectable } from '@angular/core';
 import { z } from 'zod';
-import { SafeValidateSchema, ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
-import { MessageRemoteDataSourceService } from '../../../data/repository/message/message-remote-data-source.service';
 import { MessageSocketRepositoryService } from '../../../data/repository/message/message-live-signalr-data-source.service';
 import { XTracerAsync, TracingType } from 'src/app/services/monitoring/opentelemetry/tracer';
 export const MessageDeleteInputDTOSchema = z.object({

src/app/module/chat/domain/use-case/message/message-mark-as-read-use-case.service.ts

@@ -1,6 +1,17 @@
 import { Injectable } from '@angular/core';
-import { MessageSocketRepositoryService, sendReadAt } from '../../../data/repository/message/message-live-signalr-data-source.service';
+import { MessageSocketRepositoryService } from '../../../data/repository/message/message-live-signalr-data-source.service';
 import { XTracerAsync, TracingType } from 'src/app/services/monitoring/opentelemetry/tracer';
+import { z } from 'zod';
+
+export const MessageMarkAsReadInputSchema = z.object({
+  memberId: z.number(),
+  messageId: z.string(),
+  roomId: z.string(),
+  requestId: z.string()
+})
+
+export type MessageMarkAsReadInput = z.infer<typeof MessageMarkAsReadInputSchema>
+
 @Injectable({
   providedIn: 'root'
 })
@@ -12,7 +23,7 @@ export class MessageMarkAsReadUseCaseService {
 
 
   @XTracerAsync({name:'MessageMarkAsReadUseCaseService', module:'chat',  bugPrint: true})
-  async execute(sendReadAt: sendReadAt, tracing?: TracingType) {
-    return this.MessageSocketRepositoryService.sendReadAt(sendReadAt)
+  async execute(sendReadAt: MessageMarkAsReadInput, tracing?: TracingType) {
+    return this.MessageSocketRepositoryService.sendReadAt(sendReadAt as any)
   }
 }

src/app/module/chat/domain/use-case/message/message-read-at-by-id-use-case.service.ts

@@ -1,32 +0,0 @@
-import { Injectable } from '@angular/core';
-import { err, ok } from 'neverthrow';
-import { SessionStore } from 'src/app/store/session.service';
-import { MessageLocalDataSourceService } from '../../../data/repository/message/message-local-data-source.service';
-import { MessageSocketRepositoryService } from '../../../data/repository/message/message-live-signalr-data-source.service';
-import { MessageRemoteDataSourceService } from '../../../data/repository/message/message-remote-data-source.service';
-import { SignalRService } from 'src/app/infra/socket/signalR/signal-r.service';
-
-
-@Injectable({
-  providedIn: 'root'
-})
-export class MessageReadAtByIdUseCaseService {
-
-  constructor(
-    private MessageSocketRepositoryService: MessageSocketRepositoryService,
-    private messageLiveSignalRDataSourceService: SignalRService,
-    private messageLocalDataSourceService: MessageLocalDataSourceService,
-  ) { }
-
-  async execute({roomId}) {
-    // const result = await this.messageLocalDataSourceService.getLastMessageByRoomId(roomId)
-    // if(result.isOk()) {
-    //   if(result.value) {
-
-    //     return await this.MessageSocketRepositoryService.sendReadAt({roomId, memberId: SessionStore.user.UserId, messageId: result.value.id, requestId: ''})
-    //   }
-    //   return ok(true)
-    // }
-    // return err(false)
-  }
-}

src/app/module/chat/domain/use-case/message/message-send-use-case.service.ts

@@ -1,31 +0,0 @@
-import { Injectable } from '@angular/core';
-import { MessageEntity } from '../../../../../core/chat/entity/message';
-import { z } from 'zod';
-
-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() { }
-
-
-  async execute(input: MessageEntity) {
-
-    // const result = await this.MessageRepositoryService.(input)
-
-    // if(result.isOk()) {
-
-    // }
-
-    // return result
-  }
-}

src/app/module/chat/domain/use-case/message/message-to-async-ui.service.ts

@@ -1,9 +0,0 @@
-import { Injectable } from '@angular/core';
-
-@Injectable({
-  providedIn: 'root'
-})
-export class MessageToAsyncUIService {
-
-  constructor() { }
-}

src/app/module/chat/domain/use-case/room/room-create-use-case.service.ts

@@ -1,12 +1,21 @@
 import { Injectable } from '@angular/core';
-import { create } from 'domain';
 import { SessionStore } from 'src/app/store/session.service';
 import { RoomRemoteDataSourceService } from '../../../data/repository/room/room-remote-repository.service';
 import { RoomSocketRepositoryService } from '../../../data/repository/room/room-socket-repository.service';
-import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
-import { RoomInputDTO } from '../../../data/dto/room/roomInputDTO';
 import { RoomLocalRepository } from '../../../data/repository/room/room-local-repository.service';
 import { TracingType, XTracerAsync } from 'src/app/services/monitoring/opentelemetry/tracer';
+import { z } from "zod";
+
+export const CreateRoomInputDTOSchema = z.object({
+  roomName: z.string(),
+  createdBy: z.number(),
+  roomType: z.number(),
+  expirationDate: z.string().nullable().optional(),
+  members: z.array(z.number())
+});
+
+
+export type CreateRoomInputDTO = z.infer<typeof CreateRoomInputDTOSchema>
 
 @Injectable({
   providedIn: 'root'
@@ -19,9 +28,8 @@ export class CreateRoomUseCaseService {
     private RoomSocketRepositoryService: RoomSocketRepositoryService
   ) { }
 
-
   @XTracerAsync({name:'room-create-use-case.service', module:'chat',  bugPrint: true, waitNThrow: 5000})
-  async execute(data: RoomInputDTO, tracing?: TracingType) {
+  async execute(data: CreateRoomInputDTO, tracing?: TracingType) {
 
     const result = await this.RoomSocketRepositoryService.CreateGroup(data)
     // const result = await this.roomRemoteDataSourceService.createRoom(data)

src/app/module/chat/domain/use-case/room/room-get-list-use-case.service.ts

@@ -3,7 +3,6 @@ import { roomListDetermineChanges } from '../../../data/async/list/rooms/roomLis
 import { RoomRemoteDataSourceService } from '../../../data/repository/room/room-remote-repository.service';
 import { RoomLocalRepository } from '../../../data/repository/room/room-local-repository.service';
 import { captureAndReraiseAsync } from 'src/app/services/decorators/captureAndReraiseAsync';
-import { isHttpResponse } from 'src/app/services/http.service';
 import { CronJobService } from 'src/app/utils/task-scheduler'
 @Injectable({
   providedIn: 'root'

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

@@ -2,7 +2,29 @@ import { Injectable, Input } from '@angular/core';
 import { MessageLocalDataSourceService } from '../../../data/repository/message/message-local-data-source.service';
 import { TracingType, XTracerAsync } from 'src/app/services/monitoring/opentelemetry/tracer';
 import { ParamsValidation } from 'src/app/services/decorators/validate-schema.decorator';
-import { MessageOutPutDataDTOSchema } from '../../../data/dto/message/messageOutputDTO';
+import { MessageEntitySchema } from 'src/app/core/chat/entity/message';
+import { z } from 'zod';
+
+const SocketMessageCreateOutputSchema = MessageEntitySchema.pick({
+  id: true,
+  attachments: true,
+  canEdit: true,
+  editedAt: true,
+  info: true,
+  isDeleted: true,
+  message: true,
+  messageType: true,
+  oneShot: true,
+  reactions: true,
+  receiverId: true,
+  requireUnlock: true,
+  roomId: true,
+  sender: true,
+  sending: true,
+  sentAt: true,
+})
+
+export type ISocketMessageCreateOutput = z.infer<typeof SocketMessageCreateOutputSchema>
 
 @Injectable({
   providedIn: 'root'
@@ -14,9 +36,9 @@ export class SocketMessageCreateUseCaseService {
   ) { }
 
   @XTracerAsync({name:'Socket-Message-Create-UseCase', module:'chat',  bugPrint: true})
-  async execute(input: any, tracing?: TracingType) {
+  async execute(input: ISocketMessageCreateOutput, tracing?: TracingType) {
 
-    ParamsValidation(MessageOutPutDataDTOSchema, input, tracing)
+    ParamsValidation(SocketMessageCreateOutputSchema, input, tracing)
 
     const incomingMessage =  {
       ...input,

src/app/module/chat/domain/use-case/socket/socket-message-delete-use-case.service.ts

@@ -1,6 +1,29 @@
 import { Injectable } from '@angular/core';
 import { MessageLocalDataSourceService } from '../../../data/repository/message/message-local-data-source.service';
-import { MessageOutPutDataDTO } from '../../../data/dto/message/messageOutputDTO';
+import { MessageEntitySchema } from 'src/app/core/chat/entity/message';
+import { z } from 'zod';
+
+const SocketMessageDeleteOutputSchema = MessageEntitySchema.pick({
+  id: true,
+  attachments: true,
+  canEdit: true,
+  editedAt: true,
+  info: true,
+  isDeleted: true,
+  message: true,
+  messageType: true,
+  oneShot: true,
+  reactions: true,
+  receiverId: true,
+  requireUnlock: true,
+  roomId: true,
+  sender: true,
+  sending: true,
+  sentAt: true,
+})
+
+
+export type ISocketMessageDeleteOutput = z.infer<typeof SocketMessageDeleteOutputSchema>
 
 @Injectable({
   providedIn: 'root'
@@ -12,7 +35,7 @@ export class SocketMessageDeleteUseCaseService {
   ) { }
 
 
-  async execute(input: MessageOutPutDataDTO) {
+  async execute(input: ISocketMessageDeleteOutput) {
     const result = await this.messageLocalDataSourceService.update(input.id, { isDeleted: true})
 
     if(result.isOk()) {

src/app/module/chat/domain/use-case/socket/socket-message-update-use-case.service.ts

@@ -2,9 +2,32 @@ import { Injectable } from '@angular/core';
 import { MessageLocalDataSourceService } from '../../../data/repository/message/message-local-data-source.service';
 import { MessageOutPutDataDTO, MessageOutPutDataDTOSchema } from '../../../data/dto/message/messageOutputDTO';
 import { ParamsValidation, SafeValidateSchema, ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
-import { MessageInputDTOSchema } from '../../../data/dto/message/messageInputDtO';
 import { TracingType, XTracerAsync } from 'src/app/services/monitoring/opentelemetry/tracer';
+import { MessageEntitySchema } from 'src/app/core/chat/entity/message';
+import { z } from 'zod';
+import { MessageTable } from 'src/app/infra/database/dexie/instance/chat/schema/message';
 
+
+const SocketMessageUpdateOutputSchema = MessageEntitySchema.pick({
+  id: true,
+  attachments: true,
+  canEdit: true,
+  editedAt: true,
+  info: true,
+  isDeleted: true,
+  message: true,
+  messageType: true,
+  oneShot: true,
+  reactions: true,
+  receiverId: true,
+  requireUnlock: true,
+  roomId: true,
+  sender: true,
+  sending: true,
+  sentAt: true,
+})
+
+export type ISocketMessageUpdateOutput = z.infer<typeof SocketMessageUpdateOutputSchema>
 @Injectable({
   providedIn: 'root'
 })
@@ -16,21 +39,19 @@ export class SocketMessageUpdateUseCaseService {
 
 
   @XTracerAsync({name:'Socket-Message-Update-UseCase', bugPrint: true, module:'chat',})
-  async execute(data: MessageOutPutDataDTO, tracing?: TracingType) {
+  async execute(input: ISocketMessageUpdateOutput, tracing?: TracingType) {
 
-    ParamsValidation(MessageOutPutDataDTOSchema, data, tracing)
+    ParamsValidation(MessageOutPutDataDTOSchema, input, tracing)
     tracing?.addEvent("Message existe?")
-    const result = await this.messageLocalDataSourceService.findOne({id: data.id})
+    const result = await this.messageLocalDataSourceService.findOne({id: input.id})
 
-    const incomingMessage =  {
-      ...data,
-      sending: false
-    }
+    const messageToSave: MessageTable = input
+    messageToSave.sending = false
 
     if(result.isOk() && result.value) {
       
       tracing?.addEvent("Message found")
-      const updateResult = await this.messageLocalDataSourceService.update(result.value.$id, incomingMessage)
+      const updateResult = await this.messageLocalDataSourceService.update(result.value.$id, messageToSave)
       tracing.setAttribute('outcome', 'success')
       return updateResult
     } else if(result.isOk() && !result.value) {