amazon-connect-reference-dialer 1.0.0 → 1.4.2

package/src/client/api/csioHandler.js

@@ -0,0 +1,204 @@
+'use strict';
+import networkStrengthMonitor from './networkStrengthMonitor';
+import audioFrequencyMonitor from './audioFrequencyMonitor';
+
+import lo from 'lodash';
+import databaseManager from './databaseManager';
+import {
+  getRandomInt
+} from './../utils/acutils';
+import mediaManager from './mediaManager';
+
+const appId = APP_ID || WEB_PACK_APP_ID;
+const appSecret = APP_SECRET || WEB_PACK_APP_SECRET;
+const enableJabraCollection = ENABLE_JABRA_COLLECTION === 'enable';
+const siteIds = ['HQ', 'Remote', 'Home'];
+
+const ccpUrl = () => {
+  const connectURL = databaseManager.getDefaultConnectURL(CONNECT_URL || WEB_PACK_CONNECT_URL);
+  return `https://${connectURL}/connect/ccp#/`;
+};
+
+class CSIOHandler {
+  constructor () {
+    this.callstatsac = undefined;
+    this.dispatch = undefined;
+    this.localUserId = undefined;
+    // eslint-disable-next-line new-cap
+    this.agentMonitor = new callstatsAgentMonitor();
+  }
+
+  /**
+   * @private
+   * @return {string} Return a site id from given site id list
+   */
+  getRandomSiteId () {
+    return siteIds[ getRandomInt(1, siteIds.length) - 1 ];
+  }
+  // eslint-disable-next-line handle-callback-err
+  onCSIOInitialize (err, msg) {
+    // console.warn('->', 'onCSIOInitialize', new Date(), err, msg);
+  }
+
+  onCSIOStats (stats) {
+    // console.warn('->onCSIOStats', stats);
+    if (stats && stats.fabricState === 'terminated') {
+      return;
+    }
+
+    if (stats && stats.mediaStreamTracks) {
+      let track1 = lo.first(stats.mediaStreamTracks);
+      let track2 = lo.last(stats.mediaStreamTracks);
+
+      // console.warn('~', stats);
+      let audioIntputLevel = parseInt(track1.audioIntputLevel || track2.audioIntputLevel || 0, 10);
+      let audioOutputLevel = parseInt(track1.audioOutputLevel || track2.audioOutputLevel || 0, 10);
+
+      let track1Bitrate = parseInt(track1.bitrate || 0, 10);
+      let track2Bitrate = parseInt(track2.bitrate || 0, 10);
+      let track1RTT = parseInt(track1.rtt || 0, 10);
+      // no rtt for inbound tracks.
+      // let track2RTT = parseInt(track1.rtt || 0, 10);
+
+      let track1Fl = parseInt(track1.fractionLoss || 0, 10);
+      let track2Fl = parseInt(track2.fractionLoss || 0, 10);
+
+      //      console.warn('-> ', 'on csio stats', stats);
+      networkStrengthMonitor.addThroughput(track1Bitrate, track2Bitrate);
+      networkStrengthMonitor.addRTT(track1RTT, track1RTT);
+      networkStrengthMonitor.addRTT(track1Fl, track2Fl);
+      audioFrequencyMonitor.addAudioLevel(audioIntputLevel, false);
+      audioFrequencyMonitor.addAudioLevel(audioOutputLevel, true);
+    }
+  }
+
+  getRemoteStream () {
+    const pc = CallstatsAmazonShim && CallstatsAmazonShim.getPeerConnection();
+    if (!pc) {
+      return undefined;
+    }
+    const remoteStreams = pc.getRemoteStreams();
+    return remoteStreams && lo.get(remoteStreams, 0, undefined);
+  }
+
+  doPrecallTest () {
+    return new Promise((resolve) => {
+      if (CallstatsAmazonShim) {
+        CallstatsAmazonShim.makePrecallTest((status, result) => {
+          // console.warn('-> ', 'on precall test', status, result);
+          let testResult = databaseManager.savePrecalltestResult(result);
+
+          let throughput = lo.get(result, 'throughput', 0);
+          let rtt = lo.get(result, 'rtt', 0);
+          let fractionalLoss = lo.get(result, 'fractionalLoss', 0);
+          networkStrengthMonitor.addThroughput(throughput, throughput);
+          networkStrengthMonitor.addRTT(rtt, rtt);
+          networkStrengthMonitor.addFractionalLoss(fractionalLoss, fractionalLoss);
+          resolve(testResult);
+        });
+      }
+    });
+  }
+
+  onCSIORecommendedConfigCallback (config) {
+    // console.warn('->', 'onCSIORecommendedConfigCallback', new Date(), config);
+  }
+
+  onCSIOPrecalltestCallback (status, result) {
+    // console.warn('-> ', 'on precall test', status, result);
+    databaseManager.savePrecalltestResult(result);
+    let throughput = lo.get(result, 'throughput', 0);
+    let rtt = lo.get(result, 'rtt', 0);
+    let fractionalLoss = lo.get(result, 'fractionalLoss', 0);
+    networkStrengthMonitor.addThroughput(throughput, throughput);
+    networkStrengthMonitor.addRTT(rtt, rtt);
+    networkStrengthMonitor.addFractionalLoss(fractionalLoss, fractionalLoss);
+  }
+
+  dispose () {
+    this.dispatch = undefined;
+  }
+
+  register (dispatch = undefined, agent = undefined) {
+    this.dispatch && this.dispose();
+    this.dispatch = dispatch;
+
+    if (!agent) {
+      // console.error('agent object cannot be empty');
+      return;
+    }
+    if (!CallstatsAmazonShim) {
+      // console.error('CallstatsAmazonShim object cannot be empty');
+      return;
+    }
+    const localUserId = agent.getName();
+    this.localUserId = localUserId;
+    const configParams = {
+      siteID: this.getRandomSiteId(),
+      enableJabraCollection: enableJabraCollection
+    };
+
+    if (this.callstatsac) {
+      this.callstatsac = undefined;
+    }
+
+    this.callstatsac = CallstatsAmazonShim.initialize(connect, appId, appSecret, localUserId, configParams, this.onCSIOInitialize, this.onCSIOStats);
+    this.callstatsac.on('recommendedConfig', this.onCSIORecommendedConfigCallback.bind(this));
+    this.callstatsac.on('preCallTestResults', this.onCSIOPrecalltestCallback.bind(this));
+
+    // add agent monitor
+    if (this.agentMonitor && typeof this.agentMonitor.initialize === 'function') {
+      this.agentMonitor.initialize(connect, ccpUrl(), appId, appSecret, localUserId, configParams);
+    }
+  }
+
+  // Quick hack to send feedback in structural way before we have a API for that
+  postProcessFeedback (feedbackJSON = {}) {
+    let markedFeedback = [];
+    for (let currentIssue of feedbackJSON.issueList || []) {
+      for (let issue of currentIssue.items || []) {
+        if (issue.marked === true) {
+          markedFeedback.push(issue.text);
+        }
+      }
+    }
+    return markedFeedback;
+  }
+
+  sendFeedback (feedbackJSON = {}) {
+    let markedFeedbackList = this.postProcessFeedback(feedbackJSON);
+    let feedbackText = `${[feedbackJSON.feedbackText, ...markedFeedbackList].join(' ,')}`;
+    const feedback = {
+      userId: this.localUserId,
+      overall: Math.max(feedbackJSON.feedbackRatings, 1),
+      comment: feedbackText
+    };
+    CallstatsAmazonShim.sendUserFeedback(feedback, msg => {
+      // console.warn('on submitted feedback ', msg);
+    });
+  }
+
+  sendFeedbackRating (feedbackRating = 1) {
+    const feedback = {
+      userId: this.localUserId,
+      overall: Math.max(feedbackRating, 1)
+    };
+    CallstatsAmazonShim.sendUserFeedback(feedback, msg => {
+      // console.warn('on submitted rating ', msg);
+    });
+  }
+
+  sendActiveDeviceList () {
+    mediaManager.getDefaultOrPreferredAudioInputDevice()
+      .then(activeAudioDevice => {
+        const eventData = {
+          deviceList: [activeAudioDevice]
+        };
+        CallstatsAmazonShim.sendFabricEvent(this.callstatsac.fabricEvent.activeDeviceList, eventData);
+      })
+      .catch(() => {});
+  }
+}
+
+const csioHandler = new CSIOHandler();
+export default csioHandler;

