amazon-connect-reference-dialer 1.0.0 → 1.4.3

package/src/client/api/manager/agent.js

@@ -0,0 +1,203 @@
+import lo from 'lodash';
+
+export const getQuickConnectionList = (agent = undefined) => {
+  return new Promise((resolve, reject) => {
+    if (!agent) {
+      resolve([]);
+      return;
+    }
+    agent.getEndpoints(agent.getAllQueueARNs(),
+      {
+        success: data => {
+          let endpoints = data.endpoints || [];
+          let quickConnects = endpoints.filter(item => {
+            return item.type === 'phone_number';
+          });
+          resolve(quickConnects);
+        },
+        failure: _ => {
+          reject(new Error('failed to get quick connection list'));
+        }
+      }
+    );
+  });
+};
+
+export const getTransferConnList = (agent = undefined) => {
+  return new Promise((resolve, reject) => {
+    if (!agent) {
+      resolve([]);
+      return;
+    }
+
+    agent.getEndpoints(agent.getAllQueueARNs(),
+      {
+        success: data => {
+          let endpoints = data.endpoints || [];
+          resolve(endpoints);
+        },
+        failure: _ => {
+          reject(new Error('failed to get transfer connection list'));
+        }
+      }
+    );
+  });
+};
+
+export const getEndpointByPhone = (agent = undefined, phoneNumber = null) => {
+  return new Promise((resolve, reject) => {
+    if (!agent) {
+      reject(new Error('agent can not be undefined'));
+      return;
+    }
+    if (!phoneNumber) {
+      reject(new Error('phone number required'));
+      return;
+    }
+    phoneNumber = phoneNumber.replace(/\s/g, '');
+    let endpoint = connect.Endpoint.byPhoneNumber(phoneNumber);
+    resolve(endpoint);
+  });
+};
+
+export const dialNumber = (agent = undefined, phoneNumber = null) => {
+  return new Promise((resolve, reject) => {
+    if (!phoneNumber) {
+      reject(new Error('empty number'));
+      return;
+    }
+    if (!agent) {
+      reject(new Error('agent cannot be undefined'));
+      return;
+    }
+    const endpoint = connect.Endpoint.byPhoneNumber(phoneNumber);
+    agent.connect(endpoint, {
+      success: function () {
+        resolve('Successfully sent outbound call');
+      },
+      failure: function (err) {
+        reject(err);
+      }
+    });
+  });
+};
+
+export const mute = (agent = undefined) => {
+  if (agent) {
+    agent.mute();
+  }
+};
+
+export const unmute = (agent = undefined) => {
+  if (agent) {
+    agent.unmute();
+  }
+};
+
+export const setAgentState = (agent = undefined, agentState) => {
+  return new Promise((resolve, reject) => {
+    agentState && agent && agent.setState(agentState, {
+      success: (data) => {
+        resolve('success');
+      },
+      failure: (data) => {
+        reject(data);
+      }
+    });
+  });
+};
+
+export const getAgentDeskphoneNumber = (agent = undefined) => {
+  if (!agent) {
+    return '';
+  }
+  const agentConfig = agent.getConfiguration();
+  const extension = agentConfig && agentConfig.extension;
+  return extension;
+};
+
+export const isAgentSoftphoneEnabled = (agent = undefined) => {
+  if (!agent) {
+    return false;
+  }
+  const agentConfig = agent.getConfiguration();
+  const softphoneEnabled = agentConfig && agentConfig.softphoneEnabled;
+  return softphoneEnabled;
+};
+
+export const changeToSoftPhone = (agent = undefined) => {
+  return new Promise((resolve, reject) => {
+    if (!agent) {
+      reject(new Error('agent cannot be undefined'));
+      return;
+    }
+    let newConfig = agent && agent.getConfiguration();
+    newConfig.softphoneEnabled = true;
+    agent.setConfiguration(newConfig, {
+      success: function () {
+        resolve(newConfig);
+      },
+      failure: function () {
+        reject(new Error('Failed to change to softphone'));
+      }
+    });
+  });
+};
+
+export const changeToDeskphone = (agent = undefined, phoneNumber = null) => {
+  return new Promise((resolve, reject) => {
+    if (!phoneNumber) {
+      reject(new Error('empty number'));
+      return;
+    }
+    if (!agent) {
+      reject(new Error('agent cannot be undefined'));
+      return;
+    }
+    let newConfig = agent.getConfiguration();
+    newConfig.softphoneEnabled = false;
+    newConfig.extension = phoneNumber;
+    agent.setConfiguration(newConfig, {
+      success: function () {
+        resolve(newConfig);
+      },
+      failure: function () {
+        reject(new Error('Failed to change to hardphone'));
+      }
+    });
+  });
+};
+
+export const getDialableCountries = (agent = undefined) => {
+  if (!agent) {
+    return [];
+  }
+  let agentConfig = agent.getConfiguration();
+  const dialableCountries = agentConfig && agentConfig.dialableCountries;
+  return dialableCountries;
+};
+
+export const setAgentAvailable = (agent = undefined) => {
+  return new Promise((resolve, reject) => {
+    if (!agent) {
+      reject(new Error('agent cannot be undefined'));
+      return;
+    }
+    const agentState = agent.getAgentStates().find(item => item.name === 'Available');
+    agent && agent.setState(agentState, {
+      success: (data) => {
+        // console.warn('-> setAgentState', data);
+      },
+      failure: (data) => {
+        console.error('-> setAgentState', data);
+      }
+    });
+  });
+};
+
+export const getCallbackQueue = (agent = undefined) => {
+  if (!agent) {
+    return undefined;
+  }
+  return lo.first(agent.getContacts('queue_callback')) || undefined;
+};

