create direct message

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

@@ -0,0 +1,99 @@
+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-update-by-id-use-case.service';
+import { MessageOutPutDataDTO } from '../../dto/message/messageOutputDTO';
+import { MessageInputDTO } from '../../dto/message/messageInputDtO';
+
+interface msgObj {
+  roomId: string;
+  senderId: string;
+  message:string;
+  messageType:1;
+  canEdit:Boolean;
+  oneShot:Boolean;
+  requestId: string;
+}
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MessageSocketRepositoryService {
+
+  constructor(
+    private socket: SignalRService
+  ) {}
+
+  async sendMessage(data: msgObj) {
+
+    try {
+      const result = await this.socket.sendMessage(data)
+      return ok(result)
+    } catch (e) {
+      return err(e)
+    }
+
+  }
+
+  async sendDirectMessage(data: MessageInputDTO) {
+    const result =  await this.socket.sendData<MessageOutPutDataDTO>({
+      method: 'SendDirectMessage',
+      data: data as any,
+    })
+
+    return result;
+  }
+
+  listenToMessages() {
+    return this.socket.getMessage()
+  }
+
+
+  listenToDeleteMessages() {
+    return this.socket.getMessageDelete()
+  }
+
+
+  listenToUpdateMessages() {
+    return this.socket.getMessageUpdate()
+  }
+
+  
+  reactToMessageSocket(data) {
+    this.socket.sendData({
+      method: 'ReactMessage',
+      data
+    })
+  }
+
+  updateMessage(input: MessageUpdateInput) {
+    this.socket.sendData({
+      method: 'EditMessage',
+      data: input,
+    })
+  }
+
+  sendTyping(roomId) {
+    return this.socket.sendTyping({
+      roomId,
+      UserName:SessionStore.user.FullName,
+      userId: SessionStore.user.UserId
+    })
+  }
+
+
+  sendMessageDelete(data: MessageDeleteInputDTO) {
+
+    data['requestId'] = InstanceId +'@'+ uuidv4();
+
+    return this.socket.sendMessageDelete(data)
+  }
+
+
+  
+
+}

src/app/module/chat/data/repository/message/message-local-data-source.service.ts

@@ -0,0 +1,210 @@
+import { Injectable } from '@angular/core';
+import { liveQuery } from 'Dexie';
+import { err, ok, Result } from 'neverthrow';
+import { Observable, Subject } from 'rxjs';
+import { filter } from 'rxjs/operators';
+import { MessageEntity } from '../../../domain/entity/message';
+import { DexieRepository } from 'src/app/infra/repository/dexie/dexie-repository.service';
+import { MessageTable, MessageTableSchema } from 'src/app/module/chat/infra/database/dexie/schema/message';
+import { chatDatabase } from '../../../infra/database/dexie/service';
+import { Observable as  DexieObservable, PromiseExtended } from 'Dexie';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MessageLocalDataSourceService extends DexieRepository<MessageTable>  {
+
+  messageSubject = new Subject();
+
+  constructor() {
+    super(chatDatabase.message, MessageTableSchema)
+
+    this.setAllSenderToFalse();
+  }
+
+  async setAllSenderToFalse() {
+    try {
+      await chatDatabase.transaction('rw', chatDatabase.message, async () => {
+        // Perform the update operation within the transaction
+        await chatDatabase.message.toCollection().modify({ sending: false });
+      });
+      console.log('All messages updated successfully.');
+    } catch (error) {
+      console.error('Error updating messages:', error);
+    }
+  }
+
+  async getLastMessageByRoomId(roomId: string): Promise<Result<undefined|MessageTable, any>> {
+    try {
+      console.log({roomId})
+      const lastMessage = await chatDatabase.message
+        .where('roomId')
+        .equals(roomId)
+        .reverse()
+        .sortBy('id');
+
+      return ok(lastMessage[0]); // Get the last message
+    } catch (error) {
+      return err(error);
+    }
+  }
+
+  async deleteByMessageId(id: string): Promise<Result<undefined|MessageTable, any>> {
+    try {
+      console.log(id)
+      const lastMessage = await chatDatabase.message
+        .where('id')
+        .equals(id).delete()
+
+      return ok(lastMessage[0]); // Get the last message
+    } catch (error) {
+      return err(error);
+    }
+  }
+
+
+  async sendMessage(data: MessageTable) {
+
+    const dataValidation = MessageTableSchema.safeParse(data)
+    if(dataValidation.success) {
+
+      const safeData = dataValidation.data
+      safeData.sending = true
+
+      try {
+        const result = await chatDatabase.message.add(safeData)
+        this.messageSubject.next({roomId: safeData.roomId});
+        return ok(result as number)
+      } catch (e) {
+        return err(false)
+      }
+
+    } else {
+      console.log(dataValidation)
+      return err(dataValidation)
+    }
+  }
+
+
+ //  @ValidateSchema(tableSchema)
+  async createMessage(data: MessageTable) {
+
+    try {
+      const result = await chatDatabase.message.add(data)
+      this.messageSubject.next({roomId: data.roomId});
+      return ok(result)
+    } catch (e) {
+      return err(false)
+    }
+
+  }
+
+  async createManyMessage(data: MessageTable[]) {
+
+    try {
+      const result = await chatDatabase.message.bulkAdd(data)
+      this.messageSubject.next({roomId: data[0].roomId});
+      return ok(result)
+    } catch (e) {
+      return err(false)
+    }
+
+  }
+
+  async messageExist({id}) {
+    try {
+
+      console.log({id});
+
+      const existingMessage = await chatDatabase.message
+      .where('id')
+      .equals(id)
+      .first();
+
+      if (existingMessage) {
+        return ok(existingMessage)
+      } else {
+        return err(false)
+      }
+
+    } catch (error) {
+      return err(false);
+    }
+
+  }
+
+  // not used
+  async updateByMessageId(data: MessageTable ) {
+
+    try {
+      const result = await chatDatabase.message.update(data.id as any, data)
+      return ok(result)
+    } catch (e) {
+      return err(false)
+    }
+
+  }
+
+
+  async findOrUpdate(data: MessageTable) {
+    const findResult = await this.findMessageById(data.id)
+
+    if(findResult.isOk()) {
+      return this.update(findResult.value.$id, data)
+    } else  {
+      return this.createMessage(data)
+    }
+  }
+
+  getItems(roomId: string): PromiseExtended<MessageEntity[]> {
+    return chatDatabase.message.where('roomId').equals(roomId).sortBy('$id') as any
+  }
+
+  getItemsLive(roomId: string): DexieObservable<MessageEntity[]> {
+    return liveQuery(() => chatDatabase.message.where('roomId').equals(roomId).sortBy('$id') as any)
+  }
+
+
+  async findMessageById(id: string) {
+    try {
+      const a = await chatDatabase.message.where('id').equals(id).first()
+
+      if(a) {
+        return ok(a)
+      } else {
+        return err('not found')
+      }
+
+    } catch (e) {
+      return err('DB error')
+    }
+
+  }
+
+
+  subscribeToNewMessage(roomId: string): Observable<MessageTable>  {
+    return this.messageSubject.pipe(
+      filter((message: MessageTable) =>
+        message.roomId === roomId
+      )
+    )
+  }
+
+
+  async getOfflineMessages () {
+    try {
+      const allMessages = await chatDatabase.message
+        .filter(msg => typeof msg.id !== 'string' && msg.sending == false)
+        .toArray();
+
+
+        console.log("======================================================================")
+        console.log({localMessage:allMessages})
+
+      return allMessages as MessageEntity[];
+    } catch (error) {
+      console.error('Error fetching messages:', error);
+    }
+  }
+}
+

