@aiqa/sdk 0.0.0

package/src/config.ts

@@ -0,0 +1,29 @@
+export const MINIMAL_SUPPORT_VERSION = '1.0.0';
+
+export interface SDKConfig {
+  url?: string;
+  jwtToken?: string;
+  path?: string;
+  enableLogging?: boolean;
+}
+
+let config: SDKConfig = {
+  url: 'ws://localhost:3025',
+  path: '/ws',
+  enableLogging: true
+};
+
+export function setConfig(newConfig: SDKConfig) {
+  config = { ...config, ...newConfig };
+}
+
+export function getConfig(): SDKConfig {
+  return config;
+}
+
+export function isLoggingEnabled(): boolean {
+  return config.enableLogging !== false; // Default to true if not explicitly set to false
+}
+
+export default config;
+

package/src/enum.ts

@@ -0,0 +1,16 @@
+export enum Methods {
+  INIT_AUDIO_RECORDER = "INIT_AUDIO_RECORDER",
+  IS_ALIVE = "IS_ALIVE",
+
+  CREATE_APPLICATION = "CREATE_APPLICATION",
+  GET_APPLICATION = "GET_APPLICATION",
+  UPDATE_APPLICATION = "UPDATE_APPLICATION",
+  SET_ACTIVE_APPLICATION = "SET_ACTIVE_APPLICATION",
+  GET_ACTIVE_APPLICATION = "GET_ACTIVE_APPLICATION",
+
+  START_RECORDING = "START_RECORDING",
+  STOP_RECORDING = "STOP_RECORDING",
+  IS_RECORDING = "IS_RECORDING",
+  
+  ADD_FACT = "ADD_FACT"
+}

package/src/index.ts

