quickblox-react-ui-kit 0.1.0

package/src/Domain/use_cases/GetAllMessagesForDialog.ts

@@ -0,0 +1,61 @@
+import { IUseCase } from './base/IUseCase';
+import { MessageEntity } from '../entity/MessageEntity';
+import { IMessagesRepository } from '../repository/IMessagesRepository';
+import { PaginatedResult, Pagination } from '../repository/Pagination';
+
+export class GetAllMessagesForDialogMock
+  implements IUseCase<void, Array<MessageEntity>>
+{
+  private messagesRepository: IMessagesRepository;
+
+  private readonly dialogId: string;
+
+  private currentPagination: Pagination;
+
+  constructor(
+    messagesRepository: IMessagesRepository,
+    dialogId: string,
+    currentPagination: Pagination,
+  ) {
+    console.log('CONSTRUCTOR GetAllMessagesForDialog');
+    this.messagesRepository = messagesRepository;
+    this.dialogId = dialogId;
+    this.currentPagination = currentPagination;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async execute(): Promise<Array<MessageEntity>> {
+    console.log('execute GetAllMessagesForDialog');
+    //
+    const result: PaginatedResult<MessageEntity> =
+      await this.messagesRepository.getMessagesFromRemote(
+        this.dialogId,
+        this.currentPagination,
+      );
+
+    console.log(
+      `GET MESSAGES ${
+        result.ResultData.length
+      } FROM REPOSITORY: ${JSON.stringify(result)} `,
+    );
+
+    //
+    // await Promise.all(
+    //   result.ResultData.map(async (entity) => {
+    //     await this.messagesRepository.saveMessageToLocal(entity).catch((e) => {
+    //       console.log(
+    //         'EXCEPTION MessageEntity perform in GetAllMessagesForDialog: ',
+    //         JSON.stringify(entity),
+    //       );
+    //       console.log(stringifyError(e));
+    //     });
+    //
+    //     return entity;
+    //   }),
+    // );
+    // return this.messagesRepository.getMessagesFromLocal(this.dialogId);
+    //
+    //
+    return result.ResultData;
+  }
+}

package/src/Domain/use_cases/GetAllUsersUseCase.ts

@@ -0,0 +1,34 @@
+import { IUseCase } from './base/IUseCase';
+import UsersRepository from '../../Data/repository/UsersRepository';
+import { PaginatedResult, Pagination } from '../repository/Pagination';
+import { UserEntity } from '../entity/UserEntity';
+
+export class GetAllUsersUseCase
+  implements IUseCase<void, PaginatedResult<UserEntity>>
+{
+  private usersRepository: UsersRepository;
+
+  private currentPagination: Pagination;
+
+  private filter: string;
+
+  constructor(
+    usersRepository: UsersRepository,
+    currentPagination: Pagination,
+    filter: string,
+  ) {
+    console.log('CONSTRUCTOR GetUsersByIdsUseCase');
+    this.usersRepository = usersRepository;
+    this.currentPagination = currentPagination;
+    this.filter = filter;
+  }
+
+  execute(): Promise<PaginatedResult<UserEntity>> {
+    console.log('execute GetUsersByIdsUseCase');
+
+    return this.usersRepository.getALLUsersFromRemote(
+      this.currentPagination,
+      this.filter,
+    );
+  }
+}

package/src/Domain/use_cases/GetDialogByIdUseCase.ts

@@ -0,0 +1,28 @@
+import { IUseCase } from './base/IUseCase';
+import { DialogEntity } from '../entity/DialogEntity';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+
+export class GetDialogByIdUseCase implements IUseCase<void, DialogEntity> {
+  private readonly dialogRepository: DialogsRepository;
+
+  private readonly dialogId: string;
+
+  constructor(dialogRepository: DialogsRepository, dialogId: string) {
+    console.log('CONSTRUCTOR GetDialogByIdUseCase');
+    this.dialogRepository = dialogRepository;
+    this.dialogId = dialogId;
+  }
+
+  async execute(): Promise<DialogEntity> {
+    console.log('execute GetAllDialogsUseCaseWithMock');
+    const fromRemote: DialogEntity =
+      await this.dialogRepository.getDialogFromRemote(this.dialogId);
+
+    await this.dialogRepository.updateDialogInLocal(fromRemote);
+
+    const dialogResult: DialogEntity =
+      await this.dialogRepository.getDialogFromLocal(this.dialogId);
+
+    return dialogResult;
+  }
+}

package/src/Domain/use_cases/GetUsersByIdsUseCase.ts

@@ -0,0 +1,22 @@
+import { IUseCase } from './base/IUseCase';
+import { UserEntity } from '../entity/UserEntity';
+import UsersRepository from '../../Data/repository/UsersRepository';
+
+export class GetUsersByIdsUseCase implements IUseCase<void, Array<UserEntity>> {
+  private usersRepository: UsersRepository;
+
+  private userIds: Array<number>;
+
+  constructor(usersRepository: UsersRepository, userIds: Array<number>) {
+    console.log('CONSTRUCTOR GetUsersByIdsUseCase');
+    this.usersRepository = usersRepository;
+    this.userIds = userIds;
+  }
+
+  execute(): Promise<Array<UserEntity>> {
+    console.log('execute GetUsersByIdsUseCase');
+
+    // return this.usersRepository.getUsersFromLocal(this.userIds);
+    return this.usersRepository.getUsersFromRemote(this.userIds);
+  }
+}

package/src/Domain/use_cases/LeaveDialogUseCase.ts

@@ -0,0 +1,109 @@
+import { IUseCase } from './base/IUseCase';
+import { DialogEntity } from '../entity/DialogEntity';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import { RemoteMessageDTO } from '../../Data/dto/message/RemoteMessageDTO';
+import { stringifyError } from '../../utils/parse';
+import { NotificationTypes } from '../entity/NotificationTypes';
+import { DialogType } from '../entity/DialogTypes';
+import { GroupDialogEntity } from '../entity/GroupDialogEntity';
+import { PrivateDialogEntity } from '../entity/PrivateDialogEntity';
+import EventMessagesRepository from '../../Data/repository/EventMessagesRepository';
+import EventMessageType from '../entity/EventMessageType';
+
+export const DialogLeaveType = {
+  delete: 'delete',
+  deleteForce: 'deleteForce',
+  leave: 'leave',
+} as const;
+
+export type DialogLeaveTypeArcheType = keyof typeof DialogLeaveType;
+
+export class LeaveDialogUseCase implements IUseCase<void, boolean> {
+  private dialogRepository: DialogsRepository;
+
+  private eventMessagesRepository: EventMessagesRepository;
+
+  private dialogToLeave: DialogEntity;
+
+  private leaveType: DialogLeaveTypeArcheType;
+
+  constructor(
+    eventMessagesRepository: EventMessagesRepository,
+    dialogRepository: DialogsRepository,
+    dialog: DialogEntity,
+    leaveType: DialogLeaveTypeArcheType,
+  ) {
+    console.log('CONSTRUCTOR LeaveDialogUseCase');
+    this.eventMessagesRepository = eventMessagesRepository;
+    this.dialogRepository = dialogRepository;
+    this.dialogToLeave = dialog;
+    this.leaveType = leaveType;
+  }
+
+  async execute(): Promise<boolean> {
+    console.log('execute LeaveDialogUseCase');
+    let resultOperation = false;
+
+    //
+    const remoteMessageDTO: RemoteMessageDTO = new RemoteMessageDTO();
+    let receivers: number[] = [];
+
+    if (this.dialogToLeave.type === DialogType.group) {
+      receivers = [...(this.dialogToLeave as GroupDialogEntity).participantIds];
+    }
+
+    if (this.dialogToLeave.type === DialogType.private) {
+      receivers = [(this.dialogToLeave as PrivateDialogEntity).participantId];
+    }
+
+    remoteMessageDTO.dialogId = this.dialogToLeave.id;
+    remoteMessageDTO.notification_type = NotificationTypes.DELETE_LEAVE_DIALOG;
+    remoteMessageDTO.date_sent = Date.now();
+    remoteMessageDTO.message = `User ${this.dialogToLeave.ownerId} has left dialog.`;
+
+    this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+      EventMessageType.RegularMessage,
+      remoteMessageDTO,
+      receivers,
+    );
+    //
+
+    await this.dialogRepository
+      .deleteDialogFromRemote(this.dialogToLeave.id)
+      .then(() => {
+        resultOperation = true;
+        console.log('dialog was deleted successes');
+
+        return resultOperation;
+      })
+      .catch((reason) => {
+        console.log(
+          'have exception in deleteDialogFromRemote: ',
+          stringifyError(reason),
+        );
+        resultOperation = false;
+      });
+    if (resultOperation) {
+      console.log('try to delete dialog in local');
+
+      remoteMessageDTO.dialogId = this.dialogToLeave.id;
+      remoteMessageDTO.notification_type =
+        NotificationTypes.DELETE_LEAVE_DIALOG;
+
+      await this.dialogRepository.deleteDialogFromLocal(this.dialogToLeave.id);
+      this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+        EventMessageType.LocalMessage,
+        remoteMessageDTO,
+        [],
+      );
+
+      this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+        EventMessageType.SystemMessage,
+        remoteMessageDTO,
+        receivers,
+      );
+    }
+
+    return resultOperation;
+  }
+}