src/app/module/chat/data/repository/message/message-remote-data-source.service.ts

@@ -0,0 +1,50 @@
+import { Injectable } from '@angular/core';
+import { HttpService } from 'src/app/services/http.service';
+import { MessageInputDTO, MessageInputDTOSchema } from '../../dto/message/messageInputDtO';
+import { ValidateSchema } from 'src/app/services/decorators/validate-schema.decorator';
+import { APIReturn } from 'src/app/services/decorators/api-validate-schema.decorator';
+import { MessageOutPutDataDTOSchema, MessageOutPutDTO, MessageOutPutDTOSchema } from '../../dto/message/messageOutputDTO';
+import { DataSourceReturn } from 'src/app/services/Repositorys/type';
+import { SignalRService } from '../../../infra/socket/signal-r.service';
+import { MessageUpdateInput } from '../../../domain/use-case/message-update-by-id-use-case.service';
+import { SessionStore } from 'src/app/store/session.service';
+import { MessageDeleteInputDTO } from '../../dto/message/messageDeleteInputDTO';
+import { InstanceId } from '../../../domain/chat-service.service';
+import { v4 as uuidv4 } from 'uuid'
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MessageRemoteDataSourceService {
+
+  private baseUrl = 'https://gdapi-dev.dyndns.info/stage/api/v2/Chat'; // Your base URL
+
+  constructor(
+    private httpService: HttpService,
+    private socket: SignalRService,
+  ) {}
+
+  @APIReturn(MessageOutPutDTOSchema, 'post/Messages')
+  @ValidateSchema(MessageInputDTOSchema)
+  async sendMessage(data: MessageInputDTO) {
+    return await this.httpService.post<MessageOutPutDTO>(`${this.baseUrl}/Messages`, data);
+  }
+
+  async reactToMessage(id: string, reaction: any) {
+    return await this.httpService.post<any>(`${this.baseUrl}/Messages/${id}/React`, reaction);
+  }
+
+
+  // @APIReturn(MessageOutPutDTOSchema, 'get/Messages')
+  async getMessagesFromRoom(id: string): DataSourceReturn<MessageOutPutDTO>  {
+    return await this.httpService.get(`${this.baseUrl}/Room/${id}/Messages`);
+  }
+
+
+  @APIReturn(MessageOutPutDTOSchema, 'get/Messages/attachment')
+  async getAttachment(id: string): DataSourceReturn<MessageOutPutDTO>  {
+    return await this.httpService.get(`${this.baseUrl}/attachment/${id}`);
+  }
+
+
+}