@webex/calling 3.11.0 → 3.12.0

package/dist/CallHistory/CallHistory.js

@@ -0,0 +1,596 @@
+"use strict";
+
+var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+var _Object$keys = require("@babel/runtime-corejs2/core-js/object/keys");
+var _Object$getOwnPropertySymbols = require("@babel/runtime-corejs2/core-js/object/get-own-property-symbols");
+var _Object$getOwnPropertyDescriptor = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptor");
+var _Object$getOwnPropertyDescriptors = require("@babel/runtime-corejs2/core-js/object/get-own-property-descriptors");
+var _Object$defineProperties = require("@babel/runtime-corejs2/core-js/object/define-properties");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCallHistoryClient = exports.CallHistory = void 0;
+var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
+var _stringify = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/json/stringify"));
+var _isNan = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/number/is-nan"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _SDKConnector = _interopRequireDefault(require("../SDKConnector"));
+var _types = require("../common/types");
+var _Logger = _interopRequireDefault(require("../Logger"));
+var _Utils = require("../common/Utils");
+var _constants = require("./constants");
+var _constants2 = require("../common/constants");
+var _types2 = require("../Events/types");
+var _impl = require("../Events/impl");
+function ownKeys(e, r) { var t = _Object$keys(e); if (_Object$getOwnPropertySymbols) { var o = _Object$getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return _Object$getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : _Object$getOwnPropertyDescriptors ? _Object$defineProperties(e, _Object$getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { _Object$defineProperty(e, r, _Object$getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? _Reflect$construct(o, e || [], (0, _getPrototypeOf2.default)(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); } /* eslint-disable dot-notation */ /* eslint-disable no-underscore-dangle */
+/**
+ * `CallHistory` module is designed to facilitate the retrieval of Call History Records by providing a set of APIs.
+ *
+ * This code snippet demonstrates how to create an instance of `CallHistory` using webex and logger.
+ *
+ * @example
+ * ```javascript
+ * const callHistory = createCallHistoryClient(webex, logger);
+ * ```
+ */
+var CallHistory = exports.CallHistory = /*#__PURE__*/function (_Eventing) {
+  /**
+   * @ignore
+   */
+  function CallHistory(webex, logger) {
+    var _this$webex$internal$;
+    var _this;
+    (0, _classCallCheck2.default)(this, CallHistory);
+    _this = _callSuper(this, CallHistory);
+    (0, _defineProperty2.default)(_this, "sdkConnector", void 0);
+    (0, _defineProperty2.default)(_this, "webex", void 0);
+    (0, _defineProperty2.default)(_this, "janusUrl", '');
+    (0, _defineProperty2.default)(_this, "fromDate", '');
+    (0, _defineProperty2.default)(_this, "loggerContext", {
+      file: _constants.CALL_HISTORY_FILE,
+      method: _constants.METHODS.GET_CALL_HISTORY_DATA
+    });
+    (0, _defineProperty2.default)(_this, "userSessions", void 0);
+    (0, _defineProperty2.default)(_this, "handleSessionEvents", /*#__PURE__*/function () {
+      var _ref = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee(event) {
+        return _regenerator.default.wrap(function (_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (event && event.data.userSessions.userSessions) {
+                _this.emit(_types2.COMMON_EVENT_KEYS.CALL_HISTORY_USER_SESSION_INFO, event);
+              }
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+    (0, _defineProperty2.default)(_this, "handleUserReadSessionEvents", /*#__PURE__*/function () {
+      var _ref2 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2(event) {
+        return _regenerator.default.wrap(function (_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (event && event.data.userReadSessions.userReadSessions) {
+                _this.emit(_types2.COMMON_EVENT_KEYS.CALL_HISTORY_USER_VIEWED_SESSIONS, event);
+              }
+            case 1:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      return function (_x2) {
+        return _ref2.apply(this, arguments);
+      };
+    }());
+    (0, _defineProperty2.default)(_this, "handleUserSessionsDeletedEvents", /*#__PURE__*/function () {
+      var _ref3 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee3(event) {
+        return _regenerator.default.wrap(function (_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              if (event && event.data.deletedSessions) {
+                _this.emit(_types2.COMMON_EVENT_KEYS.CALL_HISTORY_USER_SESSIONS_DELETED, event);
+              }
+            case 1:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      return function (_x3) {
+        return _ref3.apply(this, arguments);
+      };
+    }());
+    _this.sdkConnector = _SDKConnector.default;
+    if (!_this.sdkConnector.getWebex()) {
+      _SDKConnector.default.setWebex(webex);
+    }
+    _this.webex = _this.sdkConnector.getWebex();
+    _this.janusUrl = ((_this$webex$internal$ = _this.webex.internal.services._serviceUrls) === null || _this$webex$internal$ === void 0 ? void 0 : _this$webex$internal$.janus) || _this.webex.internal.services.get(_this.webex.internal.services._activeServices.janus);
+    _this.registerSessionsListener();
+    _Logger.default.setLogger(logger.level, _constants.CALL_HISTORY_FILE);
+    return _this;
+  }
+
+  /**
+   * Function to display the Janus API response.
+   * @param days - Number of days to fetch the call history data.
+   * @param limit - Number of records to be fetched.
+   * @param sort - Sort the records in ascending or descending order.
+   * @param sortBy - Sort the records by start time or end time.
+   */
+  (0, _inherits2.default)(CallHistory, _Eventing);
+  return (0, _createClass2.default)(CallHistory, [{
+    key: "getCallHistoryData",
+    value: (function () {
+      var _getCallHistoryData = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee4() {
+        var days,
+          limit,
+          sort,
+          sortBy,
+          date,
+          callingBackend,
+          sortByParam,
+          sortParam,
+          sharedSessionsParam,
+          url,
+          _janusResponse$header,
+          janusResponse,
+          hasCucmDN,
+          _ucmLinesResponse$dat,
+          ucmLinesResponse,
+          ucmLinesData,
+          responseDetails,
+          errorInfo,
+          errorStatus,
+          _args4 = arguments,
+          _t,
+          _t2;
+        return _regenerator.default.wrap(function (_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              days = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : _constants.NUMBER_OF_DAYS;
+              limit = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : _constants.LIMIT;
+              sort = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : _types.SORT.DEFAULT;
+              sortBy = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : _types.SORT_BY.DEFAULT;
+              /*
+                1. Mandatory field for Janus API - fromDate
+                2. Calculating the fromDate by deducting the NUMBER_OF_DAYS with the current date
+               */
+              date = new Date();
+              callingBackend = (0, _Utils.getCallingBackEnd)(this.webex);
+              date.setDate(date.getDate() - days);
+              this.fromDate = date.toISOString();
+              sortByParam = (0, _values.default)(_types.SORT_BY).includes(sortBy) ? sortBy : _types.SORT_BY.DEFAULT;
+              sortParam = (0, _values.default)(_types.SORT).includes(sort) ? sort : _types.SORT.DEFAULT;
+              _Logger.default.info("".concat(_constants2.METHOD_START_MESSAGE, " with days=").concat(days, ", limit=").concat(limit, ", sort=").concat(sortParam, ", sortBy=").concat(sortByParam), this.loggerContext);
+              _Logger.default.info("Janus API URL: ".concat(this.janusUrl), this.loggerContext);
+              _Logger.default.info("Call history from date : ".concat(this.fromDate), this.loggerContext);
+
+              // Add includeSharedSessions=true parameter for WXC backend to fetch calls with sessionType "WEBEXCALLING_SHARED"
+              sharedSessionsParam = callingBackend === _types.CALLING_BACKEND.WXC ? '&includeSharedSessions=true' : '';
+              _Logger.default.info("Fetching call history for ".concat(callingBackend, " backend").concat(callingBackend === _types.CALLING_BACKEND.WXC ? ' with shared sessions' : ''), this.loggerContext);
+              url = "".concat(this.janusUrl, "/").concat(_constants.HISTORY, "/").concat(_constants2.USER_SESSIONS).concat(_constants.FROM_DATE, "=").concat(this.fromDate, "&limit=").concat(limit, "&includeNewSessionTypes=true&sort=").concat(sortParam).concat(sharedSessionsParam);
+              _context4.prev = 1;
+              _context4.next = 2;
+              return this.webex.request({
+                uri: "".concat(url),
+                method: _types.HTTP_METHODS.GET,
+                service: _types.ALLOWED_SERVICES.JANUS
+              });
+            case 2:
+              janusResponse = _context4.sent;
+              _Logger.default.log("Response trackingId: ".concat(janusResponse === null || janusResponse === void 0 ? void 0 : (_janusResponse$header = janusResponse.headers) === null || _janusResponse$header === void 0 ? void 0 : _janusResponse$header.trackingid), this.loggerContext);
+              this.userSessions = janusResponse.body;
+              if (sortByParam === _types.SORT_BY.START_TIME) {
+                if (sortParam === _types.SORT.DESC) {
+                  this.userSessions[_constants2.USER_SESSIONS].sort(function (element, compareElement) {
+                    return new Date(compareElement[sortByParam]).getTime() - new Date(element[sortByParam]).getTime();
+                  });
+                } else if (sortParam === _types.SORT.ASC) {
+                  this.userSessions[_constants2.USER_SESSIONS].sort(function (element, compareElement) {
+                    return new Date(element[sortByParam]).getTime() - new Date(compareElement[sortByParam]).getTime();
+                  });
+                }
+              }
+              // Check the calling backend (BEMS01958007: non-fatal so /lines or uploadLogs failure does not drop call history)
+              if (!(callingBackend === _types.CALLING_BACKEND.UCM)) {
+                _context4.next = 7;
+                break;
+              }
+              _context4.prev = 3;
+              if (!(this.userSessions[_constants2.USER_SESSIONS] && this.userSessions[_constants2.USER_SESSIONS].length > 0)) {
+                _context4.next = 5;
+                break;
+              }
+              // Check if cucmDN exists and is valid in any of the userSessions
+              hasCucmDN = this.userSessions[_constants2.USER_SESSIONS].some(function (session) {
+                return session.self.cucmDN && session.self.cucmDN.length > 0;
+              }); // If any user session has cucmDN, proceed to fetch line data
+              if (!hasCucmDN) {
+                _context4.next = 5;
+                break;
+              }
+              _Logger.default.info('Fetching UCM lines data for call history enrichment', this.loggerContext);
+              _context4.next = 4;
+              return this.fetchUCMLinesData();
+            case 4:
+              ucmLinesResponse = _context4.sent;
+              // Check if the Lines API response was successful
+              if (ucmLinesResponse.statusCode === 200 && (_ucmLinesResponse$dat = ucmLinesResponse.data.lines) !== null && _ucmLinesResponse$dat !== void 0 && _ucmLinesResponse$dat.devices) {
+                ucmLinesData = ucmLinesResponse.data.lines.devices; // Iterate over user sessions and match with Lines data
+                this.userSessions[_constants2.USER_SESSIONS].forEach(function (session) {
+                  var cucmDN = session.self.cucmDN;
+                  if (cucmDN) {
+                    ucmLinesData.forEach(function (device) {
+                      device.lines.forEach(function (line) {
+                        if (line.dnorpattern === cucmDN) {
+                          session.self.ucmLineNumber = line.index; // Assign the ucmLineNumber
+                        }
+                      });
+                    });
+                  }
+                });
+                _Logger.default.log("UCM line number enrichment completed", this.loggerContext);
+              } else {
+                _Logger.default.info("UCM lines API returned statusCode ".concat(ucmLinesResponse === null || ucmLinesResponse === void 0 ? void 0 : ucmLinesResponse.statusCode, " or no devices, ") + 'returning call history without line number enrichment', this.loggerContext);
+              }
+            case 5:
+              _context4.next = 7;
+              break;
+            case 6:
+              _context4.prev = 6;
+              _t = _context4["catch"](3);
+              _Logger.default.warn("UCM lines fetch or enrich failed, returning call history without line numbers: ".concat((0, _stringify.default)(_t)), {
+                file: _constants.CALL_HISTORY_FILE,
+                method: _constants.METHODS.GET_CALL_HISTORY_DATA
+              });
+              // Continue and return userSessions without ucmLineNumber enrichment
+            case 7:
+              responseDetails = {
+                statusCode: this.userSessions[_constants2.STATUS_CODE],
+                data: {
+                  userSessions: this.userSessions[_constants2.USER_SESSIONS]
+                },
+                message: _constants2.SUCCESS_MESSAGE
+              };
+              _Logger.default.log("Successfully retrieved call history data with ".concat(this.userSessions[_constants2.USER_SESSIONS].length, " records"), this.loggerContext);
+              return _context4.abrupt("return", responseDetails);
+            case 8:
+              _context4.prev = 8;
+              _t2 = _context4["catch"](1);
+              _Logger.default.error("Failed to get call history: ".concat((0, _stringify.default)(_t2)), {
+                file: _constants.CALL_HISTORY_FILE,
+                method: _constants.METHODS.GET_CALL_HISTORY_DATA
+              });
+              _context4.next = 9;
+              return (0, _Utils.uploadLogs)();
+            case 9:
+              errorInfo = _t2;
+              errorStatus = (0, _Utils.serviceErrorCodeHandler)(errorInfo, this.loggerContext);
+              return _context4.abrupt("return", errorStatus);
+            case 10:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this, [[1, 8], [3, 6]]);
+      }));
+      function getCallHistoryData() {
+        return _getCallHistoryData.apply(this, arguments);
+      }
+      return getCallHistoryData;
+    }()
+    /**
+     * Function to update the missed call status in the call history using sessionId and time.
+     * @param endTimeSessionIds - An array of objects containing endTime and sessionId of the missed call history records
+     * @returns {Promise} Resolves to an object of type  {@link UpdateMissedCallsResponse}.Response details with success or error status.
+     */
+    )
+  }, {
+    key: "updateMissedCalls",
+    value: (function () {
+      var _updateMissedCalls = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee5(endTimeSessionIds) {
+        var loggerContext, santizedSessionIds, requestBody, _response$headers, updateMissedCallContentUrl, response, data, responseDetails, errorInfo, errorStatus, _t3, _t4, _t5, _t6, _t7, _t8, _t9, _t0;
+        return _regenerator.default.wrap(function (_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              loggerContext = {
+                file: _constants.CALL_HISTORY_FILE,
+                method: _constants.METHODS.UPDATE_MISSED_CALLS
+              }; // Convert endTime to milliseconds for each session
+              santizedSessionIds = endTimeSessionIds.map(function (session) {
+                return _objectSpread(_objectSpread({}, session), {}, {
+                  endTime: new Date(session.endTime).getTime()
+                });
+              });
+              requestBody = {
+                endTimeSessionIds: santizedSessionIds
+              };
+              _Logger.default.info("".concat(_constants2.METHOD_START_MESSAGE, " with sessions: ").concat((0, _stringify.default)(santizedSessionIds)), loggerContext);
+              _context5.prev = 1;
+              updateMissedCallContentUrl = "".concat(this.janusUrl, "/").concat(_constants.HISTORY, "/").concat(_constants2.USER_SESSIONS, "/").concat(_constants.UPDATE_MISSED_CALLS_ENDPOINT); // Make a POST request to update missed calls
+              _t3 = fetch;
+              _t4 = updateMissedCallContentUrl;
+              _t5 = _types.HTTP_METHODS.POST;
+              _t6 = _defineProperty2.default;
+              _t7 = (0, _defineProperty2.default)({}, _constants.CONTENT_TYPE, _constants.APPLICATION_JSON);
+              _context5.next = 2;
+              return this.webex.credentials.getUserToken();
+            case 2:
+              _t8 = _t6(_t7, "Authorization", _context5.sent);
+              _t9 = (0, _stringify.default)(requestBody);
+              _context5.next = 3;
+              return _t3(_t4, {
+                method: _t5,
+                headers: _t8,
+                body: _t9
+              });
+            case 3:
+              response = _context5.sent;
+              if (response.ok) {
+                _context5.next = 4;
+                break;
+              }
+              throw new Error("".concat(response.status));
+            case 4:
+              _Logger.default.log("Response trackingId: ".concat((_response$headers = response.headers) === null || _response$headers === void 0 ? void 0 : _response$headers.get('trackingid')), loggerContext);
+              _context5.next = 5;
+              return response.json();
+            case 5:
+              data = _context5.sent;
+              _Logger.default.log("Missed calls are successfully read by the user", loggerContext);
+              responseDetails = {
+                statusCode: data.statusCode,
+                data: {
+                  readStatusMessage: _constants.SET_READ_STATE_SUCCESS_MESSAGE
+                },
+                message: _constants2.SUCCESS_MESSAGE
+              };
+              _Logger.default.log("Successfully updated ".concat(santizedSessionIds === null || santizedSessionIds === void 0 ? void 0 : santizedSessionIds.length, " missed calls"), loggerContext);
+              return _context5.abrupt("return", responseDetails);
+            case 6:
+              _context5.prev = 6;
+              _t0 = _context5["catch"](1);
+              _Logger.default.error("Failed to update missed calls: ".concat((0, _stringify.default)(_t0)), {
+                file: _constants.CALL_HISTORY_FILE,
+                method: _constants.METHODS.UPDATE_MISSED_CALLS
+              });
+              _context5.next = 7;
+              return (0, _Utils.uploadLogs)();
+            case 7:
+              // Catch the 401 error from try block, return the error object to user
+              errorInfo = {
+                statusCode: _t0 instanceof Error ? Number(_t0.message) : ''
+              };
+              errorStatus = (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext);
+              return _context5.abrupt("return", errorStatus);
+            case 8:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this, [[1, 6]]);
+      }));
+      function updateMissedCalls(_x4) {
+        return _updateMissedCalls.apply(this, arguments);
+      }
+      return updateMissedCalls;
+    }()
+    /**
+     * Function to display the UCM Lines API response.
+     * @returns {Promise} Resolves to an object of type  {@link UCMLinesResponse}.Response details with success or error status.
+     */
+    )
+  }, {
+    key: "fetchUCMLinesData",
+    value: (function () {
+      var _fetchUCMLinesData = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee6() {
+        var loggerContext, vgEndpoint, userId, orgId, linesURIForUCM, _response$headers2, response, ucmLineDetails, errorInfo, errorStatus, _t1;
+        return _regenerator.default.wrap(function (_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              loggerContext = {
+                file: _constants.CALL_HISTORY_FILE,
+                method: _constants.METHODS.FETCH_UCM_LINES_DATA
+              };
+              vgEndpoint = (0, _Utils.getVgActionEndpoint)(this.webex, _types.CALLING_BACKEND.UCM);
+              userId = this.webex.internal.device.userId;
+              orgId = this.webex.internal.device.orgId;
+              linesURIForUCM = "".concat(vgEndpoint, "/").concat(_constants.VERSION_1, "/").concat(_constants.UNIFIED_COMMUNICATIONS, "/").concat(_constants.CONFIG, "/").concat(_constants.PEOPLE, "/").concat(userId, "/").concat(_constants.LINES, "?").concat(_constants.ORG_ID, "=").concat(orgId);
+              _Logger.default.info("".concat(_constants2.METHOD_START_MESSAGE, " with URL: ").concat(linesURIForUCM), loggerContext);
+              _context6.prev = 1;
+              _context6.next = 2;
+              return this.webex.request({
+                uri: "".concat(linesURIForUCM),
+                method: _types.HTTP_METHODS.GET
+              });
+            case 2:
+              response = _context6.sent;
+              _Logger.default.log("Response trackingId: ".concat(response === null || response === void 0 ? void 0 : (_response$headers2 = response.headers) === null || _response$headers2 === void 0 ? void 0 : _response$headers2.trackingid), loggerContext);
+              ucmLineDetails = {
+                statusCode: Number(response.statusCode),
+                data: {
+                  lines: response.body
+                },
+                message: _constants2.SUCCESS_MESSAGE
+              };
+              _Logger.default.log("Line details fetched successfully", loggerContext);
+              return _context6.abrupt("return", ucmLineDetails);
+            case 3:
+              _context6.prev = 3;
+              _t1 = _context6["catch"](1);
+              _Logger.default.error("Failed to fetch UCM lines data: ".concat((0, _stringify.default)(_t1)), {
+                file: _constants.CALL_HISTORY_FILE,
+                method: _constants.METHODS.FETCH_UCM_LINES_DATA
+              });
+              _context6.next = 4;
+              return (0, _Utils.uploadLogs)();
+            case 4:
+              errorInfo = _t1;
+              errorStatus = (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext);
+              return _context6.abrupt("return", errorStatus);
+            case 5:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this, [[1, 3]]);
+      }));
+      function fetchUCMLinesData() {
+        return _fetchUCMLinesData.apply(this, arguments);
+      }
+      return fetchUCMLinesData;
+    }()
+    /**
+     * Function to delete the call history records using sessionId and endTime.
+     * @param deleteSessionIds - An array of objects containing endTime and sessionId of the call history records
+     * @returns {Promise} Resolves to an object of type  {@link DeleteCallHistoryRecordsResponse}.Response details with success or error status.
+     */
+    )
+  }, {
+    key: "deleteCallHistoryRecords",
+    value: (function () {
+      var _deleteCallHistoryRecords = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee7(deleteSessionIds) {
+        var loggerContext, invalidSessions, invalidSessionIds, santizedSessionIds, deleteRequestBody, _response$headers3, deleteCallHistoryRecordContentUrl, response, data, responseDetails, errorInfo, errorStatus, _t10, _t11, _t12, _t13, _t14, _t15, _t16, _t17;
+        return _regenerator.default.wrap(function (_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              loggerContext = {
+                file: _constants.CALL_HISTORY_FILE,
+                method: _constants.METHODS.DELETE_CALL_HISTORY_RECORDS
+              }; // Collect all sessions with invalid dates (endTime) in an array
+              invalidSessions = deleteSessionIds.filter(function (session) {
+                return (0, _isNan.default)(new Date(session.endTime).getTime());
+              });
+              _Logger.default.info("".concat(_constants2.METHOD_START_MESSAGE, " with sessions: ").concat((0, _stringify.default)(deleteSessionIds)), loggerContext);
+              if (!(invalidSessions.length > 0)) {
+                _context7.next = 1;
+                break;
+              }
+              // If there are invalid sessions, return an error with details
+              invalidSessionIds = invalidSessions.map(function (session) {
+                return session.sessionId;
+              }).join(', ');
+              _Logger.default.info("The provided date is malformed or invalid for session IDs: ".concat(invalidSessionIds), loggerContext);
+              return _context7.abrupt("return", {
+                statusCode: 400,
+                data: {
+                  deleteStatusMessage: _constants.SET_DELETE_CALL_RECORDS_INVALID_DATE_FORMAT_MESSAGE
+                },
+                message: _constants2.FAILURE_MESSAGE
+              });
+            case 1:
+              // Convert endTime to milliseconds for each sessionId
+              santizedSessionIds = deleteSessionIds.map(function (session) {
+                return _objectSpread(_objectSpread({}, session), {}, {
+                  endTime: new Date(session.endTime).getTime()
+                });
+              });
+              deleteRequestBody = {
+                deleteSessionIds: santizedSessionIds
+              };
+              _context7.prev = 2;
+              deleteCallHistoryRecordContentUrl = "".concat(this.janusUrl, "/").concat(_constants.HISTORY, "/").concat(_constants2.USER_SESSIONS, "/").concat(_constants.DELETE_CALL_HISTORY_RECORDS_ENDPOINT); // Make a POST request to delete call history records
+              _t10 = fetch;
+              _t11 = deleteCallHistoryRecordContentUrl;
+              _t12 = _types.HTTP_METHODS.POST;
+              _t13 = _defineProperty2.default;
+              _t14 = (0, _defineProperty2.default)({}, _constants.CONTENT_TYPE, _constants.APPLICATION_JSON);
+              _context7.next = 3;
+              return this.webex.credentials.getUserToken();
+            case 3:
+              _t15 = _t13(_t14, "Authorization", _context7.sent);
+              _t16 = (0, _stringify.default)(deleteRequestBody);
+              _context7.next = 4;
+              return _t10(_t11, {
+                method: _t12,
+                headers: _t15,
+                body: _t16
+              });
+            case 4:
+              response = _context7.sent;
+              if (response.ok) {
+                _context7.next = 5;
+                break;
+              }
+              throw new Error("".concat(response.status));
+            case 5:
+              _Logger.default.log("Response trackingId: ".concat((_response$headers3 = response.headers) === null || _response$headers3 === void 0 ? void 0 : _response$headers3.get('trackingid')), loggerContext);
+              _context7.next = 6;
+              return response.json();
+            case 6:
+              data = _context7.sent;
+              _Logger.default.log("Successfully deleted ".concat(santizedSessionIds === null || santizedSessionIds === void 0 ? void 0 : santizedSessionIds.length, " call history records"), loggerContext);
+              responseDetails = {
+                statusCode: data.statusCode,
+                data: {
+                  deleteStatusMessage: _constants.SET_DELETE_CALL_RECORDS_SUCCESS_MESSAGE
+                },
+                message: _constants2.SUCCESS_MESSAGE
+              };
+              return _context7.abrupt("return", responseDetails);
+            case 7:
+              _context7.prev = 7;
+              _t17 = _context7["catch"](2);
+              _Logger.default.error("Failed to delete call history records: ".concat((0, _stringify.default)(_t17)), {
+                file: _constants.CALL_HISTORY_FILE,
+                method: _constants.METHODS.DELETE_CALL_HISTORY_RECORDS
+              });
+              _context7.next = 8;
+              return (0, _Utils.uploadLogs)();
+            case 8:
+              // Catch the 401 error from try block, return the error object to user
+              errorInfo = {
+                statusCode: _t17 instanceof Error ? Number(_t17.message) : ''
+              };
+              errorStatus = (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext);
+              return _context7.abrupt("return", errorStatus);
+            case 9:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this, [[2, 7]]);
+      }));
+      function deleteCallHistoryRecords(_x5) {
+        return _deleteCallHistoryRecords.apply(this, arguments);
+      }
+      return deleteCallHistoryRecords;
+    }())
+  }, {
+    key: "registerSessionsListener",
+    value:
+    /**
+     *
+     */
+    function registerSessionsListener() {
+      this.sdkConnector.registerListener(_types2.MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_INCLUSIVE, this.handleSessionEvents);
+      this.sdkConnector.registerListener(_types2.MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_LEGACY, this.handleSessionEvents);
+      this.sdkConnector.registerListener(_types2.MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_VIEWED, this.handleUserReadSessionEvents);
+      this.sdkConnector.registerListener(_types2.MOBIUS_EVENT_KEYS.CALL_SESSION_EVENT_DELETED, this.handleUserSessionsDeletedEvents);
+    }
+  }]);
+}(_impl.Eventing);
+/**
+ * Creates a `CallHistory` client instance for accessing Call History APIs.
+ *
+ * @param {WebexSDK} webex - `Webex SDK` instance.
+ * @param {LoggerInterface} logger - An instance implementing LoggerInterface used to set the log level for the module.
+ */
+var createCallHistoryClient = exports.createCallHistoryClient = function createCallHistoryClient(webex, logger) {
+  return new CallHistory(webex, logger);
+};
+//# sourceMappingURL=CallHistory.js.map