quickblox-react-ui-kit 0.4.2-beta.2 → 0.4.2-beta.4

package/src/Domain/use_cases/SubscribeToDialogsUpdatesUseCase.ts

@@ -0,0 +1,68 @@
+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> = [];
+
+  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,45 @@
+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> = [];
+
+  constructor(dialogRepository: DialogsRepository) {
+    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());
+  }
+}

package/src/Domain/use_cases/SyncDialogsUseCase.ts

@@ -0,0 +1,177 @@
+import { BaseUseCase } from './base/BaseUseCase';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import { CallBackFunction } from './base/IUseCase';
+import ConnectionRepository from '../../Data/repository/ConnectionRepository';
+import { stringifyError } from '../../utils/parse';
+import EventMessagesRepository from '../../Data/repository/EventMessagesRepository';
+import { NotificationTypes } from '../entity/NotificationTypes';
+
+export class SyncDialogsUseCase extends BaseUseCase<boolean, boolean> {
+  private connectionRepository: ConnectionRepository;
+
+  private dialogRepository: DialogsRepository;
+
+  private eventMessagesRepository: EventMessagesRepository;
+
+  private callBackExecute: CallBackFunction<boolean> | undefined;
+
+  private timer1Id: NodeJS.Timer | undefined;
+
+  private timer2Id: NodeJS.Timer | undefined;
+
+  private timerId: NodeJS.Timer | undefined;
+
+  constructor(
+    dialogRepository: DialogsRepository,
+    connectionRepository: ConnectionRepository,
+    eventMessagesRepository: EventMessagesRepository,
+  ) {
+    super();
+    console.log('CONSTRUCTOR SyncDialogsUseCaseWithMock');
+    this.callBackExecute = undefined;
+
+    this.dialogRepository = dialogRepository;
+    this.connectionRepository = connectionRepository;
+    this.eventMessagesRepository = eventMessagesRepository;
+  }
+
+  // todo: SyncDialogUseCaseWithMock
+  // создаем подписку на переменную в LocalDataSource
+  // SyncDialogUseCase слушает ее и при возникновении - передает дальше
+  // избавиться от таймера мы сможем когда введем EventRepository котор слушаеточередь сообщений
+  // или подписка на ремоте датасурсе
+  execute(callBack: CallBackFunction<boolean>): Promise<boolean> {
+    console.log('EXECUTE in SyncDialogUseCaseWithMock', callBack);
+    this.syncDialogs().catch();
+    this.callBackExecute = callBack;
+    if (
+      this.callBackExecute !== undefined &&
+      typeof this.callBackExecute === 'function'
+    ) {
+      console.log('call SUBSCRIBE in SyncDialogsUseCaseWithMock');
+      this.subscribe(this.callBackExecute);
+    }
+
+    return Promise.resolve(true);
+  }
+
+  private async syncDialogs(): Promise<void> {
+    console.log('call syncDialogs()  in SyncDialogsUseCaseWithMock');
+    if (this.connectionRepository.isChatConnected()) {
+      await this.syncDialogsActions();
+    }
+    this.connectionRepository.subscribe(() => {
+      console.log('HAVE CHANGED CONNECTION');
+      if (this.connectionRepository.isChatConnected()) {
+        console.log('CONNECTED');
+        this.syncDialogsActions().catch((e) => {
+          console.log(
+            'HAVE EXCEPTION IN syncDialogsActions',
+            stringifyError(e),
+          );
+        });
+      } else {
+        console.log('HAVE NO CONNECTION');
+      }
+    });
+    this.eventMessagesRepository.subscribeOnSystemMessaging(
+      NotificationTypes.NEW_DIALOG,
+      () => {
+        console.log('call subscribeOnSystemMessaging in  syncDialogs Mock');
+        if (this.connectionRepository.isChatConnected()) {
+          console.log('NotificationTypes.NEW_DIALOG: GET UPDATED DIALOG LIST');
+          this.syncDialogsActions().catch((e) => {
+            console.log(
+              'HAVE EXCEPTION IN syncDialogsActions',
+              stringifyError(e),
+            );
+          });
+        } else {
+          console.log('GET UPDATED DIALOG LOST: HAVE NO CONNECTION');
+        }
+      },
+    );
+    this.eventMessagesRepository.subscribeOnSystemMessaging(
+      NotificationTypes.DELETE_LEAVE_DIALOG,
+      () => {
+        console.log('call subscribeOnSystemMessaging in  syncDialogs Mock');
+        if (this.connectionRepository.isChatConnected()) {
+          console.log('NotificationTypes.NEW_DIALOG: GET UPDATED DIALOG LIST');
+          this.syncDialogsActions().catch((e) => {
+            console.log(
+              'HAVE EXCEPTION IN syncDialogsActions',
+              stringifyError(e),
+            );
+          });
+        } else {
+          console.log('GET UPDATED DIALOG LOST: HAVE NO CONNECTION');
+        }
+      },
+    );
+    this.eventMessagesRepository.subscribeOnSystemMessaging(
+      NotificationTypes.UPDATE_DIALOG,
+      () => {
+        console.log('call subscribeOnSystemMessaging in  syncDialogs Mock');
+        if (this.connectionRepository.isChatConnected()) {
+          console.log('NotificationTypes.NEW_DIALOG: GET UPDATED DIALOG LIST');
+          this.syncDialogsActions().catch((e) => {
+            console.log(
+              'HAVE EXCEPTION IN syncDialogsActions',
+              stringifyError(e),
+            );
+          });
+        } else {
+          console.log('GET UPDATED DIALOG LOST: HAVE NO CONNECTION');
+        }
+      },
+    );
+  }
+
+  private async syncDialogsActions(): Promise<void> {
+    const remoteDialogs = await this.dialogRepository.getDialogsFromRemote();
+
+    await this.setSyncInProgressAndClearLocal();
+    for (let i = 0; i < remoteDialogs.ResultData.length; i += 1) {
+      const dialog = remoteDialogs.ResultData[i];
+
+      // eslint-disable-next-line no-await-in-loop
+      await this.dialogRepository.saveDialogToLocal(dialog);
+    }
+    this.setSyncInCompleted();
+  }
+
+  // eslint-disable-next-line @typescript-eslint/require-await
+  private async setSyncInProgressAndClearLocal() {
+    this.setSyncInProgress();
+  }
+
+  private async deleteAllDialogsInLocal() {
+    const dialogs = await this.dialogRepository.getDialogsFromLocal();
+
+    for (let i = 0; i < dialogs.length; i += 1) {
+      const item = dialogs[i];
+
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        await this.dialogRepository.deleteDialogFromLocal(item.id);
+      } catch {
+        console.log('have deleting problem with ', JSON.stringify(item));
+      }
+    }
+  }
+
+  private setSyncInProgress(): void {
+    this.dialogRepository.setLocalSynced(false);
+  }
+
+  private setSyncInCompleted(): void {
+    this.dialogRepository.setLocalSynced(true);
+  }
+
+  override release() {
+    super.release();
+    if (this.timerId) {
+      clearTimeout(this.timerId);
+    }
+  }
+}