@@ -0,0 +1,428 @@
+import { Methods } from "./enum";
+import service from "./service";
+import { TApplication, TApplicationPayload, TApplicationFactPayload, TApplicationFact, TResponse, TFactIsMatched, TResult } from "./types";
+import { setConfig, SDKConfig } from "./config";
+
+
+const AiQaSdk = class {
+  events: {};
+  
+  constructor(config?: SDKConfig) {
+    this.events = {};
+    
+    if (config) {
+      setConfig(config);
+    }
+    
+    // Проверяем есть ли соединение с ПайтонАпп и если нет, то мы кидаем ошибку. Установите или запустите приложение
+    // Постоянно должно стучатся и постоянно пытаться подключится
+    // После подключения проверить версию и кинуть ошибку если не совпадает версия
+  }
+
+  configure(config: SDKConfig) {
+    setConfig(config);
+  }
+
+  on(name: string, callback: (...args: any[]) => any) {
+    this.events[name] = callback;
+  }
+
+  off(name: string) {
+    delete this.events[name];
+  }
+
+  connect() {
+    service.connect(this.events);
+  }
+
+  disconnect() {
+    service.disconnect()
+  }
+
+  /// Is Alive
+
+ 
+
+  isAlive(cb: ({isAlive, error}: TResponse) => void) {
+    try {
+      const result = service.getStatus();
+      cb({isAlive: result})
+    }
+    catch(error) {
+      cb({error})
+    }
+  };
+
+  async isAliveAsync(): Promise<boolean> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const result = service.getStatus();
+        resolve(result);
+      }
+      catch(e) {
+        reject(e)
+      }
+    })
+  };
+
+  /// Get Application ??????
+
+  getApplication(id: string, cb:({application, error}: TResponse) => void) {
+    service.sendMessage(Methods.GET_APPLICATION, {id})
+      .then((application: TApplication) => {
+        cb({application})
+      })
+      .catch(({error}) => {
+        cb({error})
+      })
+  }
+
+  async getApplicationAsync(id: string): Promise<TApplication> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const application = await service.sendMessage(Methods.GET_APPLICATION, {id});
+        //@ts-ignore
+        resolve(application)
+      }
+      catch(e) {
+        reject(e)
+      }
+    })
+  }
+
+  /// Update Application
+
+  updateApplication(id: string, referenceId: string, cb: ({application, error}: TResponse) => void) {
+    service.sendMessage(Methods.UPDATE_APPLICATION, {id, referenceId})
+      .then((application: TApplication) => {
+        cb({application})
+      })
+      .catch(({error}) => {
+        cb({error})
+      })
+  }
+
+  async updateApplicationAsync(id: string, referenceId: string): Promise<TApplication> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const application = await service.sendMessage(Methods.UPDATE_APPLICATION, {id, referenceId});
+        //@ts-ignore
+        resolve(application)
+      }
+      catch(e) {
+        reject(e)
+      }
+    })
+  }
+
+  /// Create Application
+
+  createApplication(data: TApplicationPayload, cb: ({application, error}: TResponse) => void) {
+    service.sendMessage(Methods.CREATE_APPLICATION, data)
+    .then((application: TApplication) => {
+      cb({application})
+    })
+    .catch(({error}) => {
+      cb({error})
+    })
+  }
+
+  async createApplicationAsync(data: TApplicationPayload): Promise<TApplication> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const application = await service.sendMessage(Methods.CREATE_APPLICATION, data);
+        //@ts-ignore
+        resolve(application)
+      }
+      catch(e) {
+        reject(e)
+      }
+    })
+  }
+
+  /// Set Active Application
+
+  setActiveApplication(applicationId: string, cb: ({applicationIsActive, error}: TResponse) => void) {
+    service.sendMessage(Methods.SET_ACTIVE_APPLICATION, {applicationId, active: true})
+    .then((result: TResult) => {
+      if (!!result.error) {
+        cb({error: result.error})
+      } else if (typeof result.data === 'boolean') {
+        cb({applicationIsActive: result.data})
+      } else {
+        cb({error: new Error(`Type of response data for ${Methods.SET_ACTIVE_APPLICATION} method is not equal Boolean`)});
+      }
+    })
+    .catch((error: Error) => {
+      cb({error});
+    })
+  }
+
+  async setActiveApplicationAsync(applicationId: string): Promise<boolean> {
+    return new Promise(async (resolve, reject) => { //What return?
+      try {
+        const result = await service.sendMessage(Methods.SET_ACTIVE_APPLICATION, {applicationId, active: true});
+        //@ts-ignore
+        if (!!result.error) {
+          //@ts-ignore
+          reject(result.error)
+          //@ts-ignore
+        } else if (typeof result.data === 'boolean') {
+          //@ts-ignore
+          resolve(result.data)
+        } else {
+          reject(new Error(`Type of response data for ${Methods.SET_ACTIVE_APPLICATION} method is not equal Boolean`));
+        }
+      }
+      catch(e) {
+        reject(e)
+      }
+    })
+  }
+
+  /// Get Active Application
+
+  getActiveApplication(cb: ({application, error}: TResponse) => void) {
+    service.sendMessage(Methods.GET_ACTIVE_APPLICATION)
+    .then((application: TApplication | null) => {
+      cb({application})
+    })
+    .catch((error: Error) => {
+      cb({error});
+    })
+  }
+
+  async getActiveApplicationAsync(): Promise<TApplication | null> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const result = await service.sendMessage(Methods.GET_ACTIVE_APPLICATION);
+        //@ts-ignore
+        resolve(result)
+      }
+      catch(e) {
+        reject(e);
+      }
+    })
+  }
+
+  /// Reset Active Application
+  //ToDo Reset application is needed applicationId?
+  resetActiveApplication(cb: ({applicationIsActive, error}: TResponse) => void) {
+    service.sendMessage(Methods.SET_ACTIVE_APPLICATION, {active: false})
+    .then((result: TResult) => {
+      if (!!result.error) {
+        cb({error: result.error})
+      } else if (typeof result.data === 'boolean') {
+        cb({applicationIsActive: result.data})
+      } else {
+        cb({error: new Error(`Type of response data for ${Methods.SET_ACTIVE_APPLICATION} method is not equal Boolean`)});
+      }
+    })
+    .catch((error: Error) => {
+      cb({error});
+    })
+  }
+
+  async resetActiveApplicationAsync(): Promise<boolean> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const result = await service.sendMessage(Methods.SET_ACTIVE_APPLICATION, {active: false});
+        //@ts-ignore
+        if (!!result.error) {
+          //@ts-ignore
+          reject(result.error)
+          //@ts-ignore
+        } else if (typeof result.data === 'boolean') {
+          //@ts-ignore
+          resolve(result.data)
+        } else {
+          reject(new Error(`Type of response data for ${Methods.SET_ACTIVE_APPLICATION} method is not equal Boolean`));
+        }
+      }
+      catch(e) {
+        reject(e);
+      }
+    })
+  }
+
+  /// Add Fact
+
+  addFact(fact: TApplicationFactPayload, cb: ({factIsMatched, error}: TResponse) => void){
+    service.sendMessage(Methods.ADD_FACT, fact)
+    .then((result: TFactIsMatched) => {
+      cb({factIsMatched: result})
+    })
+    .catch((error: Error) => {
+      cb({error});
+    })
+  }
+
+  async addFactAsync (fact: TApplicationFactPayload): Promise<TFactIsMatched> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const result = await service.sendMessage(Methods.ADD_FACT, fact);
+        //@ts-ignore
+        resolve(result);
+      }
+      catch(e) {
+        reject(e);
+      }
+    })
+  }
+
+  /// Start Recording
+
+  startRecording(cb: ({recordingIsStarted, error}: TResponse) => void) {
+    service.sendMessage(Methods.START_RECORDING)
+    .then((result: TResult) => {
+      if (typeof result.data === 'boolean') {
+        cb({recordingIsStarted: result.data})
+      } else {
+        cb({error: new Error(`Type of response data for ${Methods.START_RECORDING} method is not equal Boolean`)})
+      }
+    })
+    .catch((error: Error) => {
+      cb({error})
+    })
+  }
+
+  async startRecordingAsync(): Promise<boolean> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const result = await service.sendMessage(Methods.START_RECORDING);
+        //@ts-ignore
+        if (!!result.error) {
+          //@ts-ignore
+          reject(result.error)
+          //@ts-ignore
+        } else if (typeof result.data === 'boolean') {
+          //@ts-ignore
+          resolve(result.data)
+        } else {
+          reject(new Error(`Type of response data for ${Methods.START_RECORDING} method is not equal Boolean`))
+        }
+      }
+      catch(error) {
+        reject(error)
+      }
+    })
+  }
+
+  /// Stop Recording
+
+  stopRecording(cb: ({recordingIsStopped, error}: TResponse) => void) {
+    service.sendMessage(Methods.STOP_RECORDING)
+    .then((result: TResult) => {
+      if (!!result.error) {
+        cb({error: result.error})
+      } else if (typeof result.data === 'boolean') {
+        cb({recordingIsStopped: result.data})
+      } else {
+        cb({error: new Error(`Type of response data for ${Methods.STOP_RECORDING} method is not equal Boolean`)})
+      }
+    })
+    .catch((error) => {
+      cb({error})
+    })
+  }
+
+  async stopRecordingAsync(): Promise<boolean> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const result = await service.sendMessage(Methods.STOP_RECORDING);
+        //@ts-ignore
+        if (!!result.error) {
+          //@ts-ignore
+          reject(result.error)
+          //@ts-ignore
+        } else if (typeof result.data === 'boolean') {
+          //@ts-ignore
+          resolve(result.data)
+        } else {
+          reject(new Error(`Type of response data for ${Methods.STOP_RECORDING} method is not equal Boolean`))
+        }
+      }
+      catch(error) {
+        reject(error)
+      }
+    })
+  } 
+
+  /// Is Recording Now
+
+  isRecordingNow(cb: ({recordingIsActive, error}: TResponse) => void) {
+    service.sendMessage(Methods.IS_RECORDING)
+    .then((result: TResult) => {
+      if (!!result.error) {
+        cb({error: result.error})
+      } else if (typeof result.data === 'boolean') {
+        cb({recordingIsActive: result.data})
+      } else {
+        cb({error: new Error(`Type of response data for ${Methods.IS_RECORDING} method is not equal Boolean`)})
+      }
+    })
+    .catch((error: Error) => {
+      cb({error})
+    })
+  };
+
+  async isRecordingNowAsync(): Promise<boolean> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const result = await service.sendMessage(Methods.IS_RECORDING);
+        //@ts-ignore
+        if (!!result.error) {
+          //@ts-ignore
+          reject(result.error)
+          //@ts-ignore
+        } else if (typeof result.data === 'boolean') {
+          //@ts-ignore
+          resolve(result.data)
+        } else {
+          reject(new Error(`Type of response data for ${Methods.IS_RECORDING} method is not equal Boolean`))
+        }
+      }
+      catch(e) {
+        reject(e)
+      }
+    })
+  };
+};
+
+export default AiQaSdk;
+
+
+/**
+  Validation for 
+  
+  - createApplication
+    policyNumber: string;
+    product: string;
+    insuredPhone: string;
+    clientName: string;
+
+  - addFact
+    {
+        "conversationId": "",
+        "applicationAliasKey": "",
+        "factId": "",
+        "fact_status": true,
+        "value": "string"
+    }
+
+  if user set wrong data we can make throw or call callback / reject function
+
+  and optional checking arg for 
+
+  - getApplication
+    check string argument
+
+  - setApplication
+    check string argument
+
+  - onClick Play/Stop
+    check is the application active
+
+  - addFact
+    check is the application active
+ */

