soft delete

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

@@ -32,13 +32,13 @@ import { GetMessageAttachmentLocallyUseCaseService } from 'src/app/module/chat/d
 import { GetRoomListUseCaseService } from 'src/app/module/chat/domain/use-case/room-get-list-use-case.service';
 import { filter } from 'rxjs/operators';
 import { v4 as uuidv4 } from 'uuid'
-import { MessageEntity } from './entity/message';
+import { MessageEntity } from '../../../core/chat/entity/message';
 import { MessageAttachmentByMessageIdInput, MessageAttachmentByMessageIdUseCase } from './use-case/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 { RoomUpdateInputDTO } from '../data/dto/room/roomUpdateInputDTO';
-import { RoomType } from "src/app/module/chat/domain/entity/group";
+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";
 
 export const InstanceId = uuidv4();
@@ -128,7 +128,7 @@ export class ChatServiceService {
 
   async start() {
     await this.chatSync()
-    this.SocketConnectUseCaseService.execute();
+    await this.SocketConnectUseCaseService.execute();
   }
 
 

src/app/module/chat/domain/entity/group.ts

@@ -1,4 +0,0 @@
-export enum RoomType {
-  Group = 1,
-  Direct = 2
-}

src/app/module/chat/domain/entity/message.ts

@@ -1,99 +0,0 @@
-import { z } from "zod";
-import { MessageAttachmentFileType, MessageAttachmentSource } from "../../data/dto/message/messageOutputDTO";
-import { SafeResourceUrl } from "@angular/platform-browser";
-import { base64Schema } from "src/app/utils/zod";
-
-export const MessageEntitySchema = z.object({
-  $id: z.any().optional(),
-  id: z.string().optional(),
-  roomId: z.string().uuid().optional(),
-  receiverId: z.number().optional(),
-  message: z.string().optional(),
-  messageType: z.number(),
-  canEdit: z.boolean(),
-  oneShot: z.boolean(),
-  sentAt: z.string().optional(),
-  requireUnlock: z.boolean(),
-  editedAt: z.string().nullable().optional(),
-  sender: z.object({
-    wxUserId: z.number(),
-    wxFullName: z.string(),
-    wxeMail: z.string(),
-    userPhoto: z.string(),
-  }),
-  info: z.array(z.object({
-    memberId: z.number(),
-    readAt: z.string().nullable(),
-    deliverAt: z.string().nullable()
-  })).optional(),
-  sending: z.boolean().optional(),
-  attachments: z.array(z.object({
-    fileType: z.nativeEnum(MessageAttachmentFileType),
-    source: z.nativeEnum(MessageAttachmentSource),
-    file: base64Schema.optional(),
-    fileName: z.string().optional(),
-    applicationId: z.number().optional(),
-    docId: z.string().optional(),
-    id: z.string().optional(),
-    mimeType: z.string().optional()
-  })).optional()
-})
-
-type Message = z.infer<typeof MessageEntitySchema>;
-
-export class MessageEntity {
-
-  $id?: number
-  id?: string
-  roomId?: string
-  receiverId?: number
-  message?: string
-  messageType: number = 0
-  canEdit: boolean = false
-  oneShot: boolean = false
-  sentAt?: string
-  requireUnlock: boolean = false
-  info: {
-    memberId?: number
-    readAt?: string,
-    deliverAt?: string
-  }[] = []
-  sender!: {
-    wxUserId: number,
-    wxFullName: string,
-    wxeMail: string,
-    userPhoto: string,
-  }
-  sending: boolean = false
-  sendAttemp = 0
-
-  attachments: {
-    safeFile?: SafeResourceUrl;
-    fileType: MessageAttachmentFileType,
-    source: MessageAttachmentSource,
-    file?: string,
-    fileName: string,
-    applicationId?: number,
-    docId?: string,
-    mimeType?: string,
-    description?: string
-    id?: string
-  }[] = []
-
-  reactions = []
-
-  requestId!: string
-
-  constructor() {}
-
-  get messageStatus() {
-    if(this.id) {
-      return 'send'
-    }
-  }
-
-  get hasAttachment() {
-    return this.attachments.length >= 1
-  }
-
-}

src/app/module/chat/domain/mapper/messageMapper.ts

@@ -1,6 +1,6 @@
 import { MessageInputDTO } from "../../data/dto/message/messageInputDtO";
 import { MessageOutPutDataDTO } from "../../data/dto/message/messageOutputDTO";
-import { MessageEntity } from "../entity/message";
+import { MessageEntity } from "../../../../core/chat/entity/message";
 
 export class MessageMapper {
   static toDomain(DTO: MessageOutPutDataDTO) : MessageEntity {

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

@@ -2,7 +2,7 @@ import { Injectable } from '@angular/core';
 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 '../entity/message';
+import { MessageEntity } from '../../../../core/chat/entity/message';
 
 @Injectable({
   providedIn: 'root'

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

@@ -5,7 +5,7 @@ import { AttachmentLocalDataSource } from 'src/app/module/chat/data/repository/a
 import { convertBlobToDataURL } from 'src/app/utils/ToBase64';
 import { Result } from 'neverthrow';
 import { Logger } from 'src/app/services/logger/main/service';
-import { MessageEntity } from '../entity/message';
+import { MessageEntity } from '../../../../core/chat/entity/message';
 
 const MessageAttachmentByMessageIdSchema = z.object({
   $messageId: z.number(),

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

@@ -1,5 +1,5 @@
 import { Injectable } from '@angular/core';
-import { MessageEntity, MessageEntitySchema,  } from '../entity/message';
+import { MessageEntity, MessageEntitySchema,  } from '../../../../core/chat/entity/message';
 import { AttachmentLocalDataSource } from "src/app/module/chat/data/repository/attachment-local-repository.service";
 import { z } from 'zod';
 import { v4 as uuidv4 } from 'uuid';
@@ -13,8 +13,7 @@ import { MessageSocketRepositoryService } from '../../data/repository/message/me
 import { err, Result } from 'neverthrow';
 import { MessageTable } from '../../infra/database/dexie/schema/message';
 import { MessageMapper } from '../mapper/messageMapper';
-import { SignalRService } from '../../infra/socket/signal-r.service';
-import { RoomType } from "src/app/module/chat/domain/entity/group";
+import { RoomType } from "src/app/core/chat/entity/group";
 import { TracingType, XTracerAsync } from 'src/app/services/monitoring/opentelemetry/tracer';
 import { MemberListLocalRepository } from 'src/app/module/chat/data/repository/member-list-local-repository.service'
 import { SessionStore } from 'src/app/store/session.service';

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

@@ -1,5 +1,5 @@
 import { Injectable } from '@angular/core';
-import { MessageEntity } from '../entity/message';
+import { MessageEntity } from '../../../../core/chat/entity/message';
 import { z } from 'zod';
 
 const MessageInputUseCaseSchema = z.object({
@@ -23,7 +23,7 @@ export class MessageCreateUseCaseService {
     // const result = await this.MessageRepositoryService.(input)
 
     // if(result.isOk()) {
-      
+
     // }
 
     // return result

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

@@ -1,13 +1,17 @@
 import { Injectable } from '@angular/core';
 import { MessageLocalDataSourceService } from '../../data/repository/message/message-local-data-source.service';
 import { MessageSocketRepositoryService } from '../../data/repository/message/message-live-signalr-data-source.service';
-import { MessageOutPutDataDTO } from '../../data/dto/message/messageOutputDTO';
 import { MessageTable } from '../../infra/database/dexie/schema/message';
-import { SignalRService } from '../../infra/socket/signal-r.service';
 import { InstanceId } from '../chat-service.service';
 import { MessageMapper } from '../mapper/messageMapper';
 import { v4 as uuidv4 } from 'uuid'
 import { AttachmentLocalDataSource } from '../../data/repository/attachment-local-repository.service';
+import { RoomLocalRepository } from '../../data/repository/room/room-local-repository.service';
+import { MemberListLocalRepository } from 'src/app/module/chat/data/repository/member-list-local-repository.service'
+import { Result } from 'neverthrow';
+import { RoomType } from 'src/app/core/chat/entity/group';
+import { SessionStore } from 'src/app/store/session.service';
+import { MessageOutPutDataDTO } from '../../data/dto/message/messageOutputDTO';
 
 @Injectable({
   providedIn: 'root'
@@ -18,19 +22,27 @@ export class SendLocalMessagesUseCaseService {
     private MessageSocketRepositoryService: MessageSocketRepositoryService,
     private messageLocalDataSourceService: MessageLocalDataSourceService,
     private AttachmentRepositoryService: AttachmentLocalDataSource,
+    private roomLocalDataSourceService: RoomLocalRepository,
+    private MemberListLocalRepository: MemberListLocalRepository,
+    private messageSocketRepositoryService: MessageSocketRepositoryService,
   ) { }
 
-
   async execute() {
+
+    const allRooms = await this.roomLocalDataSourceService.findAll()
     const messages = await this.messageLocalDataSourceService.getOfflineMessages()
 
-    if(messages.length >= 1) {
+    if(allRooms.isOk()) {
+      if(allRooms.value.length == 0) {
 
-      for(const message of messages) {
+      } else {
 
-        const attachments =  await this.AttachmentRepositoryService.find({$messageId: message.$id})
+        for(const message of messages) {
+          const room = allRooms.value.find(e => e.id == message.roomId)
 
-        if(attachments.isOk()) {
+          const attachments =  await this.AttachmentRepositoryService.find({$messageId: message.$id})
+
+          if(attachments.isOk()) {
 
           message.attachments = attachments.value.map(e => ({
             fileType: e.fileType,
@@ -41,14 +53,37 @@ export class SendLocalMessagesUseCaseService {
             id: e.id,
             mimeType: e.mimeType,
             description: e.description,
-            file: e.file.split(',')[0]
+            file: e.file.split(',')[1]
           }))
           console.log('to upload', messages)
           const requestId = InstanceId +'@'+ uuidv4();
-          const DTO = MessageMapper.fromDomain(message, requestId)
 
           await this.messageLocalDataSourceService.update(message.$id, { sending: true })
-          const sendMessageResult = await this.MessageSocketRepositoryService.sendGroupMessage(DTO)
+
+          let sendMessageResult: Result<MessageOutPutDataDTO, any>
+          if(room.roomType == RoomType.Group) {
+            const DTO = MessageMapper.fromDomain(message, message.requestId)
+            sendMessageResult = await this.MessageSocketRepositoryService.sendGroupMessage(DTO)
+          } else {
+
+            if(message.receiverId) {
+              const DTO = MessageMapper.fromDomain(message, message.requestId)
+              sendMessageResult = await this.messageSocketRepositoryService.sendDirectMessage(DTO)
+            } else {
+              const getRoomMembers = await this.MemberListLocalRepository.directMember({
+                roomId:message.roomId,
+                currentUserId: SessionStore.user.UserId
+              })
+              if(getRoomMembers.isOk()) {
+                message.receiverId = getRoomMembers.value.wxUserId
+                const DTO = MessageMapper.fromDomain(message, message.requestId)
+                sendMessageResult = await this.messageSocketRepositoryService.sendGroupMessage(DTO)
+              } else {
+                console.log('not found direct users', getRoomMembers.error)
+              }
+            }
+
+          }
 
           if(sendMessageResult.isOk()) {
 
@@ -63,19 +98,19 @@ export class SendLocalMessagesUseCaseService {
               $id : message.$id
             }
 
+            clone.sending = false
+            console.log({clone})
             console.log('send message local '+ messages.length)
 
-            this.messageLocalDataSourceService.update(message.$id, {...clone, sending: false, roomId: message.roomId})
+            this.messageLocalDataSourceService.update(message.$id, {id: sendMessageResult.value.id, sending: false})
           } else {
-
-            console.log('erro send message', sendMessageResult.error)
             this.messageLocalDataSourceService.update(message.$id, {sending: false})
           }
+          }
         }
-
-
       }
 
     }
   }
+
 }

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

@@ -13,7 +13,7 @@ export class SocketMessageDeleteUseCaseService {
 
 
   async execute(input: MessageOutPutDataDTO) {
-    const result = await this.messageLocalDataSourceService.deleteByMessageId(input.id)
+    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

@@ -19,7 +19,6 @@ export class SocketMessageUpdateUseCaseService {
   async execute(data: MessageOutPutDataDTO, tracing?: TracingType) {
 
     ParamsValidation(MessageOutPutDataDTOSchema, data, tracing)
-
     tracing?.addEvent("Message existe?")
     const result = await this.messageLocalDataSourceService.messageExist({id: data.id})
 

src/app/module/chat/domain/use-case/sync-all-room-messages.service.ts

@@ -69,23 +69,23 @@ export class SyncAllRoomMessagesService {
             }
           }
 
-          for(const message of addedItems) {
-            let clone: MessageTable = message
-            clone.roomId = room.id
+            // for(const message of addedItems) {
+            //   let clone: MessageTable = message
+            //   clone.roomId = room.id
 
-            const me = message.info.find(e => e.memberId == SessionStore.user.UserId && typeof e.deliverAt == 'string' )
-            if(!me) {
-              this.MessageSocketRepositoryService.sendDeliverAt({
-                memberId: SessionStore.user.UserId,
-                messageId: message.id,
-                roomId: message.roomId,
-                requestId: uuidv4()
-              })
+            //   const me = message.info.find(e => e.memberId == SessionStore.user.UserId && typeof e.deliverAt == 'string' )
+            //   if(!me) {
+            //     this.MessageSocketRepositoryService.sendDeliverAt({
+            //       memberId: SessionStore.user.UserId,
+            //       messageId: message.id,
+            //       roomId: message.roomId,
+            //       requestId: uuidv4()
+            //     })
 
-              tracing.addEvent('send delever roomId'+ room.id)
-              
-            }
-          }
+            //     tracing.addEvent('send delever roomId'+ room.id)
+
+            //   }
+            // }
 
 
           this.messageLocalDataSourceService.createManyMessage(addedItems.reverse())