package/src/Domain/use_cases/UpdateCurrentDialogInDataSourceUseCase.ts

@@ -0,0 +1,31 @@
+import { DialogEntity } from '../entity/DialogEntity';
+import DialogsRepository from '../../Data/repository/DialogsRepository';
+import { IUseCase } from './base/IUseCase';
+import { GroupDialogEntity } from '../entity/GroupDialogEntity';
+
+export class UpdateCurrentDialogInDataSourceUseCase
+  implements IUseCase<void, DialogEntity>
+{
+  private dialogRepository: DialogsRepository;
+
+  private updateDialog: GroupDialogEntity;
+
+  constructor(
+    dialogRepository: DialogsRepository,
+    updateDialog: GroupDialogEntity,
+  ) {
+    console.log('CONSTRUCTOR UpdateCurrentDialogInDataSourceUseCase');
+    this.dialogRepository = dialogRepository;
+    this.updateDialog = updateDialog;
+  }
+
+  async execute(): Promise<DialogEntity> {
+    console.log('execute UpdateCurrentDialogInDataSourceUseCase');
+    const result: DialogEntity =
+      await this.dialogRepository.updateCurrentDialogInLocalDataSource(
+        this.updateDialog,
+      );
+
+    return Promise.resolve(result);
+  }
+}