package/src/logger.ts

@@ -0,0 +1,37 @@
+import { isLoggingEnabled } from "./config";
+
+class Logger {
+  log(...args: any[]): void {
+    if (isLoggingEnabled()) {
+      console.log(...args);
+    }
+  }
+
+  error(...args: any[]): void {
+    if (isLoggingEnabled()) {
+      console.error(...args);
+    }
+  }
+
+  warn(...args: any[]): void {
+    if (isLoggingEnabled()) {
+      console.warn(...args);
+    }
+  }
+
+  info(...args: any[]): void {
+    if (isLoggingEnabled()) {
+      console.info(...args);
+    }
+  }
+
+  debug(...args: any[]): void {
+    if (isLoggingEnabled()) {
+      console.debug(...args);
+    }
+  }
+}
+
+export const logger = new Logger();
+export default logger;
+

package/src/service/index.ts

@@ -0,0 +1,139 @@
+import { MINIMAL_SUPPORT_VERSION, getConfig } from "../config";
+import { Methods } from "../enum";
+import { TApplication, TApplicationFact, TFactIsMatched, TResult } from "../types";
+import logger from "../logger";
+
+// Use global io from CDN (loaded in index.html)
+// @ts-ignore - window.io is loaded via CDN before this script
+const io = (typeof window !== 'undefined' ? (window as any).io : null);
+
+const queue: any[] = [];
+const listenersList: any[] = [];
+const excludedMessages: string[] = ['app_version'];
+
+const service = {
+  connect(events) {
+    const self = this;
+    const config = getConfig();
+
+    logger.log('INIT WEBSOCKET', config.url);
+  
+    if (!config.url) {
+        logger.log("WebSocket address is required.");
+        return;
+    }
+
+    const socketOptions: any = {
+      reconnectionDelayMax: 10000,
+      path: config.path || '/ws',
+    };
+
+    if (config.jwtToken) {
+      socketOptions.extraHeaders = {
+        'Authorization': `Bearer ${config.jwtToken}`
+      };
+    }
+
+    this.websocketClient = io(config.url, socketOptions);
+
+    this.websocketClient.on('connect', () => {
+      logger.log("WebSocket connection established");
+
+      !!events['connect'] && events['connect']();
+    });
+
+    this.websocketClient.on('app_version', (version: string = '1.0.0') => {
+      if(!(MINIMAL_SUPPORT_VERSION <= version)) {
+        self.websocketClient.disconnect();
+        throw new Error (`You version of AIQAapp is out of date. Your version is ${version}. Required >= ${MINIMAL_SUPPORT_VERSION}. Please update your app.`)
+      } else {
+        self.websocketClient.emit(Methods.INIT_AUDIO_RECORDER, JSON.stringify({init: true})); //TODO Try remove JSON.stringify
+      }
+    })
+
+    this.websocketClient.on('close', (event) => {
+      logger.log("WebSocket connection closed", event);
+      !!events['close'] && events['close']();
+    });
+
+    this.websocketClient.on('disconnect', () => {
+      logger.log('Disconnected from WebSocket server');
+      !!events['disconnect'] && events['disconnect']();
+    });
+    
+    this.websocketClient.io.on("error", (error) => {
+      logger.log("error", error);
+      !!events['error'] && events['error']();
+    });
+    
+    this.websocketClient.io.on("reconnect_attempt", (attempt) => {
+      logger.log('reconnect_attempt', attempt);
+      !!events['reconnect_attempt'] && events['reconnect_attempt']();
+    });
+    
+    this.websocketClient.io.on("reconnect_error", (error) => {
+      logger.log("reconnect_error", error);
+      !!events['reconnect_error'] && events['reconnect_error']();
+    });
+    
+    this.websocketClient.io.on("reconnect_failed", (error) => {
+      logger.log("reconnect_failed", error);
+      !!events['reconnect_failed'] && events['reconnect_failed']();
+    });
+
+    this.websocketClient.onAny((eventName: string, eventData: any) => {
+      logger.log("Message from server:", eventName, eventData);
+      logger.log("excludedMessages", excludedMessages);
+      if(eventName && !excludedMessages.includes(eventName)) {
+        const response = eventData ? JSON.parse(eventData) : {};
+        const item = queue.find((item) => item.addressee === eventName);
+        const listener = listenersList.find((item) => item.addressee === eventName);
+
+        if (item && response.data) {  
+          item.resolve({data: response.data});
+          self.removeFromQueue(item);
+        } else if (listener && response.data) {
+          listener.callback({data: response.data});
+        } else if (item && response.error) {
+          item.reject({error: response.error});
+          self.removeFromQueue(item);
+        } else if (listener && response.error) {
+          listener.callback({error: response.error});
+        } else {
+          logger.error('Problem with receiving message');
+        }
+      }
+    })
+  },
+
+  disconnect() {
+    this.websocketClient.disconnect()
+  },
+
+  addListener(addressee: string, _checkAppVersion: () => void) {
+    listenersList.push({addressee, callback: _checkAppVersion});
+  },
+
+  sendMessage(addressee: string, data?: any): Promise<TApplication | TApplicationFact | TFactIsMatched | TResult> {
+    const self = this;
+    const promise: Promise<TApplication | TApplicationFact | TFactIsMatched | boolean> = new Promise((resolve, reject) => {
+      queue.push({addressee, resolve, reject});
+      self.websocketClient.emit(addressee, data ? JSON.stringify(data) : undefined);  //TODO Try remove JSON.stringify
+    })
+
+    return promise
+  },
+
+  removeFromQueue(item) {
+    const index = queue.indexOf(item);
+    if (index > -1) { // only splice array when item is found
+      queue.splice(index, 1); // 2nd parameter means remove one item only
+    }
+  },
+
+  getStatus() {
+    return this.websocketClient.connected;
+  }
+}
+
+export default service;