package/src/client/api/databaseManager.js

@@ -0,0 +1,59 @@
+'use strict';
+
+const maxElement = 500;
+
+class DatabaseManager {
+  // eslint-disable-next-line no-useless-constructor
+  constructor () {
+  }
+
+  savePrecalltestResult (result) {
+    const epochTime = (new Date()).getTime();
+    let retval = this.getPrecallTestResult();
+    if (retval) {
+      if (retval.length > maxElement) {
+        retval.shift();
+      }
+      retval.push({ ...result, epochTime });
+    }
+
+    window.localStorage.setItem('rttResult', JSON.stringify(retval));
+    return retval;
+  }
+
+  getPrecallTestResult () {
+    let result = window.localStorage.getItem('rttResult') || undefined;
+    if (result) {
+      return JSON.parse(result);
+    }
+    return [];
+  }
+
+  saveDefaultDevice (defaultAudioDevice = undefined) {
+    window.localStorage.setItem('defaultDevice', JSON.stringify(defaultAudioDevice));
+  }
+
+  getSelectedAudioDevice () {
+    return window.localStorage.getItem('defaultDevice') || undefined;
+  }
+
+  setDefaultConnectURL (ccpURL = '') {
+    window.localStorage.setItem('defaultConnectURL', ccpURL);
+    return ccpURL;
+  }
+
+  getDefaultConnectURL (ccpURL = '') {
+    return window.localStorage.getItem('defaultConnectURL') || ccpURL || undefined;
+  }
+
+  setDefaultCountry (defaultCountry = '') {
+    window.localStorage.setItem('defaultCountry', defaultCountry);
+  }
+
+  getDefaultCountry () {
+    return window.localStorage.getItem('defaultCountry');
+  }
+}
+
+const databaseManager = new DatabaseManager();
+export default databaseManager;