package/src/Domain/use_cases/UpdateDialogUseCase.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 { RemoteMessageDTO } from '../../Data/dto/message/RemoteMessageDTO';
+import { NotificationTypes } from '../entity/NotificationTypes';
+import EventMessagesRepository from '../../Data/repository/EventMessagesRepository';
+import EventMessageType from '../entity/EventMessageType';
+
+export class UpdateDialogUseCase implements IUseCase<void, DialogEntity> {
+  private dialogRepository: DialogsRepository;
+
+  private eventMessagesRepository: EventMessagesRepository;
+
+  private updateDialog: GroupDialogEntity;
+
+  private textInformationMessage: string;
+
+  constructor(
+    eventMessagesRepository: EventMessagesRepository,
+    dialogRepository: DialogsRepository,
+    updateDialog: GroupDialogEntity,
+    textInformationMessage: string,
+  ) {
+    console.log('CONSTRUCTOR UpdateDialogUseCase');
+    this.dialogRepository = dialogRepository;
+    this.updateDialog = updateDialog;
+    this.eventMessagesRepository = eventMessagesRepository;
+    this.textInformationMessage = textInformationMessage;
+  }
+
+  async execute(): Promise<DialogEntity> {
+    console.log('execute UpdateDialogUseCase');
+    const result: DialogEntity =
+      await this.dialogRepository.updateDialogInRemote(this.updateDialog);
+
+    await this.dialogRepository.updateDialogInLocal(result);
+
+    const remoteMessageDTO: RemoteMessageDTO = new RemoteMessageDTO();
+
+    remoteMessageDTO.dialogId = result.id;
+    remoteMessageDTO.notification_type = NotificationTypes.UPDATE_DIALOG;
+    remoteMessageDTO.date_sent = Date.now();
+    remoteMessageDTO.message =
+      this.textInformationMessage && this.textInformationMessage.length > 0
+        ? this.textInformationMessage
+        : `User ${this.updateDialog.ownerId} has updated dialog ${this.updateDialog.name}`;
+
+    this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+      EventMessageType.RegularMessage,
+      remoteMessageDTO,
+      [],
+    );
+
+    remoteMessageDTO.dialogId = result.id;
+    remoteMessageDTO.notification_type = NotificationTypes.UPDATE_DIALOG;
+
+    const participants: Array<number> = [
+      ...(this.updateDialog.participantIds ?? []),
+      ...(this.updateDialog.newParticipantIds ?? []),
+    ];
+
+    this.eventMessagesRepository.dispatchEvent<RemoteMessageDTO>(
+      EventMessageType.SystemMessage,
+      remoteMessageDTO,
+      [...participants],
+    );
+
+    this.eventMessagesRepository.dispatchEvent<DialogEntity>(
+      EventMessageType.LocalMessage,
+      result,
+      [],
+    );
+
+    return Promise.resolve(result);
+  }
+}

package/src/Domain/use_cases/UploadFileUseCase.ts

@@ -0,0 +1,24 @@
+import { IUseCase } from './base/IUseCase';
+import { FileRepository } from '../../Data/repository/FileRepository';
+import { FileEntity } from '../entity/FileEntity';
+
+export class UploadFileUseCase implements IUseCase<void, FileEntity> {
+  private fileRepository: FileRepository;
+
+  private fileEntity: FileEntity;
+
+  constructor(fileRepository: FileRepository, fileEntity: FileEntity) {
+    console.log('CONSTRUCTOR UploadFileUseCase');
+    this.fileRepository = fileRepository;
+    this.fileEntity = fileEntity;
+  }
+
+  async execute(): Promise<FileEntity> {
+    console.log('execute UploadFileUseCase');
+    const result: FileEntity = await this.fileRepository.saveFileInRemote(
+      this.fileEntity,
+    );
+
+    return Promise.resolve(result);
+  }
+}