package/src/Domain/use_cases/RemoveUsersFromTheDialogUseCase.ts

@@ -0,0 +1,103 @@
+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 RemoveUsersFromTheDialogUseCase
+  implements IUseCase<void, boolean>
+{
+  private dialogRepository: DialogsRepository;
+
+  private eventMessagesRepository: EventMessagesRepository;
+
+  private dialogToLeave: DialogEntity;
+
+  private usersIds: Array<number>;
+
+  constructor(
+    eventMessagesRepository: EventMessagesRepository,
+    dialogRepository: DialogsRepository,
+    dialog: DialogEntity,
+    usersIds: Array<number>,
+  ) {
+    console.log('CONSTRUCTOR LeaveDialogUseCase');
+    this.eventMessagesRepository = eventMessagesRepository;
+    this.dialogRepository = dialogRepository;
+    this.dialogToLeave = dialog;
+    this.usersIds = usersIds;
+  }
+
+  async execute(): Promise<boolean> {
+    console.log('execute LeaveDialogUseCase');
+    let resultOperation = false;
+
+    //
+    const remoteMessageDTO: RemoteMessageDTO = new RemoteMessageDTO();
+    let receivers: number[] = [];
+
+    if (this.dialogToLeave.type === DialogType.group) {
+      receivers = [...(this.dialogToLeave as GroupDialogEntity).participantIds];
+    }
+
+    if (this.dialogToLeave.type === DialogType.private) {
+      receivers = [(this.dialogToLeave as PrivateDialogEntity).participantId];
+    }
+
+    remoteMessageDTO.dialogId = this.dialogToLeave.id;
+    remoteMessageDTO.notification_type = NotificationTypes.DELETE_LEAVE_DIALOG;
+    remoteMessageDTO.date_sent = Date.now();
+    remoteMessageDTO.message = `User ${this.dialogToLeave.ownerId} has left dialog.`;
+
+    this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+      EventMessageType.RegularMessage,
+      remoteMessageDTO,
+      receivers,
+    );
+    //
+
+    await this.dialogRepository
+      .deleteUsersFromDialogFromRemote(this.dialogToLeave.id, this.usersIds)
+      .then(() => {
+        resultOperation = true;
+        console.log('dialog was deleted users from Dialog successes');
+
+        return resultOperation;
+      })
+      .catch((reason) => {
+        console.log(
+          'have exception in delete users from Dialog : ',
+          stringifyError(reason),
+        );
+        resultOperation = false;
+      });
+    if (resultOperation) {
+      console.log('try to delete dialog in local');
+
+      remoteMessageDTO.dialogId = this.dialogToLeave.id;
+      remoteMessageDTO.notification_type =
+        NotificationTypes.DELETE_LEAVE_DIALOG;
+
+      await this.dialogRepository.deleteDialogFromLocal(this.dialogToLeave.id);
+      this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+        EventMessageType.LocalMessage,
+        remoteMessageDTO,
+        [],
+      );
+
+      this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+        EventMessageType.SystemMessage,
+        remoteMessageDTO,
+        receivers,
+      );
+    }
+
+    return resultOperation;
+  }
+}

