@aiqa/sdk 0.0.0

package/src/types.ts

@@ -0,0 +1,164 @@
+
+export type TApplicationPayload = {
+  policyNumber: string;
+  product: string;
+  insuredPhone: string;
+  clientName: string;
+}
+
+export type TApplicationUtterance = {
+  id: string;
+  application_id?: string;
+  call_id?: number;
+  order?: number;
+  is_agent?: boolean; //?????
+  speaker?: number;
+  text?: string;
+  text_en?: string;
+  start_time?: number;
+  end_time?: number;
+  extra?: any;
+}
+
+export type TApplication = {
+  application_id: string;
+  adviser_id: string;
+  start_date: Date;
+  language: string;
+  rtStatus: string; // ??? Need create enum + discuss name
+
+  policy_number?: string;
+  insured_phone?: string;
+  client_name?: string;
+
+  utterances: TApplicationUtterance[];
+  facts: TApplicationFact[];
+}
+
+//////// ADD FACTS
+
+export type TApplicationFactPayload = {
+  fact: {
+    id: string;
+    expected_answer: string;
+  };
+  applicationId: string;
+}
+
+export type TApplicationFact = {
+  id: string;
+  expected_answer: string;
+  actual_answer: string;
+  is_matched: boolean;
+}
+/////////////
+
+export interface payloadSubscribeOnApplication {
+  application_id: string;
+}
+
+export type TFactIsMatched = boolean;
+
+export type TResponse = {
+  isAlive?: boolean;
+  application?: TApplication | null,
+  applicationIsActive?: boolean;
+  factIsMatched?: TFactIsMatched;
+  recordingIsStarted?: boolean;
+  recordingIsStopped?: boolean;
+  recordingIsActive?: boolean;
+  error?: Error
+}
+
+export type TResult = {
+  data?: any;
+  error?: any;
+}
+
+/**
+ * Events
+ * 'connect'
+ * 'disconnect'
+ * 'close'
+ * 'error'
+ */
+
+abstract class AiqaSdk {
+  abstract connect(): void;
+  abstract disconnect(): void;
+
+  abstract on(eventName: string, callback: (...args: any[]) => any): void;
+  abstract off(eventName: string): void;
+
+  abstract isAlive(cb: ({isAlive, error}: TResponse) => void): void;
+  abstract isAliveAsync(): Promise<boolean>;
+
+  abstract getApplication(applicationId: string, cb:({application, error}: TResponse) => void): void; 
+  abstract getApplicationAsync(applicationId: string): Promise<TApplication>;
+
+  abstract createApplication(data: TApplicationPayload, cb: ({application, error}: TResponse) => void): void; 
+  abstract createApplicationAsync(data: TApplicationPayload): Promise<TApplication>; 
+  
+  abstract setActiveApplication(applicationId: string, cb: ({applicationIsActive, error}: TResponse) => void): void;
+  abstract setActiveApplication(applicationId: string): Promise<boolean>;
+
+  abstract getActiveApplication(cb: ({application, error}: TResponse) => void): void;
+  abstract getActiveApplicationAsync(): Promise<TApplication | null>;
+
+  abstract resetActiveApplication(applicationId: string, cb: ({applicationIsActive, error}: TResponse) => void): void;
+  abstract resetActiveApplicationAsync(applicationId: string): Promise<boolean>;
+
+  abstract addFact(fact: TApplicationFactPayload, cb: ({factIsMatched, error}: TResponse) => void): void;
+  abstract addFactAsync(fact: TApplicationFactPayload): Promise<TFactIsMatched>;
+
+  abstract startRecording(cb: ({recordingIsStarted, error}: TResponse) => void): void; 
+  abstract startRecordingAsync(): Promise<boolean>; 
+
+  abstract stopRecording(cb: ({recordingIsStopped, error}: TResponse) => void): void; 
+  abstract stopRecordingAsync(): Promise<boolean>; 
+
+  abstract isRecordingNow(cb: ({recordingIsActive, error}: TResponse) => void): void;
+  abstract isRecordingNowAsync(): Promise<boolean>;
+}
+
+/*
+Со стороны Стаса нужно реализовать методы
+
+getApplication
+
+createApplication
+
+setActiveApplication = вроде реализован subscribeOnApplication, но ничего не возвращает
+
+getActiveApplication
+
+resetActiveApplication ???
+
+addFact = вроде реализовано ??? должен возвращать тру фолс, но ничего не возвращает
+так же отправка идет не массивом, а по одному факту
+
+////////
+
+нет понимания какие ошибки будет возвращать Сервер
+
+////////
+
+GET_APPLICATION => applicationId : TApplication
+CREATE_APPLICATION => applicationPayload: TApplication
+SET_ACTIVE_APPLICATION => applicationId, {active: true} || true для отключения отправлять false : TRUE/FALSE
+GET_ACTIVE_APPLICATION => undefined : TApplication
+ADD_FACT => factPayload : TRUE/FALSE
+
+внутренний метод
+
+ADD_UTTERANCES => еще не реализован, должен быть реализован внутри ПайтонАпп
+
+
+
+
+
+
+
+*/
+
+