package/src/Domain/use_cases/UserTypingMessageUseCase.ts

@@ -0,0 +1,50 @@
+import { IUseCase } from './base/IUseCase';
+import MessagesRepository from '../../Data/repository/MessagesRepository';
+import { DialogEntity } from '../entity/DialogEntity';
+
+export class UserTypingMessageUseCase implements IUseCase<void, void> {
+  private messagesRepository: MessagesRepository;
+
+  private readonly senderId: number;
+
+  private readonly dialog: DialogEntity;
+
+  private typingTimeout = 3;
+
+  private _typingTimer: NodeJS.Timer | undefined;
+
+  private _typingTime = 0;
+
+  constructor(
+    messagesRepository: MessagesRepository,
+    dialog: DialogEntity,
+    senderId: number,
+  ) {
+    console.log('CONSTRUCTOR SendUserIsTypingMessageUseCase');
+    this.messagesRepository = messagesRepository;
+    this.dialog = dialog;
+    this.senderId = senderId;
+  }
+
+  async execute(): Promise<void> {
+    console.log('execute SendUserIsTypingMessageUseCase');
+    this._typingTime = Date.now();
+    if (!this._typingTimer) {
+      await this.messagesRepository.typingMessageStart(
+        this.dialog,
+        this.senderId,
+      );
+      // eslint-disable-next-line @typescript-eslint/no-misused-promises
+      this._typingTimer = setInterval(() => {
+        if ((Date.now() - this._typingTime) / 1000 >= this.typingTimeout) {
+          this.messagesRepository.typingMessageStop(this.dialog, this.senderId);
+          clearInterval(this._typingTimer);
+          this._typingTimer = undefined;
+          this._typingTime = 0;
+        }
+      }, 500);
+    }
+
+    return Promise.resolve();
+  }
+}

package/src/Domain/use_cases/ai/AIAnswerAssistUseCase.ts

@@ -0,0 +1,69 @@
+// eslint-disable-next-line import/extensions
+import { QBAIAnswerAssistant } from 'qb-ai-answer-assistant';
+import { IChatMessage } from '../../../Data/source/AISource';
+import { IUseCase } from '../base/IUseCase';
+
+export class AIAnswerAssistUseCase implements IUseCase<void, string> {
+  private textToSend: string;
+
+  private dialogMessages: IChatMessage[];
+
+  private servername: string;
+
+  private api: string;
+
+  private port: string;
+
+  private sessionToken: string;
+
+  private openAIModel: string;
+
+  constructor(
+    textToSend: string,
+    dialogMessages: IChatMessage[],
+    servername: string,
+    api: string,
+    port: string,
+    sessionToken: string,
+    openAIModel = 'gpt-3.5-turbo',
+  ) {
+    console.log('CONSTRUCTOR AIRephraseUseCase');
+    this.api = api;
+    this.openAIModel = openAIModel;
+    this.port = port;
+    this.sessionToken = sessionToken;
+    this.textToSend = textToSend;
+    this.servername = servername;
+    this.dialogMessages = dialogMessages;
+  }
+
+  async execute(): Promise<string> {
+    console.log('execute AIRephraseUseCase');
+    const settings =
+      QBAIAnswerAssistant.createDefaultAIAnswerAssistantSettings();
+
+    settings.apiKey = this.sessionToken;
+    // settings.organization = 'Quickblox';
+    settings.model = this.openAIModel;
+
+    return QBAIAnswerAssistant.createAnswer(
+      this.textToSend,
+      this.dialogMessages,
+      settings,
+    );
+
+    // const prompt = AIUtils.createAnswerAssistPrompt(this.textToSend);
+    //
+    // //
+    // return AISource.getData(
+    //   prompt,
+    //   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    //   this.dialogMessages,
+    //   this.servername,
+    //   this.api,
+    //   this.port,
+    //   this.sessionToken,
+    //   this.openAIModel,
+    // );
+  }
+}

