quickblox-react-ui-kit 0.2.3 → 0.2.5

package/dist/utils/utils.d.ts

@@ -1,3 +1,12 @@
+import { MessageEntity } from '../Domain/entity/MessageEntity';
+import { IChatMessage } from '../Data/source/AISource';
+import { Tone } from '../Presentation/components/UI/Dialogs/MessagesView/AIWidgets/Tone';
 export declare const completeSentence: (text?: string) => string;
 export declare const tokenCounter: (text?: string) => number;
 export declare const loopToLimitTokens: <T>(limit: number, data: T[], getValue?: (item: T) => string, tokens?: number) => T[];
+export declare class AIUtils {
+    static createTranslatePrompt(textToSend: string, language?: string): string;
+    static createAnswerAssistPrompt(textToSend: string): string;
+    static createRephrasePrompt(textToSend: string, tone?: Tone): string;
+    static messageEntitiesToIChatMessageCollection(messageEntities: MessageEntity[], currentUserId: number | undefined, MAX_TOKENS?: number): IChatMessage[];
+}

package/global.d.ts

@@ -1,3 +1,9 @@
+interface Tone {
+  name: string;
+  description: string;
+  iconEmoji: string;
+}
+
 type Dictionary<T> = Record<string, T>;
 
 type DictionaryByKey<T, V> = {
@@ -21,20 +27,22 @@ type ProxyConfig = {
   api: string;
   servername: string;
   port: string;
-  sessionToken: string;
 };
 interface WidgetConfig {
   apiKey: string;
   useDefault: boolean;
+  maxTokens: number;
   proxyConfig: ProxyConfig;
 }
 
-interface AITranslateWidgetConfig extends WidgetConfig{
-  defaultLanguage: string; languages: string[];
+interface AITranslateWidgetConfig extends WidgetConfig {
+  defaultLanguage: string;
+  languages: string[];
 }
 
 interface AIRephraseWidgetConfig extends WidgetConfig {
-  defaultTone: string
+  defaultTone: string;
+  Tones: Tone[];
 }
 
 interface QBConfig {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quickblox-react-ui-kit",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "main": "dist/index-ui.js",
   "license": "MIT",
   "dependencies": {
@@ -8,6 +8,10 @@
     "@types/react": "^18.0.26",
     "@types/react-dom": "^18.0.9",
     "classnames": "^2.3.2",
+    "qb-ai-answer-assistant": "^0.1.0",
+    "qb-ai-core": "^0.1.0",
+    "qb-ai-rephrase": "^0.1.0",
+    "qb-ai-translate": "^0.1.0",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-router-dom": "^6.11.1",

package/src/App.tsx

@@ -28,7 +28,7 @@ function App() {
   const { connectionRepository } = useQBConnection();
 
   const initLoginData: LoginData = {
-    login: 'artimed', // vit1
+    login: 'anruaav2', // vit1
     password: 'quickblox',
   };
 

package/src/CommonTypes/FunctionResult.ts

@@ -1,3 +1,5 @@
+import {Tone} from "../Presentation/components/UI/Dialogs/MessagesView/AIWidgets/Tone";
+
 export type FunctionResult<T> = {
   result: T | T[] | boolean;
   error: any;
@@ -7,10 +9,12 @@ export type ProxyConfig = {
   api: string;
   servername: string;
   port: string;
-  sessionToken: string;
 };
 export interface WidgetConfig {
+  organizationName: string;
+  openAIModel: string;
   apiKey: string;
+  maxTokens: number;
   useDefault: boolean;
   proxyConfig: ProxyConfig;
 }
@@ -22,6 +26,7 @@ export interface AITranslateWidgetConfig extends WidgetConfig {
 
 export interface AIRephraseWidgetConfig extends WidgetConfig {
   defaultTone: string;
+  Tones: Tone[];
 }
 
 export interface QBConfig {

package/src/Data/DefaultConfigurations.ts

@@ -9,6 +9,7 @@ const supportedLanguagesForIATranslate: string[] = [
   'German',
 ];
 
+// ["en-US", "zh-CN", "ja-JP"]
 const languageBCP47: Record<string, string> = {
   'ar-SA': 'Arabic',
   'bn-BD': 'Bangla',
@@ -80,15 +81,17 @@ export class DefaultConfigurations {
       api: 'v1/chat/completions',
       servername: 'https://api.openai.com',
       port: '',
-      sessionToken: '',
     };
   }
 
-  static getDefaultLanguageForAITranslate(): string {
+  static getDefaultLanguageForAITranslate(
+    configAITranslate: AITranslateWidgetConfig,
+  ): string {
     let languageForAITranslate = 'English';
-    const { defaultLanguage } =
+    const defaultLanguage: string =
+      configAITranslate.defaultLanguage ||
       DefaultConfigurations.getDefaultQBConfig().configAIApi
-        .AITranslateWidgetConfig;
+        .AITranslateWidgetConfig.defaultLanguage;
 
     if (
       defaultLanguage.length > 0 &&
@@ -106,11 +109,14 @@ export class DefaultConfigurations {
     return languageForAITranslate;
   }
 
-  static getAdditionalLanguagesForAITranslate(): string[] {
+  static getAdditionalLanguagesForAITranslate(
+    configAITranslate: AITranslateWidgetConfig,
+  ): string[] {
     const additionalLanguages: string[] = [];
-    const { languages } =
+    const languages: string[] =
+      configAITranslate.languages ||
       DefaultConfigurations.getDefaultQBConfig().configAIApi
-        .AITranslateWidgetConfig;
+        .AITranslateWidgetConfig.languages;
 
     languages.forEach((item) => {
       if (supportedLanguagesForIATranslate.includes(item)) {
@@ -135,43 +141,109 @@ export class DefaultConfigurations {
       },
       configAIApi: {
         AIAnswerAssistWidgetConfig: {
+          organizationName: 'Quickblox',
+          openAIModel: 'gpt-3.5-turbo',
           apiKey: '',
+          maxTokens: 3584,
           useDefault: true,
           proxyConfig: {
             api: 'v1/chat/completions',
             servername: 'https://api.openai.com/',
             port: '',
-            sessionToken: '',
           },
         },
         AITranslateWidgetConfig: {
+          organizationName: 'Quickblox',
+          openAIModel: 'gpt-3.5-turbo',
           apiKey: '',
+          maxTokens: 3584,
           useDefault: true,
           defaultLanguage: 'English',
-          languages: [
-            'English',
-            'Spanish',
-            'French',
-            'Portuguese',
-            'German',
-            'Ukrainian',
-          ],
+          languages: ['English', 'French', 'Portuguese', 'German', 'Ukrainian'],
           proxyConfig: {
             api: 'v1/chat/completions',
-            servername: 'https://api.openai.com/',
+            servername: '',
             port: '',
-            sessionToken: '',
           },
+          // proxyConfig: {
+          //   api: 'v1/chat/completions',
+          //   servername: 'http://localhost',
+          //   port: '3012',
+          // },
         },
         AIRephraseWidgetConfig: {
+          organizationName: 'Quickblox',
+          openAIModel: 'gpt-3.5-turbo',
           apiKey: '',
+          maxTokens: 3584,
           useDefault: true,
           defaultTone: 'Professional',
+          Tones: [
+            {
+              name: 'Professional Tone',
+              description:
+                'This would edit messages to sound more formal, using technical vocabulary, clear sentence structures, and maintaining a respectful tone. It would avoid colloquial language and ensure appropriate salutations and sign-offs',
+              iconEmoji: '👔',
+            },
+            {
+              name: 'Friendly Tone',
+              description:
+                'This would adjust messages to reflect a casual, friendly tone. It would incorporate casual language, use emoticons, exclamation points, and other informalities to make the message seem more friendly and approachable.',
+              iconEmoji: '🤝',
+            },
+            {
+              name: 'Encouraging Tone',
+              description:
+                'This tone would be useful for motivation and encouragement. It would include positive words, affirmations, and express support and belief in the recipient.',
+              iconEmoji: '💪',
+            },
+            {
+              name: 'Empathetic Tone',
+              description:
+                'This tone would be utilized to display understanding and empathy. It would involve softer language, acknowledging feelings, and demonstrating compassion and support.',
+              iconEmoji: '🤲',
+            },
+            {
+              name: 'Neutral Tone',
+              description:
+                'For times when you want to maintain an even, unbiased, and objective tone. It would avoid extreme language and emotive words, opting for clear, straightforward communication.',
+              iconEmoji: '😐',
+            },
+            {
+              name: 'Assertive Tone',
+              description:
+                'This tone is beneficial for making clear points, standing ground, or in negotiations. It uses direct language, is confident, and does not mince words.',
+              iconEmoji: '🔨',
+            },
+            {
+              name: 'Instructive Tone',
+              description:
+                'This tone would be useful for tutorials, guides, or other teaching and training materials. It is clear, concise, and walks the reader through steps or processes in a logical manner.',
+              iconEmoji: '📖',
+            },
+            {
+              name: 'Persuasive Tone',
+              description:
+                'This tone can be used when trying to convince someone or argue a point. It uses persuasive language, powerful words, and logical reasoning.',
+              iconEmoji: '☝️',
+            },
+            {
+              name: 'Sarcastic/Ironic Tone',
+              description:
+                'This tone can make the communication more humorous or show an ironic stance. It is harder to implement as it requires the AI to understand nuanced language and may not always be taken as intended by the reader.',
+              iconEmoji: '😏',
+            },
+            {
+              name: 'Poetic Tone',
+              description:
+                'This would add an artistic touch to messages, using figurative language, rhymes, and rhythm to create a more expressive text.',
+              iconEmoji: '🎭',
+            },
+          ],
           proxyConfig: {
             api: 'v1/chat/completions',
             servername: 'https://api.openai.com/',
             port: '',
-            sessionToken: '',
           },
         },
       },
@@ -190,6 +262,70 @@ export class DefaultConfigurations {
           enable: true,
         },
       },
+      // credentials: {
+      //   appId: -1,
+      //   accountKey: '',
+      //   authKey: '',
+      //   authSecret: '',
+      //   sessionToken: '',
+      // },
+      // configAIApi: {
+      //   AIAnswerAssistWidgetConfig: {
+      //     apiKey: '',
+      //     useDefault: true,
+      //     proxyConfig: {
+      //       api: 'v1/chat/completions',
+      //       servername: 'https://api.openai.com/',
+      //       port: '',
+      //       sessionToken: '',
+      //     },
+      //   },
+      //   AITranslateWidgetConfig: {
+      //     apiKey: '',
+      //     useDefault: true,
+      //     defaultLanguage: 'English',
+      //     languages: [
+      //       'English',
+      //       'Spanish',
+      //       'French',
+      //       'Portuguese',
+      //       'German',
+      //       'Ukrainian',
+      //     ],
+      //     proxyConfig: {
+      //       api: 'v1/chat/completions',
+      //       servername: 'https://api.openai.com/',
+      //       port: '',
+      //       sessionToken: '',
+      //     },
+      //   },
+      //   AIRephraseWidgetConfig: {
+      //     apiKey: '',
+      //     useDefault: true,
+      //     defaultTone: 'Professional',
+      //     proxyConfig: {
+      //       api: 'v1/chat/completions',
+      //       servername: 'https://api.openai.com/',
+      //       port: '',
+      //       sessionToken: '',
+      //     },
+      //   },
+      // },
+      // appConfig: {
+      //   maxFileSize: 10 * 1024 * 1024,
+      //   sessionTimeOut: 122,
+      //   chatProtocol: {
+      //     active: 2,
+      //   },
+      //   debug: true,
+      //   endpoints: {
+      //     api: 'api.quickblox.com',
+      //     chat: 'chat.quickblox.com',
+      //   },
+      //   streamManagement: {
+      //     enable: true,
+      //   },
+      // },
     };
   }
 

package/src/Data/repository/DialogsRepository.ts

@@ -52,6 +52,10 @@ export default class DialogsRepository implements IDialogsRepository {
     this.dialogLocalDTOMapper = new DialogLocalDTOMapper();
   }
 
+  release() {
+    this.localDataStorage.clearAll();
+  }
+
   subscribeLocalSync(subscriber: FunctionTypeVoidToVoid): void {
     this.localDataStorage.subscribe(subscriber);
   }

package/src/Data/repository/EventMessagesRepository.ts

@@ -47,6 +47,8 @@ export default class EventMessagesRepository
       new SubscriptionPerformer<MessageEntity>();
     this.subscriptionOnSystemMessages[NotificationTypes.DELETE_LEAVE_DIALOG] =
       new SubscriptionPerformer<MessageEntity>();
+    this.subscriptionOnSystemMessages[NotificationTypes.REMOVE_USER] =
+      new SubscriptionPerformer<MessageEntity>();
     this.subscriptionOnSystemMessages[NotificationTypes.NEW_DIALOG] =
       new SubscriptionPerformer<MessageEntity>();
     this.remoteDs.subscribeOnSystemMessaging(
@@ -61,6 +63,10 @@ export default class EventMessagesRepository
       NotificationTypes.DELETE_LEAVE_DIALOG,
       this.DeleteLeaveDialogEventHandler.bind(this),
     );
+    this.remoteDs.subscribeOnSystemMessaging(
+      NotificationTypes.REMOVE_USER,
+      this.RemoteUserDialogEventHandler.bind(this),
+    );
     this.remoteDs.subscribeOnMessaging(this.NewMessageEventHandler.bind(this));
     this.remoteDs.subscribeOnUpdateMessageStatus(
       this.UpdateMessageStatusEventHandler.bind(this),
@@ -158,6 +164,31 @@ export default class EventMessagesRepository
       });
   }
 
+  protected RemoteUserDialogEventHandler(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.REMOVE_USER
+        ].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) {
@@ -274,6 +305,9 @@ export default class EventMessagesRepository
       case NotificationTypes.DELETE_LEAVE_DIALOG:
         SystemMessageType = NotificationTypes.DELETE_LEAVE_DIALOG;
         break;
+      case NotificationTypes.REMOVE_USER:
+        SystemMessageType = NotificationTypes.REMOVE_USER;
+        break;
       case NotificationTypes.UPDATE_DIALOG:
         SystemMessageType = NotificationTypes.UPDATE_DIALOG;
         break;

package/src/Data/repository/MessagesRepository.ts

@@ -225,7 +225,7 @@ export default class MessagesRepository implements IMessagesRepository {
     await this.remoteDataSource.typingMessageStop(remoteDialogDTO, senderId);
   }
 
-  async saveMessageToLocal(entity: MessageEntity): Promise<boolean> {
+  async saveMessageToLocal(entity: MessageEntity): Promise<MessageEntity> {
     try {
       const dto: RemoteMessageDTO = await this.messageLocalDTOMapper.fromEntity(
         entity,
@@ -233,26 +233,32 @@ export default class MessagesRepository implements IMessagesRepository {
 
       await this.localDataStorage.saveMessage(dto);
 
-      return Promise.resolve(true);
+      return Promise.resolve(entity);
     } catch (e) {
-      return Promise.resolve(false);
+      // eslint-disable-next-line no-param-reassign
+      entity.delivered_ids = [];
+
+      return Promise.resolve(entity);
     }
   }
 
-  async sendMessageToRemote(entity: MessageEntity): Promise<boolean> {
+  async sendMessageToRemote(entity: MessageEntity): Promise<MessageEntity> {
+    let messageResult: MessageEntity = entity;
+
     try {
-      const dto: RemoteMessageDTO =
+      const dtoParam: RemoteMessageDTO =
         await this.messageRemoteDTOMapper.fromEntity(entity);
 
-      await this.remoteDataSource.sendMessage(dto);
+      const dtoResult: RemoteMessageDTO =
+        await this.remoteDataSource.sendMessage(dtoParam);
 
-      return Promise.resolve(true);
+      messageResult = await this.messageRemoteDTOMapper.toEntity(dtoResult);
+
+      return Promise.resolve(messageResult);
     } catch (e) {
       // eslint-disable-next-line prefer-promise-reject-errors
-      return Promise.reject(false);
+      return Promise.reject(messageResult);
     }
-
-    return Promise.resolve(false);
   }
 
   async updateMessageInLocal(entity: MessageEntity): Promise<boolean> {

package/src/Data/source/exception/MapperDTOException.ts

@@ -15,5 +15,8 @@ export class MapperDTOException extends RepositoryException {
   constructor(message: string, code: number, description = '') {
     super(message, code);
     this._description = description;
+    if (this._description) {
+      this.message += ` ${this._description}`;
+    }
   }
 }