package/src/client/api/eventhandler.js

@@ -0,0 +1,278 @@
+import {
+  onCCPError,
+  onInitializationStateChange,
+  onRemoteStream,
+  onStateChange
+} from '../reducers/acReducer';
+
+import {
+  isCallbackMissed
+} from '../utils/acutils';
+
+import csioHandler from './csioHandler';
+import acManager from './acManager';
+import sessionManage from './sessionManager';
+import mediaManager from './mediaManager';
+
+// Outbound call = connection.isActive() && connection.isConnecting() && connection.getType() === 'outbound'
+// Incoming call = connection.isActive() && connection.isConnecting() && connection.getType() === 'inbound'
+// Connected = connection.isActive() && connection.isConnected() && isMultipartyCall() === false;
+// Joined = connection.isActive() && connection.isConnected() && isMultipartyCall();
+// Hold = connection.isActive() && connection.isOnHold()
+// Duration = connection.isActive() && connection.getState() && connection.getState().duration
+
+let currentAgent;
+let currentContact;
+let currentState;
+
+const knownAgentStates = ['Init', 'Default', 'Available', 'Offline', 'AfterCallWork', 'FailedConnectCustomer', 'FailedConnectAgent', 'Quality Issue', 'AgentHungUp'];
+const isError = (e) => {
+  if (e && e.errorType && e.errorMessage) {
+    return true;
+  }
+};
+
+const getAgentState = (e) => {
+  let { agent, newState } = e;
+  const currentAgentStates = sessionManage.getAgentStates();
+  // merge the known state and dynamic agent states
+  const agentStates = [ ...knownAgentStates, ...currentAgentStates.map(state => state.name) ];
+  if (!agentStates.includes(newState)) {
+    return undefined;
+  }
+  const duration = agent.getStateDuration();
+  if (isCallbackMissed(agent, newState)) {
+    newState = 'Callback missed';
+  }
+  return {
+    state: newState,
+    duration: duration,
+    agent: agent
+  };
+};
+
+// eslint-disable-next-line no-unused-vars
+const isMultipartyCall = (contact) => {
+  return !!((contact && contact.getActiveInitialConnection() && contact.getSingleActiveThirdPartyConnection()));
+};
+
+const isAgentError = (agent = undefined) => {
+  const agentState = agent && agent.getState();
+  return agentState && agentState.type === 'error';
+};
+const isOutbound = (connection) => {
+  return connection && connection.isActive() && connection.isConnected() === false &&
+        connection.isConnecting() === true && connection.getType() === 'outbound';
+};
+
+const isInbound = (connection) => {
+  return connection && connection.isActive() && connection.isConnected() &&
+        connection.getType() === 'inbound' &&
+        currentAgent.agent.getState().name === 'PendingBusy';
+};
+
+const isConnecting = (connection) => {
+  return connection && connection.isActive() && connection.isConnected() === false &&
+    connection.isConnecting() === true && connection.getType() === 'inbound' &&
+    currentAgent.agent.getState().name === 'CallingCustomer';
+};
+
+const isInboundCallback = (connection) => {
+  return connection && connection.isActive() && connection.isConnected() &&
+    connection.getType() === 'inbound' &&
+    currentAgent.agent.getState().name === 'Pending';
+};
+
+const isMissedCall = (connection) => {
+  return connection && connection.isActive() && connection.isConnected() &&
+        connection.getType() === 'inbound' &&
+        currentAgent.agent.getState().name === 'MissedCallAgent';
+};
+
+const isConnected = (connection) => {
+  return connection && connection.isActive() && connection.isConnected() &&
+        currentAgent.agent.getState().name === 'Busy';
+};
+
+const isJoined = (primaryConnectionState, thirdPartyConnectionState) => {
+  return primaryConnectionState && thirdPartyConnectionState &&
+        ['connected', 'Connected'].includes(primaryConnectionState.state) &&
+        primaryConnectionState.state === thirdPartyConnectionState.state;
+};
+
+const isHold = (connection) => {
+  return connection && connection.isActive() && connection.isOnHold();
+};
+
+const getStateDuration = (connection) => {
+  let duration = connection && connection.getStatusDuration();
+  return duration;
+};
+
+const getConnectionState = (contact = undefined, isPrimary = true) => {
+  const connection = isPrimary ? contact.getActiveInitialConnection() : contact.getSingleActiveThirdPartyConnection();
+  if (!connection) {
+    return undefined;
+  }
+  // console.warn('~', connection.isActive(), connection.isConnected(), connection.isConnecting(), connection.getType(), currentAgent.agent.getState());
+  let state;
+  if (isOutbound(connection)) {
+    state = 'Outbound call';
+  } else if (isInbound(connection)) {
+    state = 'Inbound call';
+  } else if (isMissedCall(connection)) {
+    state = 'Missed call';
+  } else if (isConnected(connection)) {
+    state = 'Connected';
+  } else if (isHold(connection)) {
+    state = 'On hold';
+  } else if (isInboundCallback(connection)) {
+    state = 'Callback incoming';
+  } else if (isConnecting(connection)) {
+    state = 'Connecting';
+  }
+
+  let duration = getStateDuration(connection);
+  return {
+    state: state,
+    duration: duration,
+    connection: connection
+  };
+};
+
+const mayBeUpdateToJoined = (primaryConnectionState = undefined, thirdPartyConnectionState = undefined) => {
+  if (isJoined(primaryConnectionState, thirdPartyConnectionState)) {
+    primaryConnectionState.state = 'Joined';
+    thirdPartyConnectionState.state = 'Joined';
+  }
+  return {
+    primaryConnectionState,
+    thirdPartyConnectionState
+  };
+};
+
+class EventHandler {
+  constructor () {
+    this.dispatch = undefined;
+  }
+
+  dispose () {
+    this.dispatch = undefined;
+  }
+
+  register (dispatch, connect) {
+    if (this.dispatch) {
+      this.dispose();
+    }
+    this.dispatch = dispatch;
+
+    if (connect && connect.core) {
+      let bus = connect.core.getEventBus();
+
+      bus.subscribe('<<all>>', e => {
+        if (isError(e)) {
+          this.dispatch(onCCPError({ ...e }));
+        }
+      });
+
+      // get the agent init to set logged in
+      bus.subscribe(connect.AgentEvents.INIT, (e) => {
+        // close the login window, since at this stage agent is already initialized
+        sessionManage.disposeLoginWindow();
+        acManager.setIsLoggedIn(true);
+        this.dispatch(onInitializationStateChange(true));
+      });
+
+      // handle shared worker terminated to set agent logged out
+      bus.subscribe(connect.EventType.TERMINATED, (e) => {
+        acManager.setIsLoggedIn(false);
+        window.location.reload();
+      });
+      bus.subscribe(connect.AgentEvents.ERROR, e => {
+        // console.warn('error', e);
+      });
+      bus.subscribe(connect.AgentEvents.STATE_CHANGE, e => {
+        currentAgent = e;
+        // console.warn('~agent state change ', getAgentState(e));
+        let payload = {
+          primaryConnectionState: getAgentState(e),
+          thirdPartyConnectionState: undefined
+        };
+        currentState = payload;
+        this.dispatch(onStateChange(payload));
+      });
+      bus.subscribe(connect.ContactEvents.REFRESH, e => {
+        currentContact = e;
+        const connection1 = getConnectionState(e, true);
+        const connection2 = getConnectionState(e, false);
+        const { primaryConnectionState, thirdPartyConnectionState } = mayBeUpdateToJoined(connection1, connection2);
+        // console.warn('~REFRESH', primaryConnectionState, thirdPartyConnectionState, isMultipartyCall(e));
+        // if there is a agent side error
+        // ignore checking connections
+        const parseAgentState = () => {
+          if (isAgentError(currentAgent.agent)) {
+            const agentState = getAgentState(currentAgent);
+            if (!agentState) {
+              return undefined;
+            }
+            let payload = {
+              primaryConnectionState: agentState,
+              thirdPartyConnectionState: undefined
+            };
+            return payload;
+          }
+          return undefined;
+        };
+        const parseConnectState = () => {
+          let payload = {
+            primaryConnectionState: primaryConnectionState,
+            thirdPartyConnectionState: thirdPartyConnectionState
+          };
+          if ((primaryConnectionState && primaryConnectionState.state) || (thirdPartyConnectionState && thirdPartyConnectionState.state)) {
+            return payload;
+          }
+          return undefined;
+        };
+
+        const parseRest = () => {
+          let payload = {
+            primaryConnectionState: getAgentState(currentAgent),
+            thirdPartyConnectionState: undefined
+          };
+          return payload;
+        };
+        let payload = parseAgentState() || parseConnectState() || parseRest();
+        currentState = payload;
+        this.dispatch(onStateChange(payload));
+      });
+      bus.subscribe(connect.ContactEvents.ENDED, () => {
+        currentContact = undefined;
+        mediaManager.setRemoteStream(undefined);
+      });
+      bus.subscribe(connect.ContactEvents.DESTROYED, () => {
+        currentContact = undefined;
+        mediaManager.setRemoteStream(undefined);
+      });
+      bus.subscribe(connect.ContactEvents.CONNECTED, e => {
+        const remoteStream = csioHandler.getRemoteStream();
+        if (remoteStream) {
+          this.dispatch(onRemoteStream(remoteStream));
+          mediaManager.setRemoteStream(remoteStream);
+        }
+        // send active device list
+        csioHandler.sendActiveDeviceList();
+      });
+    }
+  }
+
+  getCurrentContact () {
+    return currentContact;
+  }
+
+  getCurrentState () {
+    return currentState;
+  }
+}
+
+const eventHandler = new EventHandler();
+export default eventHandler;

package/src/client/api/feedbackHandler.js

@@ -0,0 +1,21 @@
+class FeedbackHandler {
+  constructor () {
+    this.feedbackRatings = 0;
+  }
+
+  showFeedbackReports () {
+    return this.feedbackRatings >= 1 && this.feedbackRatings <= 3;
+  }
+
+  updateFeedback (feedbackRatings = 0) {
+    this.feedbackRatings = feedbackRatings;
+    return this.feedbackRatings;
+  }
+
+  getFeedbackRatings () {
+    return this.feedbackRatings;
+  }
+}
+
+const feedbackHandler = new FeedbackHandler();
+export default feedbackHandler;