quickblox-react-ui-kit 0.5.1-beta.1 → 0.5.1-join-dialog-off.1

package/src/Data/source/remote/RemoteDataSource.ts

@@ -64,6 +64,8 @@ import {
   QBUsersGetById,
   setQB,
   getQB,
+  QBCreateGroupDialogWithAutojoinFalse,
+  QBLeaveDialog,
 } from '../../../qb-api-calls';
 import { UserDTOMapper } from './Mapper/UserDTOMapper';
 import { MessageDTOMapper } from './Mapper/MessageDTOMapper';
@@ -184,7 +186,9 @@ export class RemoteDataSource implements IRemoteDataSource {
         let hasMoreUsers = true;
 
         while (hasMoreUsers) {
-          const { ResultData, PaginationResult } = await this.getAllUsers(pagination);
+          const { ResultData, PaginationResult } = await this.getAllUsers(
+            pagination,
+          );
 
           for (const user of ResultData) {
             if (!this.userCache.has(user.id)) {
@@ -192,14 +196,18 @@ export class RemoteDataSource implements IRemoteDataSource {
             }
           }
 
-          if (PaginationResult.getCurrentPage() >= PaginationResult.totalPages) {
+          if (
+            PaginationResult.getCurrentPage() >= PaginationResult.totalPages
+          ) {
             hasMoreUsers = false;
           } else {
             pagination.setCurrentPage(pagination.getCurrentPage() + 1);
           }
         }
 
-        console.log(`User cache preload complete. Loaded ${this.userCache.size} users.`);
+        console.log(
+          `User cache preload complete. Loaded ${this.userCache.size} users.`,
+        );
 
         clearInterval(this.userCachePreloadInterval!);
         this.userCachePreloadInterval = null;
@@ -890,19 +898,30 @@ export class RemoteDataSource implements IRemoteDataSource {
   //get dialogs flow
 
   private async joinGroupDialog(dialogId: string): Promise<void> {
-    try {
-      await QBJoinGroupDialog(dialogId).catch(() => {
-        this.joinStatusMap.set(dialogId, false);
-        throw new RemoteDataSourceException(
-          INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_MESSAGE,
-          INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_CODE,
-        );
-      });
-      this.joinStatusMap.set(dialogId, true);
-    } catch (reason) {
-      console.log(`QBJoinGroupDialog error for dialog ${dialogId}:`, reason);
+    // try {
+    //   await QBJoinGroupDialog(dialogId).catch(() => {
+    //     this.joinStatusMap.set(dialogId, false);
+    //     throw new RemoteDataSourceException(
+    //       INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_MESSAGE,
+    //       INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_CODE,
+    //     );
+    //   });
+    //   this.joinStatusMap.set(dialogId, true);
+    // } catch (reason) {
+    //   console.log(`QBJoinGroupDialog error for dialog ${dialogId}:`, reason);
+    //   this.joinStatusMap.set(dialogId, false);
+    // }
+  }
+
+  public async joinDialog(dialogDto: RemoteDialogDTO): Promise<void> {
+    const dialogId = dialogDto.id;
+    await QBJoinGroupDialog(dialogId).catch(() => {
       this.joinStatusMap.set(dialogId, false);
-    }
+      throw new RemoteDataSourceException(
+        INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_MESSAGE,
+        INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_CODE,
+      );
+    });
   }
 
   //version 0.5.0-beta.11,12,14
@@ -929,7 +948,9 @@ export class RemoteDataSource implements IRemoteDataSource {
   private async processDialogsInBackground(dialogIds: string[]): Promise<void> {
     const BATCH_SIZE = 12;
 
-    console.log(`Starting background processing for ${dialogIds.length} dialogs`);
+    console.log(
+      `Starting background processing for ${dialogIds.length} dialogs`,
+    );
 
     for (let i = 0; i < dialogIds.length; i += BATCH_SIZE) {
       const batch = dialogIds.slice(i, i + BATCH_SIZE);
@@ -955,7 +976,7 @@ export class RemoteDataSource implements IRemoteDataSource {
     const pageNumber = currentPagination.getCurrentPage() || 1;
     const perPage = currentPagination.perPage || 100;
 
-    const params: Dictionary<any> =  {
+    const params: Dictionary<any> = {
       created_at: { lt: Date.now() / 1000 },
       sort_desc: 'updated_at',
       page: pageNumber,
@@ -983,9 +1004,13 @@ export class RemoteDataSource implements IRemoteDataSource {
         const qbEntity: QBChatDialog = item;
         if (!qbEntity) continue;
 
-        const newDTO: RemoteDialogDTO = await this.getCurrentDialogDTOMapper().toTDO(qbEntity);
+        const newDTO: RemoteDialogDTO =
+          await this.getCurrentDialogDTOMapper().toTDO(qbEntity);
 
-        if (newDTO.type === DialogType.group && !this.processedDialogs.has(newDTO.id)) {
+        if (
+          newDTO.type === DialogType.group &&
+          !this.processedDialogs.has(newDTO.id)
+        ) {
           this.processedDialogs.add(newDTO.id);
 
           if (!this.joinStatusMap.has(newDTO.id)) {
@@ -1250,6 +1275,54 @@ export class RemoteDataSource implements IRemoteDataSource {
     return Promise.resolve(newDTO);
   }
 
+  async createDialogWithAutojoin(
+    dto: RemoteDialogDTO,
+  ): Promise<RemoteDialogDTO> {
+    console.log(
+      'call createDialogWithAutoJoin in remote with params: ',
+      JSON.stringify(dto),
+    );
+    const qbEntity: QBChatDialog =
+      await this.getCurrentDialogDTOMapper().fromDTO(dto);
+
+    let qbDialog: QBChatDialog | undefined | null;
+
+    if (qbEntity.type === DialogType.private) {
+      const participantId = qbEntity.occupants_ids[0];
+
+      qbDialog = await QBCreatePrivateDialog(participantId, qbEntity.name);
+    } else if (qbEntity.type === DialogType.group) {
+      const participants = qbEntity.occupants_ids;
+
+      const data = { photo: qbEntity.photo };
+
+      qbDialog = await QBCreateGroupDialogWithAutojoinFalse(
+        participants,
+        qbEntity.name,
+        data,
+      );
+    }
+
+    if (qbDialog === null || qbDialog === undefined) {
+      return Promise.reject(
+        new RemoteDataSourceException(
+          INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_MESSAGE,
+          INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_CODE,
+        ),
+      );
+    }
+
+    const newDTO: RemoteDialogDTO =
+      await this.getCurrentDialogDTOMapper().toTDO(qbDialog);
+
+    console.log(
+      'have result in createDialog in remote ds: ',
+      JSON.stringify(newDTO),
+    );
+
+    return Promise.resolve(newDTO);
+  }
+
   async updateDialog(dto: RemoteDialogDTO): Promise<RemoteDialogDTO> {
     const qbEntity: QBUIKitChatDialog =
       await this.getCurrentDialogDTOMapper().fromDTO(dto);
@@ -1370,6 +1443,24 @@ export class RemoteDataSource implements IRemoteDataSource {
     return Promise.resolve();
   }
 
+  async unjoinUsersFromDialog(dialogDTO: RemoteDialogDTO): Promise<void> {
+    const qbEntity: QBChatDialog =
+      await this.getCurrentDialogDTOMapper().fromDTO(dialogDTO);
+
+    const qbResult = await QBLeaveDialog(qbEntity._id);
+
+    if (qbResult === null || qbResult === undefined) {
+      return Promise.reject(
+        new RemoteDataSourceException(
+          INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_MESSAGE,
+          INCORRECT_REMOTE_DATASOURCE_DATA_EXCEPTION_CODE,
+        ),
+      );
+    }
+
+    return Promise.resolve();
+  }
+
   // async getUser(dto: RemoteUserDTO): Promise<RemoteUserDTO> {
   //   const currentItem: QBUser | undefined = await QBUsersGetById(
   //     parseInt(dto.id, 10),
@@ -1582,9 +1673,7 @@ export class RemoteDataSource implements IRemoteDataSource {
         ),
       );
     }
-    console.log(
-      `GET MESSAGES ${qbMessages.items.length} FROM SERVER.`,
-    );
+    console.log(`GET MESSAGES ${qbMessages.items.length} FROM SERVER.`);
     const currentUserId = this._authInformation?.userId;
 
     await Promise.all(
@@ -1665,46 +1754,46 @@ export class RemoteDataSource implements IRemoteDataSource {
     //
     const messageText = dto.message;
 
-      const extension: Partial<QBUIKitChatNewMessage['extension']> = {
-          save_to_history: 1,
-          dialog_id: dto.dialogId,
-      };
-
-      if (dto.notification_type) {
-          extension.notification_type = dto.notification_type;
-      }
-
-      if (dto.sender_id || dto.recipient_id) {
-          extension.sender_id = dto.sender_id || dto.recipient_id;
-      }
+    const extension: Partial<QBUIKitChatNewMessage['extension']> = {
+      save_to_history: 1,
+      dialog_id: dto.dialogId,
+    };
 
-      if (dto.qb_message_action) {
-          extension.qb_message_action = dto.qb_message_action;
-      }
+    if (dto.notification_type) {
+      extension.notification_type = dto.notification_type;
+    }
 
-      if (dto.origin_sender_name) {
-          extension.origin_sender_name = dto.origin_sender_name;
-      }
+    if (dto.sender_id || dto.recipient_id) {
+      extension.sender_id = dto.sender_id || dto.recipient_id;
+    }
 
-      const originalMessages = MessageDTOMapper.translateOriginalDataToJSON(
-          MessageDTOMapper.convertToQBChatNewMessage(dto.qb_original_messages || []) || [],
-      );
+    if (dto.qb_message_action) {
+      extension.qb_message_action = dto.qb_message_action;
+    }
 
-      if (originalMessages && originalMessages.length > 0) {
-          extension.qb_original_messages = originalMessages;
-      }
+    if (dto.origin_sender_name) {
+      extension.origin_sender_name = dto.origin_sender_name;
+    }
 
+    const originalMessages = MessageDTOMapper.translateOriginalDataToJSON(
+      MessageDTOMapper.convertToQBChatNewMessage(
+        dto.qb_original_messages || [],
+      ) || [],
+    );
 
-      const qbEntity: QBUIKitChatNewMessage = {
-          type: dto.dialog_type === DialogType.private ? 'chat' : 'groupchat',
-          body: messageText || '',
-          dialog_id: dto.dialogId,
-          extension: extension as QBUIKitChatNewMessage['extension'],
-          markable: 1,
-      };
+    if (originalMessages && originalMessages.length > 0) {
+      extension.qb_original_messages = originalMessages;
+    }
 
+    const qbEntity: QBUIKitChatNewMessage = {
+      type: dto.dialog_type === DialogType.private ? 'chat' : 'groupchat',
+      body: messageText || '',
+      dialog_id: dto.dialogId,
+      extension: extension as QBUIKitChatNewMessage['extension'],
+      markable: 1,
+    };
 
-      // const qbEntity: QBUIKitChatNewMessage = {
+    // const qbEntity: QBUIKitChatNewMessage = {
     //   type: dto.dialog_type === DialogType.private ? 'chat' : 'groupchat',
     //   body: messageText || '',
     //   notification_type: dto.notification_type,
@@ -1736,13 +1825,13 @@ export class RemoteDataSource implements IRemoteDataSource {
         //   type: att.type.toString(),
         //   uid: att.uid,
         // };
-          const chatMessageAttachment: ChatMessageAttachment = {
-              id: att.id?.toString(),
-              name: att.name?.toString(),
-              size: att.size?.toString(),
-              type: att.type?.toString(),
-              uid: att.uid?.toString(),
-          };
+        const chatMessageAttachment: ChatMessageAttachment = {
+          id: att.id?.toString(),
+          name: att.name?.toString(),
+          size: att.size?.toString(),
+          type: att.type?.toString(),
+          uid: att.uid?.toString(),
+        };
 
         qbEntity.extension.attachments?.push(chatMessageAttachment);
       });
@@ -1767,13 +1856,22 @@ export class RemoteDataSource implements IRemoteDataSource {
       const dialogJid = QB.chat.helpers.getRoomJidFromDialogId(dto.dialogId);
       try {
         qbMessageId = await QBChatSendMessage(dialogJid, qbEntity);
-        console.log(`Dialog joined status is ${this.joinStatusMap.has(dto.dialogId)} and message was sent with Id: ${qbMessageId}`);
-      }catch (e) {
+        console.log(
+          `Dialog joined status is ${this.joinStatusMap.has(
+            dto.dialogId,
+          )} and message was sent with Id: ${qbMessageId}`,
+        );
+      } catch (e) {
         qbMessageId = undefined;
-        const errorMessage = `Error in DataSource: send message throw: ${stringifyError(e)}`;
+        const errorMessage = `Error in DataSource: send message throw: ${stringifyError(
+          e,
+        )}`;
         console.log('Error in DataSource: send message throw: ', errorMessage);
         console.warn('Error in DataSource: send message throw: ', errorMessage);
-        console.error('Error in DataSource: send message throw: ', errorMessage);
+        console.error(
+          'Error in DataSource: send message throw: ',
+          errorMessage,
+        );
       }
     }
 

package/src/Domain/repository/IDialogsRepository.ts

@@ -7,6 +7,8 @@ export interface IDialogsRepository {
 
   createDialogInRemote(dialog: DialogEntity): Promise<DialogEntity>;
 
+  createDialogWithAutojoinInRemote(dialog: DialogEntity): Promise<DialogEntity>;
+
   updateDialogInLocal(dialog: DialogEntity): Promise<DialogEntity>;
 
   updateDialogInRemote(dialog: DialogEntity): Promise<DialogEntity>;
@@ -30,6 +32,14 @@ export interface IDialogsRepository {
     userIds: Array<number>,
   ): Promise<boolean>;
 
+  unjoinUsersFromDialog(
+    dialogId: string,
+  ): Promise<boolean>;
+
+  joinUsersFromDialog(
+    dialogId: string,
+  ): Promise<boolean>;
+
   subscribeLocalSync(subscriber: FunctionTypeVoidToVoid): void;
 
   unsubscribeLocalSync(): void;

package/src/Domain/use_cases/CreateDialogWithAutoJoinUseCase.ts

@@ -0,0 +1,77 @@
+import { DialogEntity } from '../entity/DialogEntity';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import { IUseCase } from './base/IUseCase';
+import { GroupDialogEntity } from '../entity/GroupDialogEntity';
+import { stringifyError } from '../../utils/parse';
+import { RemoteMessageDTO } from '../../Data/dto/message/RemoteMessageDTO';
+import { NotificationTypes } from '../entity/NotificationTypes';
+import EventMessagesRepository from '../../Data/repository/EventMessagesRepository';
+import EventMessageType from '../entity/EventMessageType';
+
+export class CreateDialogWithAutoJoinUseCase implements IUseCase<void, DialogEntity> {
+  private dialogRepository: DialogsRepository;
+
+  private eventMessagesRepository: EventMessagesRepository;
+
+  private newDialog: GroupDialogEntity;
+
+  private textInformationMessage: string;
+
+  constructor(
+    eventMessagesRepository: EventMessagesRepository,
+    dialogRepository: DialogsRepository,
+    newDialog: GroupDialogEntity,
+    textInformationMessage: string,
+  ) {
+    this.dialogRepository = dialogRepository;
+    this.newDialog = newDialog;
+    this.eventMessagesRepository = eventMessagesRepository;
+    this.textInformationMessage = textInformationMessage;
+  }
+
+  async execute(): Promise<DialogEntity> {
+    console.log('execute CreateDialogWithAutoJoinUseCase', JSON.stringify(this.newDialog));
+    const result: DialogEntity = await this.dialogRepository
+      .createDialogWithAutojoinInRemote(this.newDialog)
+      .catch((e) => {
+        const message = stringifyError(e);
+
+        console.log('EXCEPTION IN CREATE DIALOG WITH AUTO JOIN USE CASE', message);
+        throw Error(message);
+      });
+
+    await this.dialogRepository.saveDialogToLocal(result);
+
+    this.eventMessagesRepository.dispatchEvent<DialogEntity>(
+      EventMessageType.LocalMessage,
+      result,
+      [],
+    );
+    const remoteMessageDTO: RemoteMessageDTO = new RemoteMessageDTO();
+
+    remoteMessageDTO.dialogId = result.id;
+    remoteMessageDTO.notification_type = NotificationTypes.NEW_DIALOG;
+
+    this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+      EventMessageType.SystemMessage,
+      remoteMessageDTO,
+      [...this.newDialog.participantIds],
+    );
+
+    remoteMessageDTO.dialogId = result.id;
+    remoteMessageDTO.notification_type = NotificationTypes.NEW_DIALOG;
+    remoteMessageDTO.date_sent = Date.now() / 1000;
+    remoteMessageDTO.message =
+      this.textInformationMessage && this.textInformationMessage.length > 0
+        ? this.textInformationMessage
+        : `User ${this.newDialog.ownerId} create new dialog ${this.newDialog.name}`;
+
+    this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+      EventMessageType.RegularMessage,
+      remoteMessageDTO,
+      [...this.newDialog.participantIds],
+    );
+
+    return Promise.resolve(result);
+  }
+}

package/src/Domain/use_cases/JoinFromTheDialogUseCase.ts

@@ -0,0 +1,61 @@
+import { IUseCase } from './base/IUseCase';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import EventMessagesRepository from '../../Data/repository/EventMessagesRepository';
+import { DialogEntity } from '../entity/DialogEntity';
+import { RemoteMessageDTO } from '../../Data/dto/message/RemoteMessageDTO';
+import { DialogType } from '../entity/DialogTypes';
+import { GroupDialogEntity } from '../entity/GroupDialogEntity';
+import { PrivateDialogEntity } from '../entity/PrivateDialogEntity';
+import { NotificationTypes } from '../entity/NotificationTypes';
+import EventMessageType from '../entity/EventMessageType';
+import { stringifyError } from '../../utils/parse';
+
+export class JoinFromTheDialogUseCase
+  implements IUseCase<void, boolean>
+{
+  private dialogRepository: DialogsRepository;
+
+  private eventMessagesRepository: EventMessagesRepository;
+
+  private dialogToLeave: DialogEntity;
+
+  constructor(
+    eventMessagesRepository: EventMessagesRepository,
+    dialogRepository: DialogsRepository,
+    dialog: DialogEntity,
+  ) {
+    this.eventMessagesRepository = eventMessagesRepository;
+    this.dialogRepository = dialogRepository;
+    this.dialogToLeave = dialog;
+  }
+
+  async execute(): Promise<boolean> {
+    console.log('execute JoinFromTheDialogUseCase');
+    let resultOperation = false;
+
+    const remoteMessageDTO: RemoteMessageDTO = new RemoteMessageDTO();
+
+    remoteMessageDTO.dialogId = this.dialogToLeave.id;
+    remoteMessageDTO.notification_type = NotificationTypes.DELETE_LEAVE_DIALOG;
+    remoteMessageDTO.date_sent = Date.now();
+
+    await this.dialogRepository
+      .joinUsersFromDialog(this.dialogToLeave.id)
+      .then(() => {
+        resultOperation = true;
+        console.log('join to Dialog successes');
+
+        return resultOperation;
+      })
+      .catch((reason) => {
+        console.log(
+          'have exception in delete users from Dialog : ',
+          stringifyError(reason),
+        );
+        resultOperation = false;
+      });
+
+
+    return resultOperation;
+  }
+}

package/src/Domain/use_cases/UnJoinFromTheDialogUseCase.ts

@@ -0,0 +1,61 @@
+import { IUseCase } from './base/IUseCase';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import EventMessagesRepository from '../../Data/repository/EventMessagesRepository';
+import { DialogEntity } from '../entity/DialogEntity';
+import { RemoteMessageDTO } from '../../Data/dto/message/RemoteMessageDTO';
+import { DialogType } from '../entity/DialogTypes';
+import { GroupDialogEntity } from '../entity/GroupDialogEntity';
+import { PrivateDialogEntity } from '../entity/PrivateDialogEntity';
+import { NotificationTypes } from '../entity/NotificationTypes';
+import EventMessageType from '../entity/EventMessageType';
+import { stringifyError } from '../../utils/parse';
+
+export class UnJoinFromTheDialogUseCase
+  implements IUseCase<void, boolean>
+{
+  private dialogRepository: DialogsRepository;
+
+  private eventMessagesRepository: EventMessagesRepository;
+
+  private dialogToLeave: DialogEntity;
+
+  constructor(
+    eventMessagesRepository: EventMessagesRepository,
+    dialogRepository: DialogsRepository,
+    dialog: DialogEntity,
+  ) {
+    this.eventMessagesRepository = eventMessagesRepository;
+    this.dialogRepository = dialogRepository;
+    this.dialogToLeave = dialog;
+  }
+
+  async execute(): Promise<boolean> {
+    console.log('execute UnJoinFromTheDialogUseCase');
+    let resultOperation = false;
+
+    const remoteMessageDTO: RemoteMessageDTO = new RemoteMessageDTO();
+
+    remoteMessageDTO.dialogId = this.dialogToLeave.id;
+    remoteMessageDTO.notification_type = NotificationTypes.DELETE_LEAVE_DIALOG;
+    remoteMessageDTO.date_sent = Date.now();
+
+    await this.dialogRepository
+      .unjoinUsersFromDialog(this.dialogToLeave.id)
+      .then(() => {
+        resultOperation = true;
+        console.log('Leave from Dialog successes');
+
+        return resultOperation;
+      })
+      .catch((reason) => {
+        console.log(
+          'have exception in leave Dialog : ',
+          stringifyError(reason),
+        );
+        resultOperation = false;
+      });
+
+
+    return resultOperation;
+  }
+}

package/src/Presentation/Views/Dialog/useDialogViewModel.ts

@@ -184,11 +184,20 @@ export default function useDialogViewModel(
         setError((e as unknown as Error).message);
       });
 
-    //
-
     const senderIds = Array.from(
-      new Set(messagesDialog.map((msg) => msg.sender_id)),
+      new Set(
+        messagesDialog.flatMap((msg) => {
+          const ids = [msg.sender_id];
+
+          if (Array.isArray(msg.qb_original_messages) && msg.qb_original_messages.length > 0) {
+            ids.push(msg.qb_original_messages[0].sender_id);
+          }
+
+          return ids;
+        })
+      )
     );
+
     const missingSenderIds = senderIds.filter((id) => !(id in userDictionary));
 
     const getMissingSenderUsersFromDialogByIdsUseCase: GetUsersByIdsUseCase =
@@ -426,7 +435,10 @@ export default function useDialogViewModel(
     userTypingMessageUseCase.execute().catch((reason) => {
       const errorMessage: string = stringifyError(reason);
 
-      console.log('Error: have exception in sendTypingTextMessage: ', errorMessage);
+      console.log(
+        'Error: have exception in sendTypingTextMessage: ',
+        errorMessage,
+      );
     });
   };
 
@@ -684,6 +696,8 @@ export default function useDialogViewModel(
     relatedMessage: MessageEntity,
   ): Promise<void> => {
     //
+    const senderRepliedMessage = messagesToReply[0].sender;
+
     const replyMessagesUseCase: ReplyMessagesUseCase = new ReplyMessagesUseCase(
       new MessagesRepository(LOCAL_DATA_SOURCE, REMOTE_DATA_SOURCE),
       messagesToReply,
@@ -705,8 +719,36 @@ export default function useDialogViewModel(
           })
           .finally(() => {
             setMessages((prevState) => {
+
+              if (messageEntity.qb_original_messages) {
+                const nestedObj = messageEntity.qb_original_messages
+
+                if (nestedObj && nestedObj.length > 0) {
+                    nestedObj[0].sender = senderRepliedMessage;
+                    if (
+                      nestedObj[0].sender &&
+                      nestedObj[0].sender.full_name &&
+                      regex &&
+                      !regex.test(nestedObj[0].sender.full_name)
+                    ) {
+                      nestedObj[0].sender.full_name = 'Unknown';
+                    }
+                  messageEntity.qb_original_messages = nestedObj
+                }
+              }
+
+              if (
+                messageEntity.sender &&
+                messageEntity.sender.full_name &&
+                regex &&
+                !regex.test(messageEntity.sender.full_name)
+              ) {
+                messageEntity.sender.full_name = 'Unknown';
+              }
+
               const newState = [...prevState, messageEntity];
 
+
               return newState;
             });
           });