package/src/client/api/manager/connection.js

@@ -0,0 +1,181 @@
+import lo from 'lodash';
+import {
+  toHMS
+} from './../../utils/acutils';
+
+export const holdConnection = (connection) => {
+  return new Promise((resolve, reject) => {
+    if (!connection) {
+      reject(new Error('connection is empty'));
+      return;
+    }
+    connection.hold({
+      success: function () {
+        resolve(null);
+      },
+      failure: function () {
+        reject(new Error('failed'));
+      }
+    });
+  });
+};
+
+export const resumeConnection = (connection) => {
+  return new Promise((resolve, reject) => {
+    if (!connection) {
+      reject(new Error('connection is empty'));
+      return;
+    }
+    connection.resume({
+      success: function () {
+        resolve(null);
+      },
+      failure: function () {
+        reject(new Error('failed'));
+      }
+    });
+  });
+};
+
+export const endConnection = (connection) => {
+  return new Promise((resolve, reject) => {
+    if (!connection) {
+      reject(new Error('connection is empty'));
+      return;
+    }
+    connection.destroy({
+      success: () => {
+        resolve('successfully close connection');
+      },
+      failure: (data) => {
+        reject(data);
+      }
+    });
+  });
+};
+
+export const getPrimaryAgentState = (currentState = undefined) => {
+  const state = lo.get(currentState, 'primaryConnectionState.state', 'none');
+  return state;
+};
+
+export const getPrimaryConnectionDuration = (currentState = undefined) => {
+  const primaryConnection = lo.get(currentState, 'primaryConnectionState', undefined);
+  if (!primaryConnection) {
+    return '00:00:00';
+  }
+  let duration = 0;
+  // if this is a agent
+  if (primaryConnection.agent) {
+    const queueCallbackConnection = lo.first(primaryConnection.agent.getContacts('queue_callback')) || undefined;
+    if (queueCallbackConnection) {
+      duration = typeof queueCallbackConnection.getStatusDuration === 'function' && queueCallbackConnection.getStatusDuration();
+    } else {
+      duration = typeof primaryConnection.agent.getStateDuration === 'function' && primaryConnection.agent.getStateDuration();
+    }
+  } else if (primaryConnection.connection) {
+    duration = typeof primaryConnection.connection.getStatusDuration === 'function' && primaryConnection.connection.getStatusDuration();
+  }
+  return toHMS(duration || 0);
+};
+
+export const getThirdPartyConnectionDuration = (currentState = undefined) => {
+  const thirdPartyConnection = lo.get(currentState, 'thirdPartyConnectionState', undefined);
+  if (!thirdPartyConnection) {
+    return '00:00:00';
+  }
+  let duration = 0;
+  if (thirdPartyConnection.connection) {
+    duration = typeof thirdPartyConnection.connection.getStatusDuration === 'function' && thirdPartyConnection.connection.getStatusDuration();
+  }
+  return toHMS(duration || 0);
+};
+
+// can be a phone or something else
+export const getPrimaryConnectionPhone = (currentState = undefined) => {
+  const primaryConnection = lo.get(currentState, 'primaryConnectionState', undefined);
+  const connection = primaryConnection && (primaryConnection.agent || primaryConnection.connection);
+  const address = connection && typeof connection.getAddress === 'function' && connection.getAddress();
+
+  let number = (address && address.phoneNumber) || '';
+  // don't show sip number
+  if (number.includes('sip')) {
+    return '';
+  } else {
+    return number;
+  }
+};
+
+export const getThirdPartyConnectionPhone = (currentState = undefined) => {
+  const thirdPartyConnection = lo.get(currentState, 'thirdPartyConnectionState', undefined);
+  const connection = thirdPartyConnection && thirdPartyConnection.connection;
+  const address = connection && typeof connection.getAddress === 'function' && connection.getAddress();
+
+  let number = (address && address.phoneNumber) || '';
+  // don't show sip number
+  if (number.includes('sip')) {
+    return '';
+  } else {
+    return number;
+  }
+};
+
+export const hangupPrimaryConnection = (currentState = undefined) => {
+  const primaryConnection = lo.get(currentState, 'primaryConnectionState', undefined);
+  const connection = primaryConnection.agent || primaryConnection.connection;
+  return new Promise((resolve, reject) => {
+    if (!connection) {
+      reject(new Error('connection is null'));
+      return;
+    }
+    connection.destroy({
+      success: () => {
+        resolve('successfully hangup primary connection');
+      },
+      failure: (data) => {
+        reject(data);
+      }
+    });
+  });
+};
+
+export const sendDigit = (activeConnection, currentDigit = -1) => {
+  if (currentDigit < 0) {
+    return Promise.resolve(null);
+  }
+  if (!['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '#', '*'].includes(currentDigit)) {
+    return Promise.resolve(null);
+  }
+
+  return new Promise((resolve, reject) => {
+    if (!activeConnection) {
+      return reject(new Error('connection is undefined'));
+    }
+    activeConnection.sendDigits(currentDigit, {
+      success: function (data) {
+        resolve(data);
+      },
+      failure: function (data) {
+        reject(data);
+      }
+    });
+  });
+};
+
+export const getPrimaryConnection = (currentState = undefined) => {
+  if (!currentState) {
+    return undefined;
+  }
+
+  const connection = lo.get(currentState, 'primaryConnectionState.connection', undefined);
+  return connection;
+};
+
+export const getThirdPartyConnection = (currentState = undefined) => {
+  if (!currentState) {
+    return undefined;
+  }
+
+  const connection = lo.get(currentState, 'thirdPartyConnectionState.connection', undefined);
+  return connection;
+};

package/src/client/api/manager/contact.js

@@ -0,0 +1,114 @@
+import { sleep } from './../../utils/acutils';
+
+export const isNeedToTransferCall = (contact = undefined) => {
+  return contact && contact.isConnected();
+};
+
+export const acceptCall = (contact = undefined) => {
+  return new Promise((resolve, reject) => {
+    if (!contact) {
+      reject(new Error('contact is null'));
+      return;
+    }
+    contact.accept({
+      success: () => {
+        resolve('accept call success');
+      },
+      failure: (data) => {
+        reject(data);
+      }
+    });
+  });
+};
+
+export const rejectCall = (contact = undefined) => {
+  return new Promise((resolve, reject) => {
+    if (!contact) {
+      reject(new Error('contact is null'));
+      return;
+    }
+    let agentConn = contact.getAgentConnection();
+    if (!agentConn) {
+      reject(new Error('agent connection is undefined'));
+    }
+    agentConn.destroy({
+      success: () => {
+        resolve('accept call success');
+      },
+      failure: (data) => {
+        reject(data);
+      }
+    });
+  });
+};
+
+export const dialContact = (contact = undefined, selectedContact = undefined) => {
+  return new Promise((resolve, reject) => {
+    if (!contact) {
+      reject(new Error('contact is undefined'));
+      return;
+    }
+    if (!selectedContact) {
+      reject(new Error('dialed selected contact is undefined'));
+      return;
+    }
+    contact.addConnection(selectedContact, {
+      success: function () {
+        resolve('successfully added new contact');
+      },
+      failure: function (err, data) {
+        reject(err);
+      }
+    });
+  });
+};
+
+export const resumeAll = (contact = undefined) => {
+  return new Promise((resolve, reject) => {
+    if (!contact) {
+      reject(new Error('contact is undefined'));
+      return;
+    }
+    contact.conferenceConnections({
+      success: (success) => {
+        resolve(success);
+      },
+      failure: (err) => {
+        reject(err);
+      }
+    });
+  });
+};
+
+export const holdAll = (hold, ...connections) => {
+  const holdConnections = async () => {
+    for (let currentConnection of connections) {
+      try {
+        if (currentConnection) {
+          await hold(currentConnection);
+          sleep(200);
+        }
+      } catch (err) {
+        console.error(err);
+      }
+    }
+  };
+  return holdConnections();
+};
+
+export const swapCall = (contact = undefined) => {
+  return new Promise((resolve, reject) => {
+    if (!contact) {
+      reject(new Error('contact is undefined'));
+      return;
+    }
+    contact.toggleActiveConnections({
+      success: (success) => {
+        resolve(success);
+      },
+      failure: (err) => {
+        reject(err);
+      }
+    });
+  });
+};

package/src/client/api/mediaManager.js

@@ -0,0 +1,138 @@
+import databaseManager from './databaseManager';
+
+const isDefault = (device = undefined, deviceList = []) => {
+  if (device && device.deviceId === 'default') {
+    return true;
+  }
+  if (device && device.label && device.label.includes('default')) {
+    return true;
+  }
+  if (deviceList.length === 1) {
+    return true;
+  }
+  return false;
+};
+
+class MediaManager {
+  constructor () {
+    this.localStream = undefined;
+    this.remoteStream = undefined;
+  }
+
+  async getDefaultAudioOutputDevice () {
+    const deviceList = await navigator.mediaDevices.enumerateDevices();
+    const defaultAudioDevice = deviceList.find(device => device.kind === 'audiooutput' && isDefault(device));
+    if (!defaultAudioDevice) {
+      return { deviceId: 'Browser default', kind: 'audiooutput', label: 'Browser default' };
+    }
+    return defaultAudioDevice;
+  }
+
+  /*
+        If there is a preferred audio device. return that one
+        otherwise return default audio device
+     */
+  async getDefaultOrPreferredAudioInputDevice () {
+    const deviceList = await navigator.mediaDevices.enumerateDevices();
+    let preferedDevice = this.getPreferedAudioInputDevice();
+
+    // if preferred device is found in the device list
+    // there can be cases where user removed the prefered device from list, and the preffered is no longer available
+    let found = preferedDevice && deviceList.find(device => device.kind === preferedDevice.kind && device.deviceId === preferedDevice.deviceId);
+    if (found) {
+      return preferedDevice;
+    }
+    let inputdevideList = deviceList.filter(device => device.kind === 'audioinput');
+    let defaultAudioDevice = inputdevideList.find(device => device.kind === 'audioinput' && isDefault(device, inputdevideList));
+    return defaultAudioDevice;
+  }
+
+  async getInputDeviceList () {
+    const deviceList = await navigator.mediaDevices.enumerateDevices();
+    const inputDeviceList = deviceList.filter(device => device.kind === 'audioinput');
+    return inputDeviceList;
+  }
+
+  async getDefaultAudioInputAndOutputDeviceDetails () {
+    const inputDevice = await this.getDefaultOrPreferredAudioInputDevice();
+    const outputDevice = await this.getDefaultAudioOutputDevice();
+    const inputDeviceList = await this.getInputDeviceList();
+
+    // console.warn('~getInputDeviceList', inputDevice, outputDevice, inputDeviceList);
+    return { inputDevice, outputDevice, inputDeviceList };
+  }
+
+  // save it in current window, and also in database
+  setPreferedAudioInputDevice (selectedDevice = undefined) {
+    window.selectedDevice = { ...selectedDevice };
+    selectedDevice && databaseManager.saveDefaultDevice(selectedDevice);
+  }
+
+  getPreferedAudioInputDevice () {
+    const selectedDevice = databaseManager.getSelectedAudioDevice();
+    return selectedDevice && JSON.parse(selectedDevice);
+  }
+
+  // Overwrite get user media
+  overWriteGetUserMedia () {
+    if (!(navigator && navigator.mediaDevices && typeof navigator.mediaDevices.getUserMedia === 'function')) {
+      return;
+    }
+
+    let original = navigator.mediaDevices.getUserMedia.bind(navigator.mediaDevices);
+    navigator.mediaDevices.getUserMedia = function (constraints) {
+      const newConstraints = {
+        audio: { deviceId: window.selectedDevice && window.selectedDevice.deviceId },
+        video: false
+      };
+      return original(newConstraints);
+    };
+  }
+
+  async getUserMedia (selectedDevice = undefined) {
+    const audioDeviceId = (selectedDevice && selectedDevice.deviceId) || undefined;
+    const constraints = {
+      audio: { deviceId: audioDeviceId },
+      video: false
+    };
+    this.dispose();
+
+    return new Promise((resolve, reject) => {
+      navigator.getUserMedia(constraints, stream => {
+        this.localStream = stream;
+        resolve(this.localStream);
+      }, err => {
+        reject(err);
+      });
+    });
+  }
+
+  setLocalStream (stream) {
+    this.localStream = stream;
+  }
+
+  setRemoteStream (stream) {
+    this.remoteStream = stream;
+  }
+
+  getLocalStream () {
+    return this.localStream;
+  }
+
+  getRemoteStream () {
+    return this.remoteStream;
+  }
+
+  // make sure we dispose local stream
+  dispose () {
+    if (this.localStream) {
+      this.localStream.getTracks().forEach(track => {
+        track.stop();
+      });
+      this.localStream = undefined;
+    }
+  }
+}
+
+const mediaManager = new MediaManager();
+export default mediaManager;

package/src/client/api/networkStrengthMonitor.js

@@ -0,0 +1,64 @@
+import {
+  qualityAsString,
+  getQuality
+} from './../configs/consts';
+
+const HASH = 10000009;
+const getRandom = () => {
+  return Math.round(Math.random() * HASH);
+};
+
+class NetworkStrengthMonitor {
+  constructor () {
+    this.hash = getRandom();
+    this.hashLastPulled = getRandom();
+    this.consicutiveMissCount = 0;
+    this.curBitrate = -1;
+    this.curFractionalLoss = -1;
+    this.curRTT = -1;
+    this.consicutiveZero = false;
+  }
+
+  addThroughput (outboundBitrate = 0, inboundBitrate = 0) {
+    // this.hash = getRandom();
+    // let totalTraffic = (outboundBitrate + inboundBitrate) / 2;
+    //
+    // if (totalTraffic < 1 && this.consicutiveZero < 2) {
+    //   return;
+    // }
+    // console.warn('->addThroughput', outboundBitrate, inboundBitrate);
+    // outboundBitrate = checkForPositiveValue(outboundBitrate) ? outboundBitrate : 0;
+    // inboundBitrate = checkForPositiveValue(inboundBitrate) ? inboundBitrate : 0;
+
+    let avgBitrate = (outboundBitrate + inboundBitrate) / 2;
+    this.curBitrate = avgBitrate;
+  }
+
+  addRTT (outboundRTT = 0, inboundRTT = 0) {
+    // outboundRTT = checkForPositiveValue(outboundRTT) ? outboundRTT : 102
+    // inboundRTT = checkForPositiveValue(inboundRTT) ? inboundRTT : 1024;
+
+    let avgRTT = (outboundRTT + inboundRTT) / 2;
+    this.curRTT = avgRTT;
+  }
+
+  addFractionalLoss (outboundFL = 0, inboundFL = 0) {
+    // outboundFL = checkForPositiveValue(outboundFL) ? outboundFL : 1;
+    // inboundFL = checkForPositiveValue(inboundFL) ? inboundFL : 1;
+    let avgFL = (outboundFL + inboundFL) / 2;
+    this.curFractionalLoss = avgFL;
+  }
+
+  getNetworkStrength () {
+    return getQuality(this.curBitrate, this.curRTT, this.curFractionalLoss);
+    // return throughputThreshold(this.curBitrate);
+  }
+
+  getNetworkStrengthAsString () {
+    const networkStrength = this.getNetworkStrength();
+    return qualityAsString(networkStrength);
+  }
+}
+
+const networkStrengthMonitor = new NetworkStrengthMonitor();
+export default networkStrengthMonitor;