amazon-connect-reference-dialer 1.0.0 → 1.4.3

package/src/client/api/precalltest.js

@@ -0,0 +1,37 @@
+import csioHandler from './csioHandler';
+
+const PCT_INTERVAL_MS = 1 * 60 * 1000; // Every two minutes
+// const PCT_INTERVAL_MS = 15 * 1000; // Every two minutes
+
+class PrecallTest {
+  constructor () {
+    this.inProgress = false;
+    this.lastRuntimeInMs = 0;
+  }
+
+  shouldRun () {
+    let now = (new Date()).getTime();
+    if (now - this.lastRuntimeInMs < PCT_INTERVAL_MS) {
+      return false;
+    }
+    if (this.inProgress) {
+      return false;
+    }
+    return true;
+  }
+
+  async doPrecallTest () {
+    this.inProgress = true;
+    try {
+      // console.warn('doPrecallTest');
+      await csioHandler.doPrecallTest();
+    } catch (err) {
+      console.warn('->', err);
+    }
+    this.inProgress = false;
+    this.lastRuntimeInMs = (new Date()).getTime();
+  }
+}
+
+const precallTest = new PrecallTest();
+export default precallTest;

package/src/client/api/sessionManager.js

@@ -0,0 +1,312 @@
+import agentHandler from './agentHandler';
+import acManager from './acManager';
+import libphonenumber from 'google-libphonenumber';
+
+import {
+  dialNumber,
+  getQuickConnectionList,
+  getTransferConnList,
+  mute,
+  unmute,
+  setAgentState,
+  getAgentDeskphoneNumber,
+  isAgentSoftphoneEnabled,
+  changeToSoftPhone,
+  changeToDeskphone,
+  getDialableCountries,
+  setAgentAvailable,
+  getEndpointByPhone,
+  getCallbackQueue
+} from './manager/agent';
+
+import {
+  isNeedToTransferCall,
+  acceptCall,
+  rejectCall,
+  dialContact,
+  holdAll,
+  resumeAll,
+  swapCall
+} from './manager/contact';
+
+import {
+  holdConnection,
+  resumeConnection,
+  getPrimaryAgentState,
+  getPrimaryConnectionDuration,
+  getThirdPartyConnectionDuration,
+  getPrimaryConnectionPhone,
+  getThirdPartyConnectionPhone,
+  hangupPrimaryConnection,
+  getPrimaryConnection,
+  getThirdPartyConnection,
+  endConnection,
+  sendDigit
+} from './manager/connection';
+import lo from 'lodash';
+
+class SessionManager {
+  constructor () {
+    this.phoneUtil = libphonenumber.PhoneNumberUtil.getInstance();
+    this.PNF = libphonenumber.PhoneNumberFormat;
+    this.lastStateAsString = null;
+  }
+
+  isNeedToTransferCall () {
+    const contact = acManager.getCurrentContact();
+    return isNeedToTransferCall(contact);
+  }
+
+  // it can be simply just dialing a number
+  // or can be a transfer call to another number
+  dialNumber (phoneNumber = null) {
+    if (!this.isNeedToTransferCall()) {
+      // simply dial the number
+      const agent = agentHandler.getAgent();
+      return dialNumber(agent, phoneNumber);
+    } else {
+      // get the contact (endpoint) by phone number, and transfer it
+      // by using addConnection method of contact using dialContact wrapper
+      const agent = agentHandler.getAgent();
+      return getEndpointByPhone(agent, phoneNumber).then(endpoint => {
+        const currentContact = acManager.getCurrentContact();
+        return dialContact(currentContact, endpoint);
+      }).catch(err => {
+        return new Promise((resolve, reject) => {
+          reject(err);
+        });
+      });
+    }
+  }
+
+  getQuickConnectionList () {
+    const agent = agentHandler.getAgent();
+    return getQuickConnectionList(agent);
+  }
+
+  getTransferConnList () {
+    const agent = agentHandler.getAgent();
+    return getTransferConnList(agent);
+  }
+
+  mute () {
+    const agent = agentHandler.getAgent();
+    return mute(agent);
+  }
+
+  unmute () {
+    const agent = agentHandler.getAgent();
+    return unmute(agent);
+  }
+
+  holdConnection (connection = undefined) {
+    return holdConnection(connection);
+  }
+
+  resumeConnection (connection = undefined) {
+    return resumeConnection(connection);
+  }
+
+  endConnection (connection = undefined) {
+    return endConnection(connection);
+  }
+
+  getPrimaryAgentState () {
+    const currentState = acManager.getCurrentState();
+    return getPrimaryAgentState(currentState);
+  }
+
+  getPrimaryConnectionDuration () {
+    const currentState = acManager.getCurrentState();
+    return getPrimaryConnectionDuration(currentState);
+  }
+
+  getThirdPartyConnectionDuration () {
+    const currentState = acManager.getCurrentState();
+    return getThirdPartyConnectionDuration(currentState);
+  }
+
+  getPrimaryConnectionPhone () {
+    const currentState = acManager.getCurrentState();
+    const phoneNumber = getPrimaryConnectionPhone(currentState);
+    if (phoneNumber && phoneNumber.length > 0) {
+      try {
+        const temp = this.phoneUtil.parse(phoneNumber, '');
+        const formatPhoneNumber = this.phoneUtil.format(temp, this.PNF.INTERNATIONAL);
+        return formatPhoneNumber;
+      } catch (err) {
+        console.warn('~', phoneNumber, err && err.message);
+        return phoneNumber;
+      }
+    } else {
+      return phoneNumber;
+    }
+  }
+
+  getThirdPartyConnectionPhone () {
+    const currentState = acManager.getCurrentState();
+    const phoneNumber = getThirdPartyConnectionPhone(currentState);
+    if (phoneNumber && phoneNumber.length > 0) {
+      try {
+        const temp = this.phoneUtil.parse(phoneNumber, '');
+        const formatPhoneNumber = this.phoneUtil.format(temp, this.PNF.INTERNATIONAL);
+        return formatPhoneNumber;
+      } catch (err) {
+        console.warn('~', phoneNumber, err && err.message);
+        return phoneNumber;
+      }
+    } else {
+      return phoneNumber;
+    }
+  }
+
+  getAgentStates () {
+    const agent = agentHandler.getAgent();
+    return agent.getAgentStates() || [];
+  }
+
+  setAgentState (agentState = undefined) {
+    let agent = agentHandler.getAgent();
+    return setAgentState(agent, agentState);
+  }
+
+  getAgentDeskphoneNumber () {
+    let agent = agentHandler.getAgent();
+    return getAgentDeskphoneNumber(agent);
+  }
+
+  isAgentSoftphoneEnabled () {
+    let agent = agentHandler.getAgent();
+    return isAgentSoftphoneEnabled(agent);
+  }
+
+  changeToSoftPhone () {
+    let agent = agentHandler.getAgent();
+    return changeToSoftPhone(agent);
+  }
+
+  changeToDeskphone (phoneNumber = null) {
+    let agent = agentHandler.getAgent();
+    return changeToDeskphone(agent, phoneNumber);
+  }
+
+  getDialableCountries () {
+    let agent = agentHandler.getAgent();
+    return getDialableCountries(agent);
+  }
+
+  setAgentAvailable () {
+    let agent = agentHandler.getAgent();
+    return setAgentAvailable(agent);
+  }
+
+  hangupPrimaryConnection () {
+    const currentState = acManager.getCurrentState();
+    return hangupPrimaryConnection(currentState);
+  }
+
+  acceptCall () {
+    const currentContact = acManager.getCurrentContact();
+    return acceptCall(currentContact);
+  }
+
+  rejectCall () {
+    const currentContact = acManager.getCurrentContact();
+    return rejectCall(currentContact);
+  }
+
+  // hangup contact, and reject are basically same
+  hangupContact () {
+    const currentContact = acManager.getCurrentContact();
+    return rejectCall(currentContact);
+  }
+
+  dialContact (selectedContact = undefined) {
+    const currentContact = acManager.getCurrentContact();
+    return dialContact(currentContact, selectedContact);
+  }
+
+  holdAll () {
+    const currentState = acManager.getCurrentState();
+    const primaryConnection = getPrimaryConnection(currentState);
+    const thirdPartyConnection = getThirdPartyConnection(currentState);
+    return holdAll(holdConnection, primaryConnection, thirdPartyConnection);
+  }
+
+  resumeAll () {
+    const currentContact = acManager.getCurrentContact();
+    return resumeAll(currentContact);
+  }
+
+  swapCall () {
+    const currentContact = acManager.getCurrentContact();
+    return swapCall(currentContact);
+  }
+
+  getPrimaryConnection () {
+    const currentState = acManager.getCurrentState();
+    return getPrimaryConnection(currentState);
+  }
+
+  getThirdPartyConnection () {
+    const currentState = acManager.getCurrentState();
+    return getThirdPartyConnection(currentState);
+  }
+
+  isConference (currentState = undefined) {
+    return currentState && currentState.primaryConnectionState && currentState.thirdPartyConnectionState;
+  }
+
+  isOnlyPrimary (currentState = undefined) {
+    return currentState && currentState.primaryConnectionState && !currentState.thirdPartyConnectionState;
+  }
+
+  getCurrentStateString (currentState = undefined, isPrimary = true) {
+    const stateAsString = lo.get(currentState,
+      isPrimary ? 'primaryConnectionState.state' : 'thirdPartyConnectionState.state', this.lastStateAsString);
+    this.lastStateAsString = stateAsString;
+    return stateAsString;
+  }
+
+  isActive (currentState = undefined) {
+    const primaryConnection = this.getPrimaryConnection();
+    const thirdParyConnection = this.getThirdPartyConnection();
+
+    return (primaryConnection && primaryConnection.isActive()) || (thirdParyConnection && thirdParyConnection.isActive());
+  }
+
+  sendDigit (currentDigit = null) {
+    const primaryConnection = this.getPrimaryConnection();
+    const thirdParyConnection = this.getThirdPartyConnection();
+    // if primary connection is active
+    if (primaryConnection && primaryConnection.isActive()) {
+      return sendDigit(primaryConnection, currentDigit);
+    } else if (thirdParyConnection && thirdParyConnection.isActive()) {
+      return sendDigit(thirdParyConnection, currentDigit);
+    } else {
+      return Promise.reject(new Error('no active connection'));
+    }
+  }
+
+  setLoginWindow (loginWindow = undefined) {
+    // current it is disposed when initialized is success from agentHandler
+    agentHandler.setLoginWindow(loginWindow);
+  }
+
+  // not calling from anywhere for now
+  disposeLoginWindow () {
+    agentHandler.disposeLoginWindow();
+  }
+
+  getIsLoggedIn () {
+    return acManager.getIsLoggedIn();
+  }
+
+  getCallbackQueue () {
+    const agent = agentHandler.getAgent();
+    return getCallbackQueue(agent);
+  }
+}
+
+const sessionManage = new SessionManager();
+export default sessionManage;

