quickblox-react-ui-kit 0.1.0 → 0.1.2

package/src/Data/repository/DialogsRepository.ts

@@ -1,422 +0,0 @@
-import { ILocalDataSource } from '../source/local/ILocalDataSource';
-import { IRemoteDataSource } from '../source/remote/IRemoteDataSource';
-import { DialogEntity } from '../../Domain/entity/DialogEntity';
-
-import RepositoryException, {
-  DIALOG_ENTITY_REPOSITORY_EXCEPTION_CODE,
-  DIALOG_ENTITY_REPOSITORY_EXCEPTION_MESSAGE,
-  UNEXPECTED_REPOSITORY_EXCEPTION_CODE,
-  UNEXPECTED_REPOSITORY_EXCEPTION_MESSAGE,
-} from '../source/exception/RepositoryException';
-import { IDialogsRepository } from '../../Domain/repository/IDialogsRepository';
-import {
-  LocalDataSourceException,
-  NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
-  NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
-  UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_CODE,
-} from '../source/exception/LocalDataSourceException';
-import { IMapper } from '../mapper/IMapper';
-import { DialogRemoteDTOMapper } from '../mapper/DialogRemoteDTOMapper';
-import { RemoteDialogDTO } from '../dto/dialog/RemoteDialogDTO';
-import { RemoteDialogsDTO } from '../dto/dialog/RemoteDialogsDTO';
-import { DialogLocalDTOMapper } from '../mapper/DialogLocalDTOMapper';
-import { LocalDialogDTO } from '../dto/dialog/LocalDialogDTO';
-import { LocalDialogsDTO } from '../dto/dialog/LocalDialogsDTO';
-import { FunctionTypeVoidToVoid } from '../../Presentation/Views/Base/BaseViewModel';
-import { MapperDTOException } from '../source/exception/MapperDTOException';
-import {
-  PaginatedResult,
-  Pagination,
-} from '../../Domain/repository/Pagination';
-import { GroupDialogEntity } from '../../Domain/entity/GroupDialogEntity';
-import { stringifyError } from '../../utils/parse';
-import { RemoteUserDTO } from '../dto/user/RemoteUserDTO';
-
-export default class DialogsRepository implements IDialogsRepository {
-  private localDataStorage: ILocalDataSource;
-
-  private remoteDataSource: IRemoteDataSource;
-
-  private dialogRemoteDTOMapper: IMapper;
-
-  private dialogLocalDTOMapper: IMapper;
-
-  // eslint-disable-next-line no-useless-constructor
-  constructor(
-    localDataStorage: ILocalDataSource,
-    remoteDataSource: IRemoteDataSource,
-  ) {
-    this.localDataStorage = localDataStorage;
-    this.remoteDataSource = remoteDataSource;
-    this.dialogRemoteDTOMapper = new DialogRemoteDTOMapper();
-    this.dialogLocalDTOMapper = new DialogLocalDTOMapper();
-  }
-
-  subscribeLocalSync(subscriber: FunctionTypeVoidToVoid): void {
-    this.localDataStorage.subscribe(subscriber);
-  }
-
-  unsubscribeLocalSync(): void {
-    this.localDataStorage.release();
-  }
-
-  isLocalSynced(): Promise<boolean> {
-    return this.localDataStorage.isLocalSynced();
-  }
-
-  setLocalSynced(synced: boolean): void {
-    this.localDataStorage.setLocalSynced(synced);
-  }
-
-  async saveDialogToLocal(entity: DialogEntity): Promise<boolean> {
-    try {
-      const dto: LocalDialogDTO = await this.dialogLocalDTOMapper.fromEntity(
-        entity,
-      );
-
-      await this.localDataStorage.saveDialog(dto);
-
-      return Promise.resolve(true);
-    } catch (e) {
-      let exceptionMessage: string;
-
-      if (e instanceof MapperDTOException) {
-        exceptionMessage = `have exception: ${e.message}, description: ${e._description} `;
-        console.log(exceptionMessage);
-      } else if (e instanceof LocalDataSourceException) {
-        exceptionMessage = `have exception: ${e.message}`;
-        console.log(exceptionMessage);
-      } else {
-        exceptionMessage = `have exception: ${
-          (e as RepositoryException).message
-        }`;
-        console.log(exceptionMessage);
-      }
-      console.log('for entity: ', JSON.stringify(entity));
-
-      // eslint-disable-next-line prefer-promise-reject-errors
-      // return Promise.reject(false);
-      return Promise.reject(exceptionMessage);
-      // todo: pay attention on Promise.resolve
-      // return Promise.resolve(false);
-    }
-  }
-
-  async createDialogInRemote(entity: DialogEntity): Promise<DialogEntity> {
-    console.log(
-      'call createDialogInRemote in Repository with param: ',
-      JSON.stringify(entity),
-    );
-    // todo exception convert error exception
-    const remoteDialogDTO: RemoteDialogDTO =
-      await this.dialogRemoteDTOMapper.fromEntity(entity);
-
-    console.log('have remoteDialogDTO: ', JSON.stringify(remoteDialogDTO));
-
-    // todo auth exception, restricted accsess, connection faild
-    try {
-      // todo MUST uncomment
-      const resultDTO: RemoteDialogDTO =
-        await this.remoteDataSource.createDialog(remoteDialogDTO);
-      const resultEntity: DialogEntity =
-        await this.dialogRemoteDTOMapper.toEntity(resultDTO);
-
-      // todo MUST delete
-      // const resultDTO: RemoteDialogDTO = remoteDialogDTO;
-      // const resultEntity: DialogEntity =
-      //   await this.dialogRemoteDTOMapper.toEntity(resultDTO);
-
-      console.log(
-        'have result entity in createDialogInRemote:',
-        JSON.stringify(resultEntity),
-      );
-
-      return Promise.resolve(resultEntity);
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-
-  async updateDialogInLocal(entity: DialogEntity): Promise<DialogEntity> {
-    console.log('call updateDialogInLocal');
-    try {
-      const dto: LocalDialogDTO = await this.dialogLocalDTOMapper.fromEntity(
-        entity,
-      );
-
-      await this.localDataStorage.updateDialog(dto);
-      const newEntity: DialogEntity = await this.dialogLocalDTOMapper.toEntity(
-        dto,
-      );
-
-      return Promise.resolve(newEntity);
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-
-  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/no-unused-vars
-  async updateDialogInRemote(entity: DialogEntity): Promise<DialogEntity> {
-    // todo exception convert error exception
-    const remoteDialogDTO: RemoteDialogDTO =
-      await this.dialogRemoteDTOMapper.fromEntity<
-        GroupDialogEntity,
-        RemoteDialogDTO
-      >(entity as GroupDialogEntity);
-
-    // todo auth exception, restricted accsess, connection faild
-    try {
-      const resultDTO: RemoteDialogDTO =
-        await this.remoteDataSource.updateDialog(remoteDialogDTO);
-      const resultEntity: DialogEntity =
-        await this.dialogRemoteDTOMapper.toEntity(resultDTO);
-
-      return Promise.resolve(resultEntity);
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-
-  async getDialogFromLocal(dialogId: string): Promise<DialogEntity> {
-    const dto: LocalDialogDTO = new LocalDialogDTO();
-
-    dto.id = dialogId;
-
-    let checkResult = true;
-
-    /*
-    if (dialogId === '0' || dialogId === '') {
-      checkResult = false;
-    }
-
-     */
-    let dialog: DialogEntity =
-      DialogRemoteDTOMapper.createDefaultDialogEntity('0');
-
-    if (checkResult) {
-      try {
-        const dtoResult: LocalDialogDTO = await this.localDataStorage.getDialog(
-          dto,
-        );
-
-        dialog = await this.dialogLocalDTOMapper.toEntity(dtoResult);
-      } catch (e) {
-        if (e instanceof LocalDataSourceException) {
-          if (e.code !== UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_CODE) {
-            // return Promise.reject(new RepositoryException(e.message, e.code));
-            return Promise.reject(
-              new RepositoryException(
-                NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
-                NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
-              ),
-            );
-            //
-          }
-
-          return Promise.reject(
-            new RepositoryException(
-              UNEXPECTED_REPOSITORY_EXCEPTION_MESSAGE,
-              UNEXPECTED_REPOSITORY_EXCEPTION_CODE,
-            ),
-          );
-        }
-        checkResult = false;
-      }
-    }
-
-    const prom = new Promise<DialogEntity>((resolve, reject) => {
-      if (checkResult === true) {
-        resolve(dialog);
-      } else {
-        reject(
-          new RepositoryException(
-            DIALOG_ENTITY_REPOSITORY_EXCEPTION_MESSAGE,
-            DIALOG_ENTITY_REPOSITORY_EXCEPTION_CODE,
-          ),
-        );
-      }
-    });
-
-    return prom;
-  }
-
-  async getDialogFromRemote(dialogId: string): Promise<DialogEntity> {
-    const dto: RemoteDialogDTO = new RemoteDialogDTO();
-
-    dto.id = dialogId;
-
-    // todo auth exception, restricted accsess, connection faild
-    try {
-      const resultDTO: RemoteDialogDTO = await this.remoteDataSource.getDialog(
-        dto,
-      );
-      const resultEntity: DialogEntity =
-        await this.dialogRemoteDTOMapper.toEntity(resultDTO);
-
-      return Promise.resolve(resultEntity);
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-
-  async getDialogsFromLocal(
-    pagination?: Pagination,
-  ): Promise<Array<DialogEntity>> {
-    try {
-      const resultDTO: LocalDialogsDTO = await this.localDataStorage.getDialogs(
-        pagination,
-      );
-      const entyties: Array<DialogEntity> = [];
-
-      // TODO: check this loop
-      // eslint-disable-next-line no-restricted-syntax
-      for (const item of resultDTO.dialogs) {
-        // eslint-disable-next-line no-await-in-loop
-        const entity: DialogEntity = await this.dialogLocalDTOMapper.toEntity(
-          item,
-        );
-
-        entyties.push(entity);
-      }
-
-      return Promise.resolve(entyties);
-    } catch (e) {
-      return Promise.reject(e);
-    }
-    /*
-    let dialogs: Array<DialogEntity> = [];
-
-    try {
-      dialogs = await this.localDataStorage.getDialogs();
-    } catch (e) {
-      if (e instanceof LocalDataSourceException) {
-        if (e.code !== UNEXPECTED_LOCAL_DATASOURCE_EXCEPTION_CODE) {
-          return Promise.reject(
-            new RepositoryException(
-              NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_MESSAGE,
-              NOT_FOUND_LOCAL_DATASOURCE_EXCEPTION_CODE,
-            ),
-          );
-        }
-
-        return Promise.reject(
-          new RepositoryException(
-            UNEXPECTED_REPOSITORY_EXCEPTION_MESSAGE,
-            UNEXPECTED_REPOSITORY_EXCEPTION_CODE,
-          ),
-        );
-      }
-    }
-
-    return Promise.resolve(dialogs);
-
-     */
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  async getDialogsFromRemote(
-    pagination?: Pagination,
-  ): Promise<PaginatedResult<DialogEntity>> {
-    // todo auth exception, restricted accsess, connection faild
-    try {
-      const resultDTO: RemoteDialogsDTO =
-        await this.remoteDataSource.getDialogs(pagination);
-      const entyties: Array<DialogEntity> = [];
-
-      // TODO: check this loop
-      // eslint-disable-next-line no-restricted-syntax
-      for (const item of resultDTO.dialogs) {
-        // eslint-disable-next-line no-await-in-loop
-        const entity: DialogEntity = await this.dialogRemoteDTOMapper.toEntity(
-          item,
-        );
-
-        entyties.push(entity);
-      }
-
-      // const DialogsDictionary: Record<number, DialogEntity[]> = {};
-      //
-      // DialogsDictionary[resultDTO.pagination.getCurrentPage()] = entyties;
-
-      const result: PaginatedResult<DialogEntity> = {
-        // PaginatedList: DialogsDictionary,
-        ResultData: entyties,
-        CurrentPagination: resultDTO.pagination,
-      };
-
-      return Promise.resolve(result);
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-
-  async deleteDialogFromLocal(dialogId: string): Promise<boolean> {
-    const dto: LocalDialogDTO = new LocalDialogDTO();
-
-    dto.id = dialogId;
-    try {
-      await this.localDataStorage.deleteDialog(dto);
-
-      return Promise.resolve(true);
-    } catch (e) {
-      console.log('exception in deleteDialogFromLocal: ', stringifyError(e));
-
-      return Promise.reject(e);
-    }
-    /*
-    try {
-      const resultDeleteDialog = await this.localDataStorage.deleteDialog(
-        dialogId,
-      );
-
-      return resultDeleteDialog;
-    } catch (e) {
-      return Promise.resolve(false);
-    }
-     */
-  }
-
-  // eslint-disable-next-line class-methods-use-this,@typescript-eslint/no-unused-vars
-  async deleteDialogFromRemote(dialogId: string): Promise<boolean> {
-    const dto: RemoteDialogDTO = new RemoteDialogDTO();
-
-    dto.id = dialogId;
-
-    // todo auth exception, restricted accsess, connection faild
-    try {
-      await this.remoteDataSource.deleteDialog(dto);
-
-      return Promise.resolve(true);
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-
-  async deleteUsersFromDialogFromRemote(
-    dialogId: string,
-    usersIds: Array<number>,
-  ): Promise<boolean> {
-    const dialogDTO: RemoteDialogDTO = new RemoteDialogDTO();
-
-    dialogDTO.id = dialogId;
-    const arrayUsersDTO: Array<RemoteUserDTO> = new Array<RemoteUserDTO>();
-
-    try {
-      for (let i = 0; i < usersIds.length; i += 1) {
-        const dto: RemoteUserDTO = new RemoteUserDTO();
-
-        dto.id = usersIds[i].toString();
-        arrayUsersDTO.push(dto);
-      }
-
-      await this.remoteDataSource.deleteUsersFromDialog(
-        dialogDTO,
-        arrayUsersDTO,
-      );
-
-      return Promise.resolve(true);
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  }
-}

package/src/Data/repository/EventMessagesRepository.ts

@@ -1,291 +0,0 @@
-import {
-  // eslint-disable-next-line import/named
-  Registry,
-  SubscriptionPerformer,
-} from '../../Domain/use_cases/base/Subscribable/SubscriptionPerformer';
-import { RemoteDataSource } from '../source/remote/RemoteDataSource';
-import ConnectionRepository from './ConnectionRepository';
-import { LocalDataSource } from '../source/local/LocalDataSource';
-import { RemoteMessageDTO } from '../dto/message/RemoteMessageDTO';
-import { stringifyError } from '../../utils/parse';
-import { CallBackFunction } from '../../Domain/use_cases/base/IUseCase';
-import EventMessageType from '../../Domain/entity/EventMessageType';
-import { IRemoteMessaging } from '../source/remote/IRemoteDataSource';
-import { MessageEntity } from '../../Domain/entity/MessageEntity';
-import { NotificationTypes } from '../../Domain/entity/NotificationTypes';
-import { MessageRemoteDTOMapper } from '../mapper/MessageRemoteDTOMapper';
-import { DialogEventInfo } from '../../Domain/entity/DialogEventInfo';
-
-export interface IEventBus {
-  dispatch<T>(event: string, arg?: T): void;
-  register<T>(event: string, callback: CallBackFunction<T>): Registry;
-}
-
-export default class EventMessagesRepository
-  implements IRemoteMessaging<MessageEntity>
-{
-  private messageDTOMapper: MessageRemoteDTOMapper;
-
-  protected subscriptionOnSystemMessages: Dictionary<
-    SubscriptionPerformer<MessageEntity>
-  > = {};
-
-  protected subscriptionOnChatMessages: SubscriptionPerformer<MessageEntity> =
-    new SubscriptionPerformer<MessageEntity>();
-
-  protected subscriptionOnUpdateMessageStatus: SubscriptionPerformer<DialogEventInfo> =
-    new SubscriptionPerformer<DialogEventInfo>();
-
-  constructor(
-    private remoteDs: RemoteDataSource,
-    private localDs: LocalDataSource,
-    private connectionRep: ConnectionRepository,
-  ) {
-    console.log('CREATE EventMessagesRepository');
-    this.messageDTOMapper = new MessageRemoteDTOMapper();
-    this.subscriptionOnSystemMessages[NotificationTypes.UPDATE_DIALOG] =
-      new SubscriptionPerformer<MessageEntity>();
-    this.subscriptionOnSystemMessages[NotificationTypes.DELETE_LEAVE_DIALOG] =
-      new SubscriptionPerformer<MessageEntity>();
-    this.subscriptionOnSystemMessages[NotificationTypes.NEW_DIALOG] =
-      new SubscriptionPerformer<MessageEntity>();
-    this.remoteDs.subscribeOnSystemMessaging(
-      NotificationTypes.NEW_DIALOG,
-      this.NewDialogEventHandler.bind(this),
-    );
-    this.remoteDs.subscribeOnSystemMessaging(
-      NotificationTypes.UPDATE_DIALOG,
-      this.UpdateDialogEventHandler.bind(this),
-    );
-    this.remoteDs.subscribeOnSystemMessaging(
-      NotificationTypes.DELETE_LEAVE_DIALOG,
-      this.DeleteLeaveDialogEventHandler.bind(this),
-    );
-    this.remoteDs.subscribeOnMessaging(this.NewMessageEventHandler.bind(this));
-    this.remoteDs.subscribeOnUpdateMessageStatus(
-      this.UpdateMessageStatusEventHandler.bind(this),
-    );
-  }
-
-  protected UpdateMessageStatusEventHandler(
-    messageInfo: DialogEventInfo,
-  ): void {
-    console.log(
-      'call UpdateMessageStatusEventHandler with updated message status in EventMessagesRepository',
-    );
-    this.subscriptionOnUpdateMessageStatus.informSubscribers(
-      messageInfo,
-      EventMessageType.LocalMessage,
-    );
-  }
-
-  protected NewMessageEventHandler(messageInfo: RemoteMessageDTO): void {
-    console.log(
-      'call NewMessageEventHandler with new message in EventMessagesRepository',
-    );
-    this.messageDTOMapper
-      .toEntity<RemoteMessageDTO, MessageEntity>(messageInfo)
-      // eslint-disable-next-line promise/always-return
-      .then((currentMessage: MessageEntity) => {
-        console.log(
-          'have system message for dialog',
-          JSON.stringify(currentMessage),
-        );
-        this.subscriptionOnChatMessages.informSubscribers(
-          currentMessage,
-          EventMessageType.RegularMessage,
-        );
-      })
-      .catch((reason) => {
-        const errorMessage = stringifyError(reason);
-
-        console.log(
-          'get system message with new dialog with exception:',
-          errorMessage,
-        );
-
-        throw new Error(errorMessage);
-      });
-  }
-
-  protected NewDialogEventHandler(messageInfo: RemoteMessageDTO): void {
-    this.messageDTOMapper
-      .toEntity<RemoteMessageDTO, MessageEntity>(messageInfo)
-      // eslint-disable-next-line promise/always-return
-      .then((currentMessage: MessageEntity) => {
-        console.log(
-          'have system message new dialog',
-          JSON.stringify(currentMessage),
-        );
-        this.subscriptionOnSystemMessages[
-          NotificationTypes.NEW_DIALOG
-        ].informSubscribers(currentMessage, EventMessageType.SystemMessage);
-      })
-      .catch((reason) => {
-        const errorMessage = stringifyError(reason);
-
-        console.log(
-          'get system message with new dialog with exception:',
-          errorMessage,
-        );
-
-        throw new Error(errorMessage);
-      });
-  }
-
-  protected DeleteLeaveDialogEventHandler(messageInfo: RemoteMessageDTO): void {
-    this.messageDTOMapper
-      .toEntity<RemoteMessageDTO, MessageEntity>(messageInfo)
-      // eslint-disable-next-line promise/always-return
-      .then((currentMessage: MessageEntity) => {
-        console.log(
-          'have system message new dialog',
-          JSON.stringify(currentMessage),
-        );
-        this.subscriptionOnSystemMessages[
-          NotificationTypes.DELETE_LEAVE_DIALOG
-        ].informSubscribers(currentMessage, EventMessageType.SystemMessage);
-      })
-      .catch((reason) => {
-        const errorMessage = stringifyError(reason);
-
-        console.log(
-          'get system message with new dialog with exception:',
-          errorMessage,
-        );
-
-        throw new Error(errorMessage);
-      });
-  }
-
-  protected UpdateDialogEventHandler(messageInfo: RemoteMessageDTO): void {
-    console.log('call UpdateDialogEventHandler');
-    if (this.messageDTOMapper) {
-      this.messageDTOMapper
-        .toEntity<RemoteMessageDTO, MessageEntity>(messageInfo)
-        // eslint-disable-next-line promise/always-return
-        .then((currentMessage: MessageEntity) => {
-          console.log(
-            'have system message new dialog',
-            JSON.stringify(currentMessage),
-          );
-          const subs =
-            this.subscriptionOnSystemMessages[NotificationTypes.UPDATE_DIALOG];
-
-          subs.informSubscribers(
-            currentMessage,
-            EventMessageType.SystemMessage,
-          );
-        })
-        .catch((reason) => {
-          const errorMessage = stringifyError(reason);
-
-          console.log(
-            'get system message with new dialog with exception:',
-            errorMessage,
-          );
-
-          throw new Error(errorMessage);
-        });
-    } else {
-      console.log('exception: this.messageDTOMapper');
-    }
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  public dispatchEvent<TEventInfo>(
-    even: EventMessageType,
-    eventBody: TEventInfo,
-    receivers: number[],
-  ) {
-    console.log(
-      `call dispatchEvent ${even.toString()} with ${JSON.stringify(
-        eventBody,
-      )} for ${JSON.stringify(receivers)}`,
-    );
-    if (even === EventMessageType.LocalMessage) {
-      this.localDs.setLocalSynced(true);
-    }
-    if (even === EventMessageType.SystemMessage) {
-      receivers.forEach((id) => {
-        const systemMessageInfo: RemoteMessageDTO =
-          eventBody as RemoteMessageDTO;
-
-        systemMessageInfo.recipient_id = id;
-
-        this.remoteDs.sendSystemMessage(systemMessageInfo).catch((reason) => {
-          console.log(
-            `EXCEPTION IN send System Message for recipient_id ${id}: `,
-            stringifyError(reason),
-          );
-        });
-      });
-    }
-    if (even === EventMessageType.RegularMessage) {
-      const messageInfo: RemoteMessageDTO = eventBody as RemoteMessageDTO;
-
-      this.remoteDs.sendMessage(messageInfo).catch((reason) => {
-        console.log(
-          `EXCEPTION IN send Regular Message for dialog ${messageInfo.dialogId}: `,
-          stringifyError(reason),
-        );
-      });
-    }
-  }
-
-  subscribeOnMessaging(
-    callback: CallBackFunction<MessageEntity>,
-    nameSubscription: string = SubscriptionPerformer.DEFAULT_SUBSCRIPTION_NAME,
-  ): void {
-    this.subscriptionOnChatMessages.subscribe(
-      callback,
-      EventMessageType.RegularMessage,
-      nameSubscription,
-    );
-  }
-
-  subscribeOnUpdateMessageStatus(
-    callback: CallBackFunction<DialogEventInfo>,
-    nameSubscription: string = SubscriptionPerformer.DEFAULT_SUBSCRIPTION_NAME,
-  ): void {
-    this.subscriptionOnUpdateMessageStatus.subscribe(
-      callback,
-      EventMessageType.LocalMessage,
-      nameSubscription,
-    );
-  }
-
-  releaseSubscriptions(): void {
-    Object.entries(this.subscriptionOnSystemMessages).map((x) => {
-      const eventName = x[0];
-
-      return this.subscriptionOnSystemMessages[eventName].release();
-    });
-  }
-
-  subscribeOnSystemMessaging(
-    notificationType: NotificationTypes,
-    callback: CallBackFunction<MessageEntity>,
-    nameSubscription: string = SubscriptionPerformer.DEFAULT_SUBSCRIPTION_NAME,
-  ): void {
-    let SystemMessageType: string = NotificationTypes.NEW_DIALOG;
-
-    switch (notificationType) {
-      case NotificationTypes.DELETE_LEAVE_DIALOG:
-        SystemMessageType = NotificationTypes.DELETE_LEAVE_DIALOG;
-        break;
-      case NotificationTypes.UPDATE_DIALOG:
-        SystemMessageType = NotificationTypes.UPDATE_DIALOG;
-        break;
-      default:
-        SystemMessageType = NotificationTypes.NEW_DIALOG;
-        break;
-    }
-
-    this.subscriptionOnSystemMessages[SystemMessageType].subscribe(
-      callback,
-      EventMessageType.SystemMessage,
-      nameSubscription,
-    );
-  }
-}