package/src/Domain/use_cases/SendTextMessageUseCase.ts

@@ -0,0 +1,26 @@
+import { IUseCase } from './base/IUseCase';
+import { MessageEntity } from '../entity/MessageEntity';
+import MessagesRepository from '../../Data/repository/MessagesRepository';
+
+export class SendTextMessageUseCase implements IUseCase<void, MessageEntity> {
+  private messagesRepository: MessagesRepository;
+
+  private messageToSend: MessageEntity;
+
+  constructor(
+    messagesRepository: MessagesRepository,
+    messageToSend: MessageEntity,
+  ) {
+    console.log('CONSTRUCTOR SendTextMessageUseCase');
+    this.messagesRepository = messagesRepository;
+    this.messageToSend = messageToSend;
+  }
+
+  async execute(): Promise<MessageEntity> {
+    console.log('execute SendTextMessageUseCase');
+
+    await this.messagesRepository.sendMessageToRemote(this.messageToSend);
+
+    return Promise.resolve(this.messageToSend);
+  }
+}

package/src/Domain/use_cases/SubscribeToDialogEventsUseCase.ts

@@ -0,0 +1,141 @@
+import { BaseUseCase } from './base/BaseUseCase';
+import { CallBackFunction } from './base/IUseCase';
+import EventMessagesRepository from '../../Data/repository/EventMessagesRepository';
+import EventMessageType from '../entity/EventMessageType';
+import { NotificationTypes } from '../entity/NotificationTypes';
+import { MessageEntity } from '../entity/MessageEntity';
+import { SubscriptionPerformer } from './base/Subscribable/SubscriptionPerformer';
+import { DialogEventInfo } from '../entity/DialogEventInfo';
+
+export class SubscribeToDialogEventsUseCase extends BaseUseCase<
+  DialogEventInfo,
+  boolean
+> {
+  private eventMessagesRepository: EventMessagesRepository;
+
+  private callBackExecute: CallBackFunction<DialogEventInfo> | undefined;
+
+  // todo: delete synUseCase: BaseUseCase<boolean>, use only dialogRepository
+  constructor(
+    eventMessagesRepository: EventMessagesRepository,
+    nameSubscription: string = SubscriptionPerformer.DEFAULT_SUBSCRIPTION_NAME,
+  ) {
+    console.log('CONSTRUCTOR SubscribeToDialogsUpdatesUseCaseWithMock');
+    super();
+    this.callBackExecute = undefined;
+
+    this.EVENT_NAME = nameSubscription;
+    this.EVENT_TYPE = EventMessageType.LocalMessage;
+    this.eventMessagesRepository = eventMessagesRepository;
+  }
+
+  execute(callBack: CallBackFunction<DialogEventInfo>): Promise<boolean> {
+    console.log('execute SubscribeToDialogEventsUseCase', callBack);
+    this.callBackExecute = callBack;
+    if (
+      this.callBackExecute !== undefined &&
+      typeof this.callBackExecute === 'function'
+    ) {
+      this.subscribe(this.callBackExecute, this.EVENT_TYPE, this.EVENT_NAME);
+    }
+
+    this.eventMessagesRepository.subscribeOnSystemMessaging(
+      NotificationTypes.NEW_DIALOG,
+      this.newDialogEventHandler.bind(this),
+      this.EVENT_NAME,
+    );
+
+    this.eventMessagesRepository.subscribeOnSystemMessaging(
+      NotificationTypes.DELETE_LEAVE_DIALOG,
+      this.leaveDialogEventHandler.bind(this),
+      this.EVENT_NAME,
+    );
+
+    this.eventMessagesRepository.subscribeOnSystemMessaging(
+      NotificationTypes.UPDATE_DIALOG,
+      this.updateDialogEventHandler.bind(this),
+      this.EVENT_NAME,
+    );
+
+    this.eventMessagesRepository.subscribeOnMessaging(
+      this.newMessageEventHandler.bind(this),
+      this.EVENT_NAME,
+    );
+
+    this.eventMessagesRepository.subscribeOnUpdateMessageStatus(
+      this.updateMessageStatusEventHandler.bind(this),
+      this.EVENT_NAME,
+    );
+
+    return Promise.resolve(true);
+  }
+
+  updateMessageStatusEventHandler(dialogEventInfo: DialogEventInfo): void {
+    console.log(
+      'execute newDialogEventHandler in SubscribeToDialogEventsUseCase:',
+      JSON.stringify(dialogEventInfo),
+    );
+
+    this.informSubscribers(dialogEventInfo);
+  }
+
+  newMessageEventHandler(messageEntity: MessageEntity): void {
+    console.log(
+      'execute newDialogEventHandler in SubscribeToDialogEventsUseCase:',
+      JSON.stringify(messageEntity),
+    );
+    const messageInfo: DialogEventInfo = {
+      messageInfo: messageEntity,
+      notificationTypes: NotificationTypes.UPDATE_DIALOG,
+      eventMessageType: EventMessageType.RegularMessage,
+      messageStatus: undefined,
+    };
+
+    this.informSubscribers(messageInfo);
+  }
+
+  updateDialogEventHandler(messageEntity: MessageEntity): void {
+    console.log(
+      'execute updateDialogEventHandler in SubscribeToDialogEventsUseCase:',
+      JSON.stringify(messageEntity),
+    );
+    const messageInfo: DialogEventInfo = {
+      messageInfo: messageEntity,
+      notificationTypes: NotificationTypes.UPDATE_DIALOG,
+      eventMessageType: EventMessageType.SystemMessage,
+      messageStatus: undefined,
+    };
+
+    this.informSubscribers(messageInfo);
+  }
+
+  leaveDialogEventHandler(messageEntity: MessageEntity): void {
+    console.log(
+      'execute leaveDialogEventHandler in SubscribeToDialogEventsUseCase:',
+      JSON.stringify(messageEntity),
+    );
+    const messageInfo: DialogEventInfo = {
+      messageInfo: messageEntity,
+      notificationTypes: NotificationTypes.DELETE_LEAVE_DIALOG,
+      eventMessageType: EventMessageType.SystemMessage,
+      messageStatus: undefined,
+    };
+
+    this.informSubscribers(messageInfo);
+  }
+
+  newDialogEventHandler(messageEntity: MessageEntity): void {
+    console.log(
+      'execute newDialogEventHandler in SubscribeToDialogEventsUseCase:',
+      JSON.stringify(messageEntity),
+    );
+    const messageInfo: DialogEventInfo = {
+      messageInfo: messageEntity,
+      notificationTypes: NotificationTypes.NEW_DIALOG,
+      eventMessageType: EventMessageType.SystemMessage,
+      messageStatus: undefined,
+    };
+
+    this.informSubscribers(messageInfo);
+  }
+}