package/src/client/configs/consts.js

@@ -0,0 +1,158 @@
+// eslint-disable-next-line no-unused-vars
+
+export function checkForNan (value) {
+  return isNaN(value) ? null : value;
+}
+
+export function isNaNOrUndefined (value) {
+  return value !== undefined && checkForNan(value) !== null;
+}
+
+const qualityRating = {
+  excellent: 5,
+  good: 4,
+  fair: 3,
+  poor: 2,
+  bad: 1
+};
+
+/* const MAX_VALUE = 1023456789;
+const throughputthreshold = [
+  { threshold: 8, qualityRating: 1 },
+  { threshold: 15, qualityRating: 2 },
+  { threshold: 25, qualityRating: 3 },
+  { threshold: 30, qualityRating: 4 },
+  { threshold: MAX_VALUE, qualityRating: 5 }
+]; */
+
+export const qualityAsString = (nextworkStrength) => {
+  switch (nextworkStrength) {
+    case -1:
+      return 'loading';
+    case 1:
+      return 'bad';
+    case 2:
+      return 'poor';
+    case 3:
+      return 'fair';
+    case 4:
+      return 'good';
+    case 5:
+      return 'excellent';
+  }
+  return 'Unknown';
+};
+
+export const throughputThreshold2 = {
+  audio: {
+    green: 30,
+    red: 8
+  }
+};
+
+export const rttThreshold = {
+  audio: {
+    green: 400,
+    red: 1000
+  }
+};
+
+export const fractionalLossThreshold = {
+  audio: {
+    green: 0.15,
+    red: 0.30
+  }
+};
+
+export const avQualityRatings = {
+  excellent: 'excellent',
+  fair: 'fair',
+  bad: 'bad',
+  unknown: 'unknown'
+};
+
+export function getDescendentRating (value, thresholds) {
+  if (thresholds.green <= value) {
+    return avQualityRatings.excellent;
+  }
+  if (thresholds.red < value) {
+    return avQualityRatings.fair;
+  }
+  return avQualityRatings.bad;
+}
+
+export function getAscendingRating (value, thresholds) {
+  let result;
+  if (thresholds.red < value) {
+    result = avQualityRatings.bad;
+  } else if (thresholds.green <= value) {
+    result = avQualityRatings.fair;
+  } else {
+    result = avQualityRatings.excellent;
+  }
+  return result;
+}
+
+export function fromQualityString (qualityString = avQualityRatings.unknown) {
+  switch (qualityString) {
+    case avQualityRatings.bad:
+      return qualityRating.bad;
+    case avQualityRatings.fair:
+      return qualityRating.fair;
+    case avQualityRatings.excellent:
+      return qualityRating.excellent;
+  }
+  return 0;
+}
+
+export function toQualityString (_qualityRating = qualityRating.excellent) {
+  switch (_qualityRating) {
+    case qualityRating.excellent:
+      return avQualityRatings.excellent;
+    case qualityRating.good:
+      return avQualityRatings.fair;
+    case qualityRating.fair:
+      return avQualityRatings.fair;
+    case qualityRating.poor:
+      return avQualityRatings.fair;
+    case qualityRating.bad:
+      return avQualityRatings.bad;
+  }
+  return avQualityRatings.unknown;
+}
+
+function getOverallTrackQuality (qualities = []) {
+  let totalWeight = 0;
+  let result = 0;
+  for (let i = 0, len = qualities.length; i < len; i += 1) {
+    let curQuality = qualities[i];
+    totalWeight += curQuality.weight;
+  }
+  for (let i = 0, len = qualities.length; i < len; i += 1) {
+    let curQuality = qualities[i];
+    result += (curQuality.result * curQuality.weight) / Math.max(totalWeight, 1);
+  }
+  result = Math.floor(result);
+  // let qualityString = this.toQualityString(result);
+  return result;
+}
+
+export function getQuality (bitrate, rtt, fl) {
+  let bitrateQualityRating = getDescendentRating(bitrate, throughputThreshold2.audio);
+  let rttQualityRating = getAscendingRating(rtt, rttThreshold.audio);
+  let flQualityRating = getAscendingRating(fl, fractionalLossThreshold.audio);
+
+  let qualities = [];
+  if (!isNaNOrUndefined(bitrateQualityRating)) {
+    qualities.push({ result: fromQualityString(bitrateQualityRating), weight: 1 });
+  }
+  if (!isNaNOrUndefined(rttQualityRating)) {
+    qualities.push({ result: fromQualityString(rttQualityRating), weight: 1 });
+  }
+  if (!isNaNOrUndefined(flQualityRating)) {
+    qualities.push({ result: fromQualityString(flQualityRating), weight: 1 });
+  }
+
+  // console.warn('-> ', bitrate, rtt, fl, qualities);
+  return getOverallTrackQuality(qualities);
+}

