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

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

@@ -0,0 +1,89 @@
+// eslint-disable-next-line import/extensions
+import { QBAIRephrase } from 'qb-ai-rephrase';
+import { IChatMessage } from '../../../Data/source/AISource';
+import { IUseCase } from '../base/IUseCase';
+import { Tone } from '../../../Presentation/Views/Dialog/AIWidgets/Tone';
+
+export class AIRephraseUseCase implements IUseCase<void, string> {
+  private textToSend: string;
+
+  private tone: Tone;
+
+  private dialogMessages: IChatMessage[];
+
+  private servername: string;
+
+  private api: string;
+
+  private port: string;
+
+  private sessionToken: string;
+
+  private openAIModel: string;
+
+  constructor(
+    textToSend: string,
+    tone: Tone,
+    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.tone = tone;
+    this.servername = servername;
+    this.dialogMessages = dialogMessages;
+  }
+
+  async execute(): Promise<string> {
+    console.log('execute AIRephraseUseCase');
+
+    const settings = QBAIRephrase.createDefaultAIRephraseSettings();
+
+    settings.apiKey = this.sessionToken;
+    // settings.organization = 'Quickblox';
+    settings.model = this.openAIModel;
+    settings.tone = this.tone;
+
+    return QBAIRephrase.rephrase(
+      this.textToSend,
+      this.dialogMessages,
+      settings,
+    );
+
+    /*
+    const settings: AITranslateSettings =
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      QBAITranslate.createDefaultAITranslateSettings();
+
+    settings.apiKey = this.sessionToken;
+    settings.language = this.language;
+
+    return QBAITranslate.translate(
+      this.textToSend,
+      this.dialogMessages,
+      settings,
+    );
+     */
+
+    // const prompt = AIUtils.createRephrasePrompt(this.textToSend, this.tone);
+    //
+    // 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/AIRephraseWithProxyUseCase.ts

@@ -0,0 +1,62 @@
+// eslint-disable-next-line import/extensions
+import { QBAIRephrase } from 'qb-ai-rephrase';
+import { IChatMessage } from '../../../Data/source/AISource';
+import { IUseCase } from '../base/IUseCase';
+import { Tone } from '../../../Presentation/Views/Dialog/AIWidgets/Tone';
+
+export class AIRephraseWithProxyUseCase implements IUseCase<void, string> {
+  private textToSend: string;
+
+  private tone: Tone;
+
+  private dialogMessages: IChatMessage[];
+
+  private servername: string;
+
+  private api: string;
+
+  private port: string;
+
+  private sessionToken: string;
+
+  private openAIModel: string;
+
+  constructor(
+    textToSend: string,
+    tone: Tone,
+    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.tone = tone;
+    this.servername = servername;
+    this.dialogMessages = dialogMessages;
+  }
+
+  async execute(): Promise<string> {
+    console.log('execute AIRephraseUseCase');
+
+    const settings = QBAIRephrase.createDefaultAIRephraseSettings();
+
+    settings.token = this.sessionToken;
+    // settings.organization = 'Quickblox';
+    settings.model = this.openAIModel;
+    settings.tone = this.tone;
+    settings.serverPath = `${this.servername}:${this.port}/${this.api}`;
+
+    return QBAIRephrase.rephrase(
+      this.textToSend,
+      this.dialogMessages,
+      settings,
+    );
+  }
+}

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

@@ -0,0 +1,76 @@
+import { AITranslateSettings, QBAITranslate } from 'qb-ai-translate';
+import { IChatMessage } from '../../../Data/source/AISource';
+import { IUseCase } from '../base/IUseCase';
+
+export class AITranslateUseCase implements IUseCase<void, string> {
+  private textToSend: string;
+
+  private language: string;
+
+  private dialogMessages: IChatMessage[];
+
+  private servername: string;
+
+  private api: string;
+
+  private port: string;
+
+  private sessionToken: string;
+
+  private openAIModel: string;
+
+  constructor(
+    textToSend: string,
+    language: 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.language = language;
+    this.servername = servername;
+    this.dialogMessages = dialogMessages;
+  }
+
+  async execute(): Promise<string> {
+    console.log('execute AIRephraseUseCase');
+    const settings: AITranslateSettings =
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      QBAITranslate.createDefaultAITranslateSettings();
+
+    settings.apiKey = this.sessionToken;
+    // settings.organization = 'Quickblox';
+    settings.model = this.openAIModel;
+    settings.language = this.language;
+
+    return QBAITranslate.translate(
+      this.textToSend,
+      this.dialogMessages,
+      settings,
+    );
+
+    // const prompt = AIUtils.createTranslatePrompt(
+    //   this.textToSend,
+    //   this.language,
+    // );
+    //
+    // 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/AITranslateWithProxyUseCase.ts

@@ -0,0 +1,63 @@
+// eslint-disable-next-line import/extensions
+import { AITranslateSettings, QBAITranslate } from 'qb-ai-translate';
+import { IChatMessage } from '../../../Data/source/AISource';
+import { IUseCase } from '../base/IUseCase';
+
+export class AITranslateWithProxyUseCase implements IUseCase<void, string> {
+  private textToSend: string;
+
+  private language: string;
+
+  private dialogMessages: IChatMessage[];
+
+  private servername: string;
+
+  private api: string;
+
+  private port: string;
+
+  private sessionToken: string;
+
+  private openAIModel: string;
+
+  constructor(
+    textToSend: string,
+    language: 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.language = language;
+    this.servername = servername;
+    this.dialogMessages = dialogMessages;
+  }
+
+  async execute(): Promise<string> {
+    console.log('execute AIRephraseUseCase');
+
+    const settings: AITranslateSettings =
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+      QBAITranslate.createDefaultAITranslateSettings();
+
+    settings.token = this.sessionToken;
+    // settings.organization = 'Quickblox';
+    settings.model = this.openAIModel;
+    settings.language = this.language;
+    settings.serverPath = `${this.servername}:${this.port}/${this.api}`;
+
+    return QBAITranslate.translate(
+      this.textToSend,
+      this.dialogMessages,
+      settings,
+    );
+  }
+}

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

@@ -0,0 +1,107 @@
+// eslint-disable-next-line import/extensions
+import { AIAnswerResponse } from 'quickblox/quickblox';
+import { IUseCase } from '../base/IUseCase';
+import { IRemoteDataSource } from '../../../Data/source/remote/IRemoteDataSource';
+
+export class AITranslateWithSDKUseCase implements IUseCase<void, string> {
+  private languageCodes: { [key: string]: string } = {
+    English: 'en',
+    Spanish: 'es',
+    'Chinese simplified': 'zh-Hans',
+    'Chinese traditional': 'zh-Hant',
+    French: 'fr',
+    German: 'de',
+    Japanese: 'ja',
+    Korean: 'ko',
+    Italian: 'it',
+    Russian: 'ru',
+    Portuguese: 'pt',
+    Arabic: 'ar',
+    Hindi: 'hi',
+    Turkish: 'tr',
+    Dutch: 'nl',
+    Polish: 'pl',
+    Ukrainian: 'uk',
+    Albanian: 'sq',
+    Armenian: 'hy',
+    Azerbaijani: 'az',
+    Basque: 'eu',
+    Belarusian: 'be',
+    Bengali: 'bn',
+    Bosnian: 'bs',
+    Bulgarian: 'bg',
+    Catalan: 'ca',
+    Croatian: 'hr',
+    Czech: 'cs',
+    Danish: 'da',
+    Estonian: 'et',
+    Finnish: 'fi',
+    Galician: 'gl',
+    Georgian: 'ka',
+    Greek: 'el',
+    Gujarati: 'gu',
+    Hungarian: 'hu',
+    Indonesian: 'id',
+    Irish: 'ga',
+    Kannada: 'kn',
+    Kazakh: 'kk',
+    Latvian: 'lv',
+    Lithuanian: 'lt',
+    Macedonian: 'mk',
+    Malay: 'ms',
+    Maltese: 'mt',
+    Mongolian: 'mn',
+    Nepali: 'ne',
+    Norwegian: 'no',
+    Pashto: 'ps',
+    Persian: 'fa',
+    Punjabi: 'pa',
+    Romanian: 'ro',
+    Sanskrit: 'sa',
+    Serbian: 'sr',
+    Sindhi: 'sd',
+    Sinhala: 'si',
+    Slovak: 'sk',
+    Slovenian: 'sl',
+    Uzbek: 'uz',
+    Vietnamese: 'vi',
+    Welsh: 'cy',
+  };
+
+  private textToSend: string;
+
+  private language: string;
+
+  private dataSource: IRemoteDataSource;
+
+  private smartChatAssistantId: string;
+
+  constructor(
+    textToSend: string,
+    language: string,
+    dataSource: IRemoteDataSource,
+    smartChatAssistantId: string,
+  ) {
+    console.log('CONSTRUCTOR AITranslateWithSDKUseCase');
+    this.dataSource = dataSource;
+    this.textToSend = textToSend;
+    this.language = language;
+    this.smartChatAssistantId = smartChatAssistantId;
+  }
+
+  getLanguageCode(language: string): string {
+    return this.languageCodes[language] || 'en';
+  }
+
+  async execute(): Promise<string> {
+    console.log('execute AITranslateWithSDKUseCase');
+
+    const response: AIAnswerResponse = await this.dataSource.translate(
+      this.textToSend,
+      this.getLanguageCode(this.language),
+      this.smartChatAssistantId,
+    );
+
+    return response.answer;
+  }
+}

package/src/Domain/use_cases/base/BaseUseCase.ts

@@ -0,0 +1,77 @@
+import { CallBackFunction, IUseCase } from './IUseCase';
+import { SubscriptionPerformer } from './Subscribable/SubscriptionPerformer';
+
+export abstract class BaseUseCase<TArg, TResult>
+  extends SubscriptionPerformer<TArg>
+  implements IUseCase<TArg, TResult>
+{
+  abstract execute(args: CallBackFunction<TArg>): Promise<TResult>;
+
+  // abstract subscribe(args: CallBackFunction): void;
+
+  // public release(): void {
+  //   this.onEventByTypeSubscribers.slice();
+  // }
+
+  // protected informSubscribers(arg?: TArg): void {
+  //   this.onEventByTypeSubscribers.forEach((subscriber) => {
+  //     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+  //     subscriber(arg);
+  //   });
+  // }
+  //
+  // protected addSubscriber(subscriber: CallBackFunction): void {
+  //   this.onEventByTypeSubscribers.push(subscriber);
+  // }
+
+  // protected abstract dispatch(eventName: string): void;
+
+  // public subject: BehaviorSubject<TArg> = new BehaviorSubject(null as TArg);
+  //
+  //
+  // private readonly onEventByTypeSubscribers: Array<CallBackFunction>;
+
+  // protected constructor() {
+  //   this.onEventByTypeSubscribers = [];
+  // }
+
+  // protected dispatch(arg?: TArg): void {
+  //   const subscriber = this.onEventByTypeSubscribers[event];
+  //
+  //   if (subscriber === undefined) {
+  //     return;
+  //   }
+  //
+  //   Object.keys(subscriber).forEach((key) => {
+  //     console.log(`dispatch called for key:${key} `);
+  //     // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+  //     subscriber[key](arg);
+  //   });
+  // }
+  //
+  // public register(event: string, callback: CallBackFunction): Registry {
+  //   const id = this.getNextId();
+  //
+  //   if (!this.onEventByTypeSubscribers[event]) this.onEventByTypeSubscribers[event] = {};
+  //
+  //   this.onEventByTypeSubscribers[event][id] = callback;
+  //
+  //   return {
+  //     unregister: () => {
+  //       delete this.onEventByTypeSubscribers[event][id];
+  //       if (Object.keys(this.onEventByTypeSubscribers[event]).length === 0)
+  //         delete this.onEventByTypeSubscribers[event];
+  //     },
+  //   };
+  // }
+  //
+  // // eslint-disable-next-line class-methods-use-this
+  // private getNextId(): number {
+  //   // eslint-disable-next-line no-return-assign
+  //   //  return (BaseUseCase.nextId += 1);
+  //   return BaseUseCase.nextId;
+  // }
+
+  //
+  //
+}

package/src/Domain/use_cases/base/IUseCase.ts

@@ -0,0 +1,5 @@
+export type CallBackFunction<TArg> = (arg: TArg) => void;
+export type CallBackFunctionWithPromise<TArg> = (arg: TArg) => Promise<void>;
+export interface IUseCase<TArg, TResult> {
+  execute(callBack: CallBackFunction<TArg> | undefined): Promise<TResult>;
+}

package/src/Domain/use_cases/base/Subscribable/ISubscribable.ts

@@ -0,0 +1,6 @@
+import { CallBackFunction } from '../IUseCase';
+
+export interface ISubscribable<TArg> {
+  subscribe(args: CallBackFunction<TArg>, event: string): void;
+  release(): void;
+}

package/src/Domain/use_cases/base/Subscribable/SubscriptionPerformer.ts

@@ -0,0 +1,144 @@
+import { CallBackFunction } from '../IUseCase';
+import { ISubscribable } from './ISubscribable';
+import EventMessageType from '../../../entity/EventMessageType';
+
+export interface Registry {
+  unregister: () => void;
+}
+
+export interface Callable<TArg> {
+  [key: string]: CallBackFunction<TArg>;
+}
+
+export interface EventSubscriber<TArg> {
+  [key: string]: Callable<TArg>;
+}
+
+// SubscriptionPerformer<TArg>
+/*
+release
+subscribe
+informSubscribers
+ */
+type DictionaryType<T> = Dictionary<CallBackFunction<T>>;
+export class SubscriptionPerformer<TArg> implements ISubscribable<TArg> {
+  protected readonly onEventByTypeSubscribers: Dictionary<
+    DictionaryType<TArg>
+  > = {};
+
+  public static readonly DEFAULT_SUBSCRIPTION_NAME = 'DEFAULT';
+
+  protected readonly subscribers: DictionaryType<TArg> = {};
+
+  protected EVENT_NAME: string =
+    SubscriptionPerformer.DEFAULT_SUBSCRIPTION_NAME;
+
+  protected EVENT_TYPE: string = EventMessageType.LocalMessage;
+
+  // eslint-disable-next-line class-methods-use-this
+  public release(): void {
+    console.log('SubscriptionPerformer release actions.');
+    // Object.entries(this.onEventByTypeSubscribers).map((x) => {
+    //   const eventName = x[0];
+    //
+    //   this.onEventByTypeSubscribers[eventName][this.EVENT_NAME] = () => {
+    //     console.log('ERROR release event in SubscriptionPerformer');
+    //   };
+    //
+    //   return this.onEventByTypeSubscribers[eventName][this.EVENT_NAME];
+    // });
+  }
+
+  constructor() {
+    console.log('CONSTRUCTOR SubscriptionPerformer');
+    // this.onEventByTypeSubscribers[EventMessageType.LocalMessage] = [];
+    this.onEventByTypeSubscribers[EventMessageType.LocalMessage] =
+      this.subscribers;
+  }
+
+  subscribe(
+    callBack: CallBackFunction<TArg>,
+    typeEvent: string = this.EVENT_TYPE,
+    nameEvent: string = this.EVENT_NAME,
+  ): void {
+    if (this.onEventByTypeSubscribers[typeEvent] === undefined) {
+      this.onEventByTypeSubscribers[typeEvent] = {};
+    }
+    this.onEventByTypeSubscribers[typeEvent][nameEvent] = callBack;
+
+    // if (!this.onEventByTypeSubscribers[typeEvent]) {
+    //   this.onEventByTypeSubscribers[typeEvent] = [];
+    // }
+    // const alreadyHave = this.onEventByTypeSubscribers[typeEvent].includes(callBack);
+    //
+    // if (!alreadyHave) {
+    //   this.onEventByTypeSubscribers[typeEvent].push(callBack);
+    // } else {
+    //   console.log('ALREADY HAVE CALLBACK');
+    // }
+  }
+
+  public informSubscribers(
+    arg?: TArg,
+    eventType: string = this.EVENT_TYPE,
+    event: string = SubscriptionPerformer.DEFAULT_SUBSCRIPTION_NAME,
+  ): void {
+    const haveSubscriptionsForType = this.onEventByTypeSubscribers[eventType];
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const haveSubscriptionName =
+      event !== SubscriptionPerformer.DEFAULT_SUBSCRIPTION_NAME;
+    const haveSubscriber =
+      this.onEventByTypeSubscribers[eventType][event] !== undefined;
+    const haveValidType =
+      typeof this.onEventByTypeSubscribers[eventType][event] === 'function';
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const haveManySubscribers =
+      Object.entries(this.onEventByTypeSubscribers[eventType]).length > 1;
+
+    if (haveSubscriptionsForType) {
+      if (haveSubscriptionName && haveSubscriber && haveValidType) {
+        // if (!haveSubscriptionName && haveSubscriber && haveValidType)
+        // if (!haveManySubscribers && haveSubscriber && haveValidType)
+
+        if (arg) {
+          this.onEventByTypeSubscribers[eventType][event](arg); // new, edit dialog
+        }
+      } else {
+        // local events and leave dialog
+        Object.entries(this.onEventByTypeSubscribers[eventType]).forEach(
+          (value) => {
+            if (arg !== undefined) {
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              const currentEventName = value[0];
+
+              value[1](arg);
+            }
+          },
+        );
+      }
+    }
+
+    // if (this.onEventByTypeSubscribers[eventType]) {
+    //   if (
+    //     event !== SubscriptionPerformer.DEFAULT_SUBSCRIPTION_NAME &&
+    //     this.onEventByTypeSubscribers[eventType][event] &&
+    //     typeof this.onEventByTypeSubscribers[eventType][event] === 'function'
+    //   ) {
+    //     if (arg) {
+    //       this.onEventByTypeSubscribers[eventType][event](arg);
+    //     }
+    //   } else {
+    //     Object.entries(this.onEventByTypeSubscribers[eventType]).forEach(
+    //       (value) => {
+    //         if (arg) {
+    //           const currentEventName = value[0];
+    //
+    //           console.log('call for event: ', currentEventName);
+    //           value[1](arg);
+    //         }
+    //       },
+    //     );
+    //   }
+    // }
+  }
+}

package/src/Presentation/Views/Dialog/AIComponents/AIAssist/AIAssist.scss

@@ -0,0 +1,39 @@
+.ai-assist-answer {
+    padding: 0px 0px 15px 0px;
+    display: flex;
+    flex-direction: row;
+    gap: 10px;
+    align-items: center;
+    justify-content: center;
+    align-self: stretch;
+    flex-shrink: 0;
+
+  &__icon {
+    border-radius: 4px;
+    display: flex;
+    flex-direction: row;
+    gap: 0px;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+    width: 24px;
+    height: 24px;
+    position: relative;
+    cursor: pointer;
+
+    &__media-robot {
+      align-self: stretch;
+      flex: 1;
+      height: auto;
+      position: relative;
+      overflow: visible;
+      fill: var(--main-elements, #3978FC);
+
+      &--disable {
+        fill: var(--disabled-elements);
+        cursor: default;
+      }
+    }
+  }
+}
+