package/src/Domain/use_cases/SubscribeToDialogsUpdatesUseCase.ts

@@ -0,0 +1,69 @@
+import { BaseUseCase } from './base/BaseUseCase';
+import { DialogEntity } from '../entity/DialogEntity';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import { CallBackFunction } from './base/IUseCase';
+
+export class SubscribeToDialogsUpdatesUseCase extends BaseUseCase<
+  Array<DialogEntity>,
+  Array<DialogEntity>
+> {
+  private dialogRepository: DialogsRepository;
+
+  private callBackExecute: CallBackFunction<Array<DialogEntity>> | undefined;
+
+  private dialogs: Array<DialogEntity> = [];
+
+  // todo: delete synUseCase: BaseUseCase<boolean>, use only dialogRepository
+  constructor(dialogRepository: DialogsRepository) {
+    console.log('CONSTRUCTOR SubscribeToDialogsUpdatesUseCase');
+    super();
+    this.callBackExecute = undefined;
+
+    this.dialogRepository = dialogRepository;
+  }
+
+  execute(
+    callBack: CallBackFunction<Array<DialogEntity>>,
+  ): Promise<Array<DialogEntity>> {
+    console.log('execute SubscribeToDialogsUpdatesUseCase', callBack);
+    this.callBackExecute = callBack;
+    if (
+      this.callBackExecute !== undefined &&
+      typeof this.callBackExecute === 'function'
+    ) {
+      this.subscribe(this.callBackExecute);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    // this.synUseCase.execute(async () => {
+    //   console.log(
+    //     '2.CALL EXECUTE CALLBACK in SubscribeToDialogsUpdatesUseCase',
+    //   );
+    //   this.dialogs = await this.dialogRepository.getDialogsFromLocal();
+    //   this.informSubscribers(this.dialogs);
+    // });
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    this.dialogRepository.subscribeLocalSync(async () => {
+      console.log(
+        '2.CALL EXECUTE CALLBACK in SubscribeToDialogsUpdatesUseCase',
+      );
+      this.dialogs = await this.dialogRepository.getDialogsFromLocal();
+      this.informSubscribers(this.dialogs);
+    });
+
+    return Promise.resolve(this.dialogRepository.getDialogsFromLocal());
+  }
+
+  // subscribe(callBack: CallBackFunction): void {
+  //   console.log('execute subscribe');
+  //   // this.subject.subscribe()
+  //   // this.callBackExecute = callBack;
+  //   //
+  //   // // callBack(this.dialogs);
+  //   // if (this.events.listeners('Execute').length === 0) {
+  //   //   this.events.addListener('Execute', this.callBackExecute);
+  //   // }
+  //   // this.events.on('Execute', this.callBackExecute);
+  //   // this.register('Execute', callBack);
+  //   this.addSubscriber(callBack);
+  // }
+}

package/src/Domain/use_cases/SubscribeToDialogsUpdatesUseCaseWithMock.ts

@@ -0,0 +1,61 @@
+import { BaseUseCase } from './base/BaseUseCase';
+import { DialogEntity } from '../entity/DialogEntity';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import { CallBackFunction } from './base/IUseCase';
+
+export class SubscribeToDialogsUpdatesUseCaseWithMock extends BaseUseCase<
+  Array<DialogEntity>,
+  Array<DialogEntity>
+> {
+  private dialogRepository: DialogsRepository;
+
+  private callBackExecute: CallBackFunction<Array<DialogEntity>> | undefined;
+
+  private dialogs: Array<DialogEntity> = [];
+
+  // todo: delete synUseCase: BaseUseCase<boolean>, use only dialogRepository
+  constructor(dialogRepository: DialogsRepository) {
+    console.log('CONSTRUCTOR SubscribeToDialogsUpdatesUseCaseWithMock');
+    super();
+    this.callBackExecute = undefined;
+
+    this.dialogRepository = dialogRepository;
+  }
+
+  execute(
+    callBack: CallBackFunction<Array<DialogEntity>>,
+  ): Promise<Array<DialogEntity>> {
+    console.log('execute SubscribeToDialogsUpdatesUseCaseWithMock', callBack);
+    this.callBackExecute = callBack;
+    if (
+      this.callBackExecute !== undefined &&
+      typeof this.callBackExecute === 'function'
+    ) {
+      this.subscribe(this.callBackExecute);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    this.dialogRepository.subscribeLocalSync(async () => {
+      console.log(
+        '2.CALL EXECUTE CALLBACK in SubscribeToDialogsUpdatesUseCaseWithMock',
+      );
+      this.dialogs = await this.dialogRepository.getDialogsFromLocal();
+      this.informSubscribers(this.dialogs);
+    });
+
+    return Promise.resolve(this.dialogRepository.getDialogsFromLocal());
+  }
+
+  // subscribe(callBack: CallBackFunction): void {
+  //   console.log('execute subscribe');
+  //   // this.subject.subscribe()
+  //   // this.callBackExecute = callBack;
+  //   //
+  //   // // callBack(this.dialogs);
+  //   // if (this.events.listeners('Execute').length === 0) {
+  //   //   this.events.addListener('Execute', this.callBackExecute);
+  //   // }
+  //   // this.events.on('Execute', this.callBackExecute);
+  //   // this.register('Execute', callBack);
+  //   this.addSubscriber(callBack);
+  // }
+}