package/src/client/container/agentduration/duration.js

@@ -0,0 +1,63 @@
+import React, { Component } from 'react';
+import sessionManager from './../../api/sessionManager';
+import PropTypes from 'prop-types';
+
+const DURATION_MS = 1 * 1000;
+
+const durationCSS = {
+  div: 'col-4 align-self-center text-right',
+  p: 'm-0',
+  pStyle: {
+    fontFamily: 'AmazonEmber',
+    color: '#ffffff',
+    fontSize: '14px'
+  }
+};
+
+// Will show the duration of current agent state duration
+// todo might need to update for conference
+class Duration extends Component {
+  constructor (props) {
+    super(props);
+    this.intervalId = undefined;
+    this.state = {
+      duration: '00:00:00'
+    };
+  }
+
+  _dispose () {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+    }
+  }
+
+  componentDidMount () {
+    this._dispose();
+    this.intervalId = setInterval(() => {
+      let duration = this.props.isPrimary ? sessionManager.getPrimaryConnectionDuration() : sessionManager.getThirdPartyConnectionDuration();
+      this.setState({
+        duration: duration
+      });
+    }, DURATION_MS);
+  }
+
+  componentWillUnmount () {
+    this._dispose();
+  }
+
+  render () {
+    return (
+      <div className={durationCSS.div}>
+        <p className={durationCSS.p}
+				   style={durationCSS.pStyle}>{this.state.duration}</p>
+      </div>
+    );
+  }
+}
+
+Duration.propTypes = {
+  currentState: PropTypes.string,
+  isPrimary: PropTypes.bool.isRequired
+};
+
+export default Duration;