package/tests/index.test.ts

@@ -0,0 +1,534 @@
+import {afterAll, beforeAll, describe, expect, it, jest, test, afterEach, beforeEach} from '@jest/globals';
+import AiQaSdk from '../src';
+import { TResponse } from '../src/types';
+
+import { createServer } from "node:http";
+
+import { Server } from "socket.io";
+import { WEBSOCKET_PORT } from "../src/config";
+import { Methods } from '../src/enum';
+
+
+describe('', () => {
+  let app, ioServer, serverSocket;
+    
+  beforeAll((done) => {
+    const httpServer = createServer();
+    ioServer = new Server(httpServer);
+    httpServer.listen(WEBSOCKET_PORT, () => {
+      app = new AiQaSdk();
+      app.on('connect', () => {
+        done()
+      });
+      ioServer.on("connection", (socket) => {
+        serverSocket = socket;
+      });
+      app.connect();
+    });
+  });
+
+  // afterEach(() => {
+  //   console.log('After All')
+  //   ioServer.close();
+  //   app.disconnect();
+  // });
+
+  describe.skip('isAlive method', () => {
+    it('should be true', (done) => {
+      app.isAlive(({data, error}: TResponse) => {
+        expect(data).toBe(true);
+        done();
+      })
+    });
+
+    it('should be false', (done) => {
+      app.disconnect();
+      app.isAlive(({data, error}: TResponse) => {
+        expect(data).toBe(false);
+        done();
+        app.connect();
+      })
+    });
+  });
+  
+  describe.skip('isAliveAsync method', () => {
+    it('should be true', async () => {
+      app.connect();
+      const result = await app.isAliveAsync();
+      expect(result).toBe(true);
+    });
+
+    it('should be false', async () => {
+      app.disconnect();
+      const result = await app.isAliveAsync();
+      expect(result).toBe(false);
+      app.connect();
+    });
+  });
+
+  describe('getApplication method', () => {
+    it.skip(`should send message ${Methods.GET_APPLICATION} to PythonApp`, (done) => {
+      const someapplicationId = 'someapplicationId';
+      serverSocket.on(Methods.GET_APPLICATION, (message: string) => {
+        const stringIncludes = message.includes(someapplicationId);
+        expect(stringIncludes).toBe(true);
+        done();
+      });
+
+      app.getApplication(someapplicationId, ({data, error}: TResponse) => {
+        console.log('')
+      })
+    });
+
+    it('should return application', (done) => {
+      const application = {some: 'value'} //TODO need APP
+    
+      app.getApplication('someapplicationId', ({data, error}: TResponse) => {
+        console.log(application)
+        //@ts-ignore
+        expect(data).toMatchObject(application);
+        done();
+      })
+
+      serverSocket.emit(Methods.GET_APPLICATION, JSON.stringify(application))
+    });
+  })
+
+  describe('getApplicationAsync method', () => {
+    it.skip(`should send message ${Methods.GET_APPLICATION} to PythonApp`, (done) => {
+      const someapplicationId = 'someapplicationId';
+      serverSocket.on(Methods.GET_APPLICATION, (message: string) => {
+        const stringIncludes = message.includes(someapplicationId);
+        expect(stringIncludes).toBeTruthy();
+        done();
+      });
+
+      app.getApplicationAsync(someapplicationId);
+    })
+
+    it('should return application', (done) => {
+      const application = {some: 'value'} //TODO need APP
+    
+      app.getApplicationAsync('someapplicationId')
+      .then((data) => {
+        expect(data.application).toMatchObject(application);
+        done()
+      })
+
+      serverSocket.emit(Methods.GET_APPLICATION, JSON.stringify({application}));
+    });
+  })
+
+  describe('createApplication method', () => {
+    it.skip(`should send message ${Methods.CREATE_APPLICATION} to PythonApp`, (done) => {
+      const createData = {some: 'data'};
+
+      serverSocket.on(Methods.CREATE_APPLICATION, (message: string) => {
+        const stringEqual = message.includes(JSON.stringify(createData));
+        expect(stringEqual).toBeTruthy();
+        done();
+      });
+
+      app.createApplication(createData, ({data, error}: TResponse) => {
+        console.log('')
+      })
+    });
+
+    it('should return created application', (done) => {
+      const createData = {some: 'value'} //TODO need APP
+    
+      app.createApplication(createData, ({data, error}: TResponse) => {
+        console.log(createData)
+        expect(data).toMatchObject(createData);
+        done();
+      })
+
+      serverSocket.emit(Methods.CREATE_APPLICATION, JSON.stringify(createData))
+    });
+  })
+
+  describe('createApplicationAsync method', () => {
+    it.skip(`should send message ${Methods.CREATE_APPLICATION} to PythonApp`, (done) => {
+      const createData = {some: 'data'};
+
+      serverSocket.on(Methods.CREATE_APPLICATION, (message: string) => {
+        const stringEqual = message.includes(JSON.stringify(createData));
+        expect(stringEqual).toBeTruthy();
+        done();
+      });
+
+      app.createApplicationAsync(createData)
+    });
+
+    it('should return created application', (done) => {
+      const createData = {some: 'value'} //TODO need APP
+    
+      app.createApplicationAsync(createData)
+      .then((data) => {
+        expect(data).toMatchObject(createData);
+        done()
+      })
+
+      serverSocket.emit(Methods.CREATE_APPLICATION, JSON.stringify(createData));
+    });
+  })
+
+  ///
+
+  describe('setActiveApplication method', () => {
+    it.skip(`should send message ${Methods.SET_ACTIVE_APPLICATION} to PythonApp`, (done) => {
+      const applicationId = 'someApplicationId';
+
+      serverSocket.on(Methods.SET_ACTIVE_APPLICATION, (message: string) => {
+        const stringEqual = message.includes(applicationId);
+        expect(stringEqual).toBe(true);
+        done();
+      });
+
+      app.setActiveApplication(applicationId, ({data, error}: TResponse) => {
+        console.log('')
+      })
+    });
+
+    it('should return state true', (done) => {
+      const applicationId = 'someApplicationId';
+    
+      app.setActiveApplication(applicationId, ({data, error}: TResponse) => {
+        expect(data).toBe(true);
+        done();
+      })
+
+      serverSocket.emit(Methods.SET_ACTIVE_APPLICATION, JSON.stringify(true))
+    });
+  })
+
+  describe('setActiveApplicationAsync method', () => {
+    it.skip(`should send message ${Methods.SET_ACTIVE_APPLICATION} to PythonApp`, (done) => {
+      const applicationId = 'someApplicationId';
+
+      serverSocket.on(Methods.SET_ACTIVE_APPLICATION, (message: string) => {
+        const stringEqual = message.includes(JSON.stringify(applicationId));
+        expect(stringEqual).toBe(true);
+        done();
+      });
+
+      app.setActiveApplicationAsync(applicationId)
+    });
+
+    it('should return state true', (done) => {
+      const applicationId = 'someApplicationId';
+    
+      app.setActiveApplicationAsync(applicationId)
+      .then((data) => {
+        expect(data).toBe(true);
+        done();
+      })
+
+      serverSocket.emit(Methods.SET_ACTIVE_APPLICATION, JSON.stringify(true));
+    });
+  })
+
+  ///
+
+  describe('getActiveApplication method', () => {
+    it.skip(`should send message ${Methods.GET_ACTIVE_APPLICATION} to PythonApp`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.GET_ACTIVE_APPLICATION, () => {
+        mockFn()
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.getActiveApplication(({data, error}: TResponse) => {
+        console.log('')
+      });
+    });
+
+    it('should return state true', (done) => {
+      const application = {some: 'data'};
+    
+      app.getActiveApplication(({data, error}: TResponse) => {
+        expect(data).toMatchObject(application);
+        done();
+      })
+
+      serverSocket.emit(Methods.GET_ACTIVE_APPLICATION, JSON.stringify(application))
+    });
+  })
+
+  describe('getActiveApplicationAsync method', () => {
+    it.skip(`should send message ${Methods.GET_ACTIVE_APPLICATION} to PythonApp`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.GET_ACTIVE_APPLICATION, () => {
+        mockFn();
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.getActiveApplicationAsync()
+    });
+
+    it('should return state true', (done) => {
+      const application = {some: 'value'} //TODO need APP
+    
+      app.getActiveApplicationAsync()
+      .then((data) => {
+        expect(data.application).toMatchObject(application);
+        done()
+      })
+
+      serverSocket.emit(Methods.GET_ACTIVE_APPLICATION, JSON.stringify({application}));
+    });
+  })
+
+  ///
+
+  describe('resetActiveApplication method', () => {
+    it.skip(`should send message ${Methods.SET_ACTIVE_APPLICATION} to PythonApp`, (done) => {
+      const applicationId = 'someApplicationId';
+
+      serverSocket.on(Methods.SET_ACTIVE_APPLICATION, (message: string) => {
+        const stringEqual = message.includes(applicationId);
+        expect(stringEqual).toBeTruthy();
+        done();
+      });
+
+      app.resetActiveApplication(applicationId, ({data, error}: TResponse) => {
+        console.log('')
+      })
+    });
+
+    it('should return state false', (done) => {
+      const applicationId = 'someApplicationId';
+    
+      app.setActiveApplication(applicationId, ({data, error}: TResponse) => {
+        expect(data).toBe(false);
+        done();
+      })
+
+      serverSocket.emit(Methods.SET_ACTIVE_APPLICATION, JSON.stringify(false))
+    });
+  })
+
+  describe('resetActiveApplicationAsync method', () => {
+    it.skip(`should send message ${Methods.SET_ACTIVE_APPLICATION} to PythonApp`, (done) => {
+      const applicationId = 'someApplicationId';
+
+      serverSocket.on(Methods.SET_ACTIVE_APPLICATION, (message: string) => {
+        const stringEqual = message.includes(JSON.stringify(applicationId));
+        expect(stringEqual).toBeTruthy();
+        done();
+      });
+
+      app.resetActiveApplicationAsync(applicationId)
+    });
+
+    it('should return state true', (done) => {
+      const applicationId = 'someApplicationId';
+    
+      app.setActiveApplicationAsync(applicationId)
+      .then((data) => {
+        expect(data).toBe(false);
+        done();
+      })
+
+      serverSocket.emit(Methods.SET_ACTIVE_APPLICATION, JSON.stringify(false));
+    });
+  })
+
+  ///
+
+  describe('addTests method', () => {
+    it.skip(`should send message ${Methods.ADD_FACT} to PythonApp`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.ADD_FACT, () => {
+        mockFn();
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.addFact(({data, error}: TResponse) => {
+        console.log('')
+      })
+    });
+
+    it.only(`should return fact`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.ADD_FACT, () => {
+        mockFn();
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.addFact(({data, error}: TResponse) => {
+        console.log('')
+      })
+    });
+  })
+
+  describe('addTestsAsync method', () => {
+    it.skip(`should send message ${Methods.ADD_FACT} to PythonApp`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.ADD_FACT, () => {
+        mockFn();
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.addFact(({data, error}: TResponse) => {
+        console.log('')
+      })
+    });
+
+    it.only(`should return fact`, (done) => {
+      app.addFact()
+    });
+  })
+
+  ///
+
+  describe('startRecording method', () => {
+    it.skip(`should send message ${Methods.START_RECORDING} to PythonApp`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.START_RECORDING, () => {
+        mockFn();
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.startRecording(({data, error}: TResponse) => {
+        console.log('')
+      })
+    });
+
+    it('should return state true', (done) => {
+      app.startRecording(({data, error}: TResponse) => {
+        expect(data).toBe(true);
+        done();
+      })
+
+      serverSocket.emit(Methods.START_RECORDING, JSON.stringify(true))
+    });
+  })
+
+  describe('startRecordingAsync method', () => {
+    it.skip(`should send message ${Methods.START_RECORDING} to PythonApp`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.START_RECORDING, (message: string) => {
+        mockFn();
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.startRecordingAsync()
+    });
+
+    it('should return state true', (done) => {
+      app.startRecordingAsync()
+      .then((data) => {
+        expect(data).toBe(true);
+        done();
+      })
+
+      serverSocket.emit(Methods.START_RECORDING, JSON.stringify(true));
+    });
+  })
+
+  ///
+
+  describe('stopRecording method', () => {
+    it.skip(`should send message ${Methods.STOP_RECORDING} to PythonApp`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.STOP_RECORDING, () => {
+        mockFn();
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.stopRecording(({data, error}: TResponse) => {
+        console.log('')
+      })
+    });
+
+    it('should return state false', (done) => {
+      app.stopRecording(({data, error}: TResponse) => {
+        expect(data).toBe(true);
+        done();
+      })
+
+      serverSocket.emit(Methods.STOP_RECORDING, JSON.stringify(true))
+    });
+  })
+
+  describe('stopRecordingAsync method', () => {
+    it.skip(`should send message ${Methods.STOP_RECORDING} to PythonApp`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.STOP_RECORDING, (message: string) => {
+        mockFn();
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.stopRecordingAsync()
+    });
+
+    it('should return state true', (done) => {
+      app.stopRecordingAsync()
+      .then((data: boolean) => {
+        expect(data).toBe(true);
+        done();
+      })
+
+      serverSocket.emit(Methods.STOP_RECORDING, JSON.stringify(true));
+    });
+  })
+
+  ///
+
+  describe('isRecordingNow method', () => {
+    it.skip(`should send message ${Methods.IS_RECORDING} to PythonApp`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.IS_RECORDING, () => {
+        mockFn();
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.isRecordingNow(({data, error}: TResponse) => {
+        console.log('')
+      })
+    });
+
+    it('should return state true', (done) => {
+      app.isRecordingNow(({data, error}: TResponse) => {
+        expect(data).toBe(true);
+        done();
+      })
+
+      serverSocket.emit(Methods.IS_RECORDING, JSON.stringify(true))
+    });
+  })
+
+  describe('isRecordingAsync method', () => {
+    it.skip(`should send message ${Methods.IS_RECORDING} to PythonApp`, (done) => {
+      const mockFn = jest.fn();
+      serverSocket.on(Methods.IS_RECORDING, (message: string) => {
+        mockFn();
+        expect(mockFn).toHaveBeenCalled();
+        done();
+      });
+
+      app.isRecordingNowAsync()
+    });
+
+    it('should return state false', (done) => {
+      app.isRecordingNowAsync()
+      .then((data: boolean) => {
+        expect(data).toBe(false);
+        done();
+      })
+
+      serverSocket.emit(Methods.IS_RECORDING, JSON.stringify(false));
+    });
+  })
+})

package/tests/server.ts

@@ -0,0 +1,22 @@
+import { createServer } from "http";
+import { Server } from "socket.io";
+import { WEBSOCKET_PORT } from "../src/config";
+
+function createSocketIoServer() {
+  const httpServer = createServer();
+  const ioServer = new Server(httpServer, {
+    // options
+  });
+  
+  ioServer.on("connection", (socket) => {
+    // ...
+  });
+  
+  httpServer.listen(WEBSOCKET_PORT);
+  
+  console.log('Started...', WEBSOCKET_PORT)
+
+  return ioServer;
+}
+
+export default createSocketIoServer;