package/src/Domain/use_cases/ai/AIAnswerAssistWithProxyUseCase.ts

@@ -0,0 +1,57 @@
+// eslint-disable-next-line import/extensions
+import { QBAIAnswerAssistant } from 'qb-ai-answer-assistant';
+import { IChatMessage } from '../../../Data/source/AISource';
+import { IUseCase } from '../base/IUseCase';
+
+export class AIAnswerAssistWithProxyUseCase implements IUseCase<void, string> {
+  private textToSend: string;
+
+  private dialogMessages: IChatMessage[];
+
+  private servername: string;
+
+  private api: string;
+
+  private port: string;
+
+  private sessionToken: string;
+
+  private openAIModel: string;
+
+  constructor(
+    textToSend: string,
+    dialogMessages: IChatMessage[],
+    servername: string,
+    api: string,
+    port: string,
+    sessionToken: string,
+    openAIModel = 'gpt-3.5-turbo',
+  ) {
+    console.log('CONSTRUCTOR AIRephraseUseCase');
+    this.api = api;
+    this.openAIModel = openAIModel;
+    this.port = port;
+    this.sessionToken = sessionToken;
+    this.textToSend = textToSend;
+    this.servername = servername;
+    this.dialogMessages = dialogMessages;
+  }
+
+  async execute(): Promise<string> {
+    console.log('execute AIRephraseUseCase');
+
+    const settings =
+      QBAIAnswerAssistant.createDefaultAIAnswerAssistantSettings();
+
+    settings.token = this.sessionToken;
+    // settings.organization = 'Quickblox';
+    settings.model = this.openAIModel;
+    settings.serverPath = `${this.servername}:${this.port}/${this.api}`;
+
+    return QBAIAnswerAssistant.createAnswer(
+      this.textToSend,
+      this.dialogMessages,
+      settings,
+    );
+  }
+}

package/src/Domain/use_cases/ai/AIAnswerAssistWithSDKUseCase.ts

@@ -0,0 +1,50 @@
+// eslint-disable-next-line import/extensions
+import { AIAnswerResponse, AIChatMessage, AIRole } from 'quickblox';
+import { IChatMessage } from '../../../Data/source/AISource';
+import { IUseCase } from '../base/IUseCase';
+import { IRemoteDataSource } from '../../../Data/source/remote/IRemoteDataSource';
+
+// interface AIChatMessageEx extends AIChatMessage {
+//   content: string;
+// } // artik 19.05.2024
+export class AIAnswerAssistWithSDKUseCase implements IUseCase<void, string> {
+  private textToSend: string;
+
+  private dialogMessages: IChatMessage[];
+
+  private dataSource: IRemoteDataSource;
+
+  private smartChatAssistantId: string;
+
+  constructor(
+    textToSend: string,
+    dialogMessages: IChatMessage[],
+    dataSource: IRemoteDataSource,
+    smartChatAssistantId: string,
+  ) {
+    console.log('CONSTRUCTOR AIAnswerAssistWithSDKUseCase');
+    this.textToSend = textToSend;
+    this.dialogMessages = dialogMessages;
+    this.dataSource = dataSource;
+    this.smartChatAssistantId = smartChatAssistantId;
+  }
+
+  async execute(): Promise<string> {
+    console.log('execute AIAnswerAssistWithSDKUseCase');
+    const history: AIChatMessage[] = this.dialogMessages.map(
+      (msg: IChatMessage) => {
+        return {
+          role: msg.role as AIRole,
+          message: msg.content,
+        } as AIChatMessage;
+      },
+    );
+    const response: AIAnswerResponse = await this.dataSource.createAnswer(
+      this.textToSend,
+      history,
+      this.smartChatAssistantId,
+    );
+
+    return response.answer;
+  }
+}