package/src/client/container/agentduration/index.js

@@ -0,0 +1,3 @@
+import Duration from './duration';
+
+export default Duration;

package/src/client/container/agentview/conferenceconnection/agentview.css

@@ -0,0 +1,100 @@
+.buttonCommon {
+    cursor: pointer;
+    width: 132px;
+    height: 36px;
+    box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.2);
+    background-color: #ffffff;
+    color: #000000;
+    font-family: AmazonEmber;
+    font-size: 14px;
+    border-radius: 0 !important;
+
+}
+
+.toggleMute {
+    width: 132px;
+    height: 36px;
+    box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.2);
+    background-color: #ffffff;
+    color: #000000;
+    font-family: AmazonEmber;
+    font-size: 14px;
+    border-radius: 0 !important;
+}
+
+.quickConnectOrTransfer {
+    width: 132px;
+    height: 36px;
+    box-shadow: 0 2px 4px 0 rgba(0, 0, 0, 0.2);
+    background-color: #ffffff;
+    color: #000000;
+    font-family: AmazonEmber;
+    font-size: 14px;
+    border-radius: 0 !important;
+}
+
+.agentStateDiv {
+    max-height: 0em;
+}
+
+.agentState {
+    font-family: AmazonEmber-light;
+    color: #ffffff;
+    font-size: 26px;
+}
+
+.agentStateMini {
+    font-family: AmazonEmber-light;
+    color: #ffffff;
+    font-size: 26px;
+}
+
+.phoneAndDurationMini {
+    font-family: AmazonEmber;
+    color: #ffffff;
+    font-size: 14px;
+}
+
+.agentMutedState {
+    /*max-height: 0em;*/
+}
+
+.agentMutedText {
+    font-family: AmazonEmber;
+    color: #ffffff;
+    font-size: 12px;
+}
+
+.agentMutedSpan {
+    margin-left: 2%;
+}
+
+.agentMutedIcon {
+    margin-top: -1%;
+}
+
+.peerAndAgentDurationText {
+    font-family: AmazonEmber;
+    color: #ffffff;
+    font-size: 14px;
+}
+
+.miniHoldResume {
+    background-size: 24px 24px;
+    width: 24px;
+    height: 24px;
+    /*margin-left: 7%;*/
+
+    margin-right: 5% !important;
+    margin-top: 10% !important;
+    cursor: pointer;
+}
+
+.miniEnd {
+    background-size: 24px 24px;
+    width: 24px;
+    height: 24px;
+    /*margin-left: 5% !important;*/
+    cursor: pointer;
+    margin-top: 10% !important;
+}

package/src/client/container/agentview/conferenceconnection/components/bothhold.js

@@ -0,0 +1,20 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+
+import MuteUnmute from './togglemute';
+import ResumeAll from './resumeall';
+
+const BothHoldView = ({ muted = false, toggleMuteUnmute, resumeAll }) => (
+  <div className={`row mt-3`}>
+    <ResumeAll resumeAll={resumeAll}/>
+    <MuteUnmute muted={muted} toggleMuteUnmute={toggleMuteUnmute}/>
+  </div>
+);
+
+BothHoldView.propTypes = {
+  muted: PropTypes.bool,
+  toggleMuteUnmute: PropTypes.func,
+  resumeAll: PropTypes.func
+};
+
+export default BothHoldView;