@webex/calling 3.0.0-next.4 → 3.0.0-next.40

package/dist/Contacts/ContactsClient.js

@@ -0,0 +1,1156 @@
+"use strict";
+
+var _Object$keys2 = 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.createContactsClient = exports.ContactsClient = void 0;
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _promise = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/promise"));
+var _values = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/values"));
+var _entries = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/entries"));
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/slicedToArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/toConsumableArray"));
+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 _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _constants = require("../common/constants");
+var _types = require("../common/types");
+var _SDKConnector = _interopRequireDefault(require("../SDKConnector"));
+var _Logger = _interopRequireDefault(require("../Logger"));
+var _constants2 = require("./constants");
+var _types2 = require("./types");
+var _Utils = require("../common/Utils");
+function ownKeys(e, r) { var t = _Object$keys2(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; } /* eslint-disable no-await-in-loop */
+/**
+ * `ContactsClient` module is designed to offer a set of APIs for retrieving and updating contacts and groups from the contacts-service.
+ *
+ * This code snippet demonstrates how to create an instance of `ContactClient` using webex and logger.
+ *
+ * Example
+ * ```javascript
+ * const contactClient = createContactsClient(webex, logger);
+ * ```
+ */
+var ContactsClient = exports.ContactsClient = /*#__PURE__*/function () {
+  /**
+   * @ignore
+   */
+  function ContactsClient(webex, logger) {
+    (0, _classCallCheck2.default)(this, ContactsClient);
+    (0, _defineProperty2.default)(this, "sdkConnector", void 0);
+    (0, _defineProperty2.default)(this, "encryptionKeyUrl", void 0);
+    (0, _defineProperty2.default)(this, "webex", void 0);
+    (0, _defineProperty2.default)(this, "groups", void 0);
+    (0, _defineProperty2.default)(this, "contacts", void 0);
+    (0, _defineProperty2.default)(this, "defaultGroupId", void 0);
+    this.sdkConnector = _SDKConnector.default;
+    if (!this.sdkConnector.getWebex()) {
+      _SDKConnector.default.setWebex(webex);
+    }
+    this.webex = this.sdkConnector.getWebex();
+    this.encryptionKeyUrl = '';
+    this.groups = undefined;
+    this.contacts = undefined;
+    this.defaultGroupId = '';
+    _Logger.default.setLogger(logger.level, _constants2.CONTACTS_FILE);
+  }
+
+  /**
+   * Decrypt emails, phoneNumbers, sipAddresses.
+   */
+  (0, _createClass2.default)(ContactsClient, [{
+    key: "decryptContactDetail",
+    value: (function () {
+      var _decryptContactDetail = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(encryptionKeyUrl, contactDetails) {
+        var _this = this;
+        var decryptedContactDetail, decryptedValues;
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              decryptedContactDetail = (0, _toConsumableArray2.default)(contactDetails);
+              _context.next = 3;
+              return _promise.default.all(decryptedContactDetail.map(function (detail) {
+                return _this.webex.internal.encryption.decryptText(encryptionKeyUrl, detail.value);
+              }));
+            case 3:
+              decryptedValues = _context.sent;
+              decryptedValues.forEach(function (decryptedValue, index) {
+                decryptedContactDetail[index].value = decryptedValue;
+              });
+              return _context.abrupt("return", decryptedContactDetail);
+            case 6:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      function decryptContactDetail(_x, _x2) {
+        return _decryptContactDetail.apply(this, arguments);
+      }
+      return decryptContactDetail;
+    }()
+    /**
+     * Encrypt emails, phoneNumbers, sipAddresses.
+     *
+     */
+    )
+  }, {
+    key: "encryptContactDetail",
+    value: (function () {
+      var _encryptContactDetail = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(encryptionKeyUrl, contactDetails) {
+        var _this2 = this;
+        var encryptedContactDetail, encryptedValues;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              encryptedContactDetail = (0, _toConsumableArray2.default)(contactDetails);
+              _context2.next = 3;
+              return _promise.default.all(encryptedContactDetail.map(function (detail) {
+                return _this2.webex.internal.encryption.encryptText(encryptionKeyUrl, detail.value);
+              }));
+            case 3:
+              encryptedValues = _context2.sent;
+              encryptedValues.forEach(function (encryptedValue, index) {
+                encryptedContactDetail[index].value = encryptedValue;
+              });
+              return _context2.abrupt("return", encryptedContactDetail);
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function encryptContactDetail(_x3, _x4) {
+        return _encryptContactDetail.apply(this, arguments);
+      }
+      return encryptContactDetail;
+    }()
+    /**
+     * Encrypts a given contact.
+     */
+    )
+  }, {
+    key: "encryptContact",
+    value: (function () {
+      var _encryptContact = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5(contact) {
+        var _this3 = this;
+        var encryptionKeyUrl, encryptedContact, encryptionPromises, encryptedFieldsList;
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              encryptionKeyUrl = contact.encryptionKeyUrl;
+              encryptedContact = _objectSpread({}, contact);
+              encryptionPromises = (0, _values.default)(_constants2.encryptedFields).map( /*#__PURE__*/function () {
+                var _ref = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(field) {
+                  var plaintextAddressInfo, encryptedAddressInfo, encryptedAddressInfoPromises, plainTextDetails, encryptedDetails, encryptedValue;
+                  return _regenerator.default.wrap(function _callee4$(_context4) {
+                    while (1) switch (_context4.prev = _context4.next) {
+                      case 0:
+                        _context4.t0 = field;
+                        _context4.next = _context4.t0 === _constants2.encryptedFields.ADDRESS_INFO ? 3 : _context4.t0 === _constants2.encryptedFields.EMAILS ? 12 : _context4.t0 === _constants2.encryptedFields.PHONE_NUMBERS ? 12 : _context4.t0 === _constants2.encryptedFields.SIP_ADDRESSES ? 12 : 18;
+                        break;
+                      case 3:
+                        plaintextAddressInfo = encryptedContact.addressInfo;
+                        if (!plaintextAddressInfo) {
+                          _context4.next = 11;
+                          break;
+                        }
+                        encryptedAddressInfoPromises = (0, _entries.default)(plaintextAddressInfo).map( /*#__PURE__*/function () {
+                          var _ref3 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(_ref2) {
+                            var _ref4, key, value;
+                            return _regenerator.default.wrap(function _callee3$(_context3) {
+                              while (1) switch (_context3.prev = _context3.next) {
+                                case 0:
+                                  _ref4 = (0, _slicedToArray2.default)(_ref2, 2), key = _ref4[0], value = _ref4[1];
+                                  _context3.t0 = key;
+                                  _context3.next = 4;
+                                  return _this3.webex.internal.encryption.encryptText(encryptionKeyUrl, value);
+                                case 4:
+                                  _context3.t1 = _context3.sent;
+                                  return _context3.abrupt("return", [_context3.t0, _context3.t1]);
+                                case 6:
+                                case "end":
+                                  return _context3.stop();
+                              }
+                            }, _callee3);
+                          }));
+                          return function (_x7) {
+                            return _ref3.apply(this, arguments);
+                          };
+                        }());
+                        _context4.t1 = Object;
+                        _context4.next = 9;
+                        return _promise.default.all(encryptedAddressInfoPromises);
+                      case 9:
+                        _context4.t2 = _context4.sent;
+                        encryptedAddressInfo = _context4.t1.fromEntries.call(_context4.t1, _context4.t2);
+                      case 11:
+                        return _context4.abrupt("return", [field, encryptedAddressInfo]);
+                      case 12:
+                        plainTextDetails = encryptedContact[field];
+                        if (!plainTextDetails) {
+                          _context4.next = 17;
+                          break;
+                        }
+                        _context4.next = 16;
+                        return _this3.encryptContactDetail(encryptionKeyUrl, plainTextDetails);
+                      case 16:
+                        encryptedDetails = _context4.sent;
+                      case 17:
+                        return _context4.abrupt("return", [field, encryptedDetails]);
+                      case 18:
+                        if (!((0, _values.default)(_constants2.encryptedFields).includes(field) && encryptedContact[field])) {
+                          _context4.next = 22;
+                          break;
+                        }
+                        _context4.next = 21;
+                        return _this3.webex.internal.encryption.encryptText(encryptionKeyUrl, encryptedContact[field]);
+                      case 21:
+                        encryptedValue = _context4.sent;
+                      case 22:
+                        return _context4.abrupt("return", [field, encryptedValue]);
+                      case 23:
+                      case "end":
+                        return _context4.stop();
+                    }
+                  }, _callee4);
+                }));
+                return function (_x6) {
+                  return _ref.apply(this, arguments);
+                };
+              }());
+              _context5.next = 5;
+              return _promise.default.all(encryptionPromises);
+            case 5:
+              encryptedFieldsList = _context5.sent;
+              encryptedFieldsList.forEach(function (_ref5) {
+                var _ref6 = (0, _slicedToArray2.default)(_ref5, 2),
+                  field = _ref6[0],
+                  value = _ref6[1];
+                if (value !== undefined) {
+                  encryptedContact[field] = value;
+                }
+              });
+              return _context5.abrupt("return", encryptedContact);
+            case 8:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5);
+      }));
+      function encryptContact(_x5) {
+        return _encryptContact.apply(this, arguments);
+      }
+      return encryptContact;
+    }()
+    /**
+     * Decrypts a given contact.
+     */
+    )
+  }, {
+    key: "decryptContact",
+    value: (function () {
+      var _decryptContact = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8(contact) {
+        var _this4 = this;
+        var encryptionKeyUrl, decryptedContact, decryptionPromises, decryptedFieldsList;
+        return _regenerator.default.wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              encryptionKeyUrl = contact.encryptionKeyUrl;
+              decryptedContact = _objectSpread({}, contact);
+              decryptionPromises = (0, _values.default)(_constants2.encryptedFields).map( /*#__PURE__*/function () {
+                var _ref7 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7(field) {
+                  var plaintextAddressInfo, decryptedAddressInfo, decryptedAddressInfoPromises, plainTextDetails, decryptedDetails, decryptedValue;
+                  return _regenerator.default.wrap(function _callee7$(_context7) {
+                    while (1) switch (_context7.prev = _context7.next) {
+                      case 0:
+                        _context7.t0 = field;
+                        _context7.next = _context7.t0 === _constants2.encryptedFields.ADDRESS_INFO ? 3 : _context7.t0 === _constants2.encryptedFields.EMAILS ? 12 : _context7.t0 === _constants2.encryptedFields.PHONE_NUMBERS ? 12 : _context7.t0 === _constants2.encryptedFields.SIP_ADDRESSES ? 12 : 18;
+                        break;
+                      case 3:
+                        plaintextAddressInfo = decryptedContact.addressInfo;
+                        if (!plaintextAddressInfo) {
+                          _context7.next = 11;
+                          break;
+                        }
+                        decryptedAddressInfoPromises = (0, _entries.default)(plaintextAddressInfo).map( /*#__PURE__*/function () {
+                          var _ref9 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6(_ref8) {
+                            var _ref10, key, value;
+                            return _regenerator.default.wrap(function _callee6$(_context6) {
+                              while (1) switch (_context6.prev = _context6.next) {
+                                case 0:
+                                  _ref10 = (0, _slicedToArray2.default)(_ref8, 2), key = _ref10[0], value = _ref10[1];
+                                  _context6.t0 = key;
+                                  _context6.next = 4;
+                                  return _this4.webex.internal.encryption.decryptText(encryptionKeyUrl, value);
+                                case 4:
+                                  _context6.t1 = _context6.sent;
+                                  return _context6.abrupt("return", [_context6.t0, _context6.t1]);
+                                case 6:
+                                case "end":
+                                  return _context6.stop();
+                              }
+                            }, _callee6);
+                          }));
+                          return function (_x10) {
+                            return _ref9.apply(this, arguments);
+                          };
+                        }());
+                        _context7.t1 = Object;
+                        _context7.next = 9;
+                        return _promise.default.all(decryptedAddressInfoPromises);
+                      case 9:
+                        _context7.t2 = _context7.sent;
+                        decryptedAddressInfo = _context7.t1.fromEntries.call(_context7.t1, _context7.t2);
+                      case 11:
+                        return _context7.abrupt("return", [field, decryptedAddressInfo]);
+                      case 12:
+                        plainTextDetails = decryptedContact[field];
+                        if (!plainTextDetails) {
+                          _context7.next = 17;
+                          break;
+                        }
+                        _context7.next = 16;
+                        return _this4.decryptContactDetail(encryptionKeyUrl, plainTextDetails);
+                      case 16:
+                        decryptedDetails = _context7.sent;
+                      case 17:
+                        return _context7.abrupt("return", [field, decryptedDetails]);
+                      case 18:
+                        if (!((0, _values.default)(_constants2.encryptedFields).includes(field) && decryptedContact[field])) {
+                          _context7.next = 22;
+                          break;
+                        }
+                        _context7.next = 21;
+                        return _this4.webex.internal.encryption.decryptText(encryptionKeyUrl, decryptedContact[field]);
+                      case 21:
+                        decryptedValue = _context7.sent;
+                      case 22:
+                        return _context7.abrupt("return", [field, decryptedValue]);
+                      case 23:
+                      case "end":
+                        return _context7.stop();
+                    }
+                  }, _callee7);
+                }));
+                return function (_x9) {
+                  return _ref7.apply(this, arguments);
+                };
+              }());
+              _context8.next = 5;
+              return _promise.default.all(decryptionPromises);
+            case 5:
+              decryptedFieldsList = _context8.sent;
+              decryptedFieldsList.forEach(function (_ref11) {
+                var _ref12 = (0, _slicedToArray2.default)(_ref11, 2),
+                  field = _ref12[0],
+                  value = _ref12[1];
+                if (value !== undefined) {
+                  decryptedContact[field] = value;
+                }
+              });
+              return _context8.abrupt("return", decryptedContact);
+            case 8:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8);
+      }));
+      function decryptContact(_x8) {
+        return _decryptContact.apply(this, arguments);
+      }
+      return decryptContact;
+    }()
+    /**
+     * Fetches contacts from DSS.
+     */
+    )
+  }, {
+    key: "fetchContactFromDSS",
+    value: (function () {
+      var _fetchContactFromDSS = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9(contactsDataMap) {
+        var _this5 = this;
+        var contactList, dssResult, _loop, i;
+        return _regenerator.default.wrap(function _callee9$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              contactList = [];
+              _context10.next = 3;
+              return this.webex.internal.dss.lookup({
+                ids: (0, _keys.default)(contactsDataMap)
+              });
+            case 3:
+              dssResult = _context10.sent;
+              _loop = /*#__PURE__*/_regenerator.default.mark(function _loop() {
+                var contact, contactId, displayName, emails, phoneNumbers, sipAddresses, photos, _contact$additionalIn, department, firstName, identityManager, jobTitle, lastName, manager, _contactsDataMap$cont, contactType, avatarUrlDomain, encryptionKeyUrl, ownerId, groups, avatarURL, addedPhoneNumbers, decryptedPhoneNumbers, addedSipAddresses, decryptedSipAddresses, cloudContact;
+                return _regenerator.default.wrap(function _loop$(_context9) {
+                  while (1) switch (_context9.prev = _context9.next) {
+                    case 0:
+                      contact = dssResult[i];
+                      contactId = contact.identity;
+                      displayName = contact.displayName, emails = contact.emails, phoneNumbers = contact.phoneNumbers, sipAddresses = contact.sipAddresses, photos = contact.photos;
+                      _contact$additionalIn = contact.additionalInfo, department = _contact$additionalIn.department, firstName = _contact$additionalIn.firstName, identityManager = _contact$additionalIn.identityManager, jobTitle = _contact$additionalIn.jobTitle, lastName = _contact$additionalIn.lastName;
+                      manager = identityManager && identityManager.displayName ? identityManager.displayName : undefined;
+                      _contactsDataMap$cont = contactsDataMap[contactId], contactType = _contactsDataMap$cont.contactType, avatarUrlDomain = _contactsDataMap$cont.avatarUrlDomain, encryptionKeyUrl = _contactsDataMap$cont.encryptionKeyUrl, ownerId = _contactsDataMap$cont.ownerId, groups = _contactsDataMap$cont.groups;
+                      avatarURL = '';
+                      if (photos.length) {
+                        avatarURL = photos[0].value;
+                      }
+                      addedPhoneNumbers = contactsDataMap[contactId].phoneNumbers;
+                      if (!addedPhoneNumbers) {
+                        _context9.next = 14;
+                        break;
+                      }
+                      _context9.next = 12;
+                      return _this5.decryptContactDetail(encryptionKeyUrl, addedPhoneNumbers);
+                    case 12:
+                      decryptedPhoneNumbers = _context9.sent;
+                      decryptedPhoneNumbers.forEach(function (number) {
+                        return phoneNumbers.push(number);
+                      });
+                    case 14:
+                      addedSipAddresses = contactsDataMap[contactId].sipAddresses;
+                      if (!addedSipAddresses) {
+                        _context9.next = 20;
+                        break;
+                      }
+                      _context9.next = 18;
+                      return _this5.decryptContactDetail(encryptionKeyUrl, addedSipAddresses);
+                    case 18:
+                      decryptedSipAddresses = _context9.sent;
+                      decryptedSipAddresses.forEach(function (address) {
+                        return sipAddresses.push(address);
+                      });
+                    case 20:
+                      cloudContact = {
+                        avatarUrlDomain: avatarUrlDomain,
+                        avatarURL: avatarURL,
+                        contactId: contactId,
+                        contactType: contactType,
+                        department: department,
+                        displayName: displayName,
+                        emails: emails,
+                        encryptionKeyUrl: encryptionKeyUrl,
+                        firstName: firstName,
+                        groups: groups,
+                        lastName: lastName,
+                        manager: manager,
+                        ownerId: ownerId,
+                        phoneNumbers: phoneNumbers,
+                        sipAddresses: sipAddresses,
+                        title: jobTitle
+                      };
+                      contactList.push(cloudContact);
+                    case 22:
+                    case "end":
+                      return _context9.stop();
+                  }
+                }, _loop);
+              });
+              i = 0;
+            case 6:
+              if (!(i < dssResult.length)) {
+                _context10.next = 11;
+                break;
+              }
+              return _context10.delegateYield(_loop(), "t0", 8);
+            case 8:
+              i += 1;
+              _context10.next = 6;
+              break;
+            case 11:
+              return _context10.abrupt("return", contactList);
+            case 12:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee9, this);
+      }));
+      function fetchContactFromDSS(_x11) {
+        return _fetchContactFromDSS.apply(this, arguments);
+      }
+      return fetchContactFromDSS;
+    }()
+    /**
+     * Returns list of contacts.
+     */
+    )
+  }, {
+    key: "getContacts",
+    value: (function () {
+      var _getContacts = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11() {
+        var _this6 = this;
+        var loggerContext, contactList, contactsDataMap, response, responseBody, contacts, groups, i, contact, decryptedContact, cloudContacts, contactResponse, errorInfo, errorStatus;
+        return _regenerator.default.wrap(function _callee11$(_context12) {
+          while (1) switch (_context12.prev = _context12.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CONTACTS_FILE,
+                method: 'getContacts'
+              };
+              contactList = [];
+              contactsDataMap = {};
+              _context12.prev = 3;
+              _context12.next = 6;
+              return this.webex.request({
+                // eslint-disable-next-line no-underscore-dangle
+                uri: "".concat(this.webex.internal.services._serviceUrls.contactsService, "/").concat(_constants2.ENCRYPT_FILTER, "/").concat(_constants2.USERS, "/").concat(_constants2.CONTACT_FILTER),
+                method: _types.HTTP_METHODS.GET
+              });
+            case 6:
+              response = _context12.sent;
+              responseBody = response.body;
+              if (responseBody) {
+                _context12.next = 10;
+                break;
+              }
+              throw new Error("".concat(response));
+            case 10:
+              contacts = responseBody.contacts, groups = responseBody.groups;
+              i = 0;
+            case 12:
+              if (!(i < contacts.length)) {
+                _context12.next = 25;
+                break;
+              }
+              contact = contacts[i];
+              if (!(contact.contactType === _types2.ContactType.CUSTOM)) {
+                _context12.next = 21;
+                break;
+              }
+              _context12.next = 17;
+              return this.decryptContact(contact);
+            case 17:
+              decryptedContact = _context12.sent;
+              contactList.push(decryptedContact);
+              _context12.next = 22;
+              break;
+            case 21:
+              if (contact.contactType === _types2.ContactType.CLOUD && contact.contactId) {
+                contactsDataMap[contact.contactId] = contact;
+              }
+            case 22:
+              i += 1;
+              _context12.next = 12;
+              break;
+            case 25:
+              if (!(0, _keys.default)(contactsDataMap).length) {
+                _context12.next = 30;
+                break;
+              }
+              _context12.next = 28;
+              return this.fetchContactFromDSS(contactsDataMap);
+            case 28:
+              cloudContacts = _context12.sent;
+              contactList.push.apply(contactList, (0, _toConsumableArray2.default)(cloudContacts));
+            case 30:
+              _context12.next = 32;
+              return _promise.default.all(groups.map( /*#__PURE__*/function () {
+                var _ref13 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10(group, idx) {
+                  return _regenerator.default.wrap(function _callee10$(_context11) {
+                    while (1) switch (_context11.prev = _context11.next) {
+                      case 0:
+                        _context11.next = 2;
+                        return _this6.webex.internal.encryption.decryptText(group.encryptionKeyUrl, group.displayName);
+                      case 2:
+                        groups[idx].displayName = _context11.sent;
+                      case 3:
+                      case "end":
+                        return _context11.stop();
+                    }
+                  }, _callee10);
+                }));
+                return function (_x12, _x13) {
+                  return _ref13.apply(this, arguments);
+                };
+              }()));
+            case 32:
+              this.groups = groups;
+              this.contacts = contactList;
+              contactResponse = {
+                statusCode: Number(response[_constants.STATUS_CODE]),
+                data: {
+                  contacts: contactList,
+                  groups: groups
+                },
+                message: _constants.SUCCESS_MESSAGE
+              };
+              return _context12.abrupt("return", contactResponse);
+            case 38:
+              _context12.prev = 38;
+              _context12.t0 = _context12["catch"](3);
+              errorInfo = _context12.t0;
+              errorStatus = (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext);
+              return _context12.abrupt("return", errorStatus);
+            case 43:
+            case "end":
+              return _context12.stop();
+          }
+        }, _callee11, this, [[3, 38]]);
+      }));
+      function getContacts() {
+        return _getContacts.apply(this, arguments);
+      }
+      return getContacts;
+    }()
+    /**
+     * Creates a new KMS Resource Object (KRO) and Content Key (CK) which is used for encryption.
+     *
+     * @returns EncryptionKeyUrl as a Promise.
+     */
+    )
+  }, {
+    key: "createNewEncryptionKeyUrl",
+    value: (function () {
+      var _createNewEncryptionKeyUrl = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12() {
+        var loggerContext, unboundedKeyUri, unboundedKeys;
+        return _regenerator.default.wrap(function _callee12$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CONTACTS_FILE,
+                method: this.createNewEncryptionKeyUrl.name
+              };
+              unboundedKeyUri = '';
+              _Logger.default.info('Requesting kms for a new KRO and key', loggerContext);
+              _context13.next = 5;
+              return this.webex.internal.encryption.kms.createUnboundKeys({
+                count: 1
+              });
+            case 5:
+              unboundedKeys = _context13.sent;
+              unboundedKeyUri = unboundedKeys[0].uri;
+              this.webex.internal.encryption.kms.createResource({
+                keyUris: [unboundedKeyUri]
+              });
+              return _context13.abrupt("return", unboundedKeyUri);
+            case 9:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee12, this);
+      }));
+      function createNewEncryptionKeyUrl() {
+        return _createNewEncryptionKeyUrl.apply(this, arguments);
+      }
+      return createNewEncryptionKeyUrl;
+    }()
+    /**
+     * Fetches the encryptionKeyUrl from one of the groups. Creates a new key and default group if there is no data.
+     *
+     * @returns EncryptionKeyUrl as a Promise.
+     */
+    )
+  }, {
+    key: "fetchEncryptionKeyUrl",
+    value: (function () {
+      var _fetchEncryptionKeyUrl = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13() {
+        var _response$data$group;
+        var response, _response$data$group2;
+        return _regenerator.default.wrap(function _callee13$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              if (!this.encryptionKeyUrl) {
+                _context14.next = 2;
+                break;
+              }
+              return _context14.abrupt("return", this.encryptionKeyUrl);
+            case 2:
+              // istanbul ignore else
+              if (this.groups === undefined) {
+                this.getContacts();
+              }
+              // istanbul ignore else
+              if (!(this.groups && this.groups.length)) {
+                _context14.next = 5;
+                break;
+              }
+              return _context14.abrupt("return", this.groups[0].encryptionKeyUrl);
+            case 5:
+              _context14.next = 7;
+              return this.createNewEncryptionKeyUrl();
+            case 7:
+              this.encryptionKeyUrl = _context14.sent;
+              _Logger.default.info("Creating a default group: ".concat(_constants2.DEFAULT_GROUP_NAME), {
+                file: _constants2.CONTACTS_FILE,
+                method: this.fetchEncryptionKeyUrl.name
+              });
+              _context14.next = 11;
+              return this.createContactGroup(_constants2.DEFAULT_GROUP_NAME, this.encryptionKeyUrl);
+            case 11:
+              response = _context14.sent;
+              if ((_response$data$group = response.data.group) !== null && _response$data$group !== void 0 && _response$data$group.groupId) {
+                this.defaultGroupId = (_response$data$group2 = response.data.group) === null || _response$data$group2 === void 0 ? void 0 : _response$data$group2.groupId;
+              }
+              return _context14.abrupt("return", this.encryptionKeyUrl);
+            case 14:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee13, this);
+      }));
+      function fetchEncryptionKeyUrl() {
+        return _fetchEncryptionKeyUrl.apply(this, arguments);
+      }
+      return fetchEncryptionKeyUrl;
+    }()
+    /**
+     * Fetches a default group.
+     *
+     * @returns GroupId of default group.
+     */
+    )
+  }, {
+    key: "fetchDefaultGroup",
+    value: (function () {
+      var _fetchDefaultGroup = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14() {
+        var i, response, group;
+        return _regenerator.default.wrap(function _callee14$(_context15) {
+          while (1) switch (_context15.prev = _context15.next) {
+            case 0:
+              if (!this.defaultGroupId) {
+                _context15.next = 2;
+                break;
+              }
+              return _context15.abrupt("return", this.defaultGroupId);
+            case 2:
+              if (!(this.groups && this.groups.length)) {
+                _context15.next = 11;
+                break;
+              }
+              i = 0;
+            case 4:
+              if (!(i < this.groups.length)) {
+                _context15.next = 11;
+                break;
+              }
+              if (!(this.groups[i].displayName === _constants2.DEFAULT_GROUP_NAME)) {
+                _context15.next = 8;
+                break;
+              }
+              this.defaultGroupId = this.groups[i].groupId;
+              return _context15.abrupt("return", this.defaultGroupId);
+            case 8:
+              i += 1;
+              _context15.next = 4;
+              break;
+            case 11:
+              _Logger.default.info('No default group found.', {
+                file: _constants2.CONTACTS_FILE,
+                method: this.fetchDefaultGroup.name
+              });
+              _context15.next = 14;
+              return this.createContactGroup(_constants2.DEFAULT_GROUP_NAME);
+            case 14:
+              response = _context15.sent;
+              group = response.data.group;
+              if (!group) {
+                _context15.next = 18;
+                break;
+              }
+              return _context15.abrupt("return", group.groupId);
+            case 18:
+              return _context15.abrupt("return", '');
+            case 19:
+            case "end":
+              return _context15.stop();
+          }
+        }, _callee14, this);
+      }));
+      function fetchDefaultGroup() {
+        return _fetchDefaultGroup.apply(this, arguments);
+      }
+      return fetchDefaultGroup;
+    }()
+    /**
+     * Creates a personal contact group.
+     * Also creates a KRO, if there aren't any groups.
+     * @param displayName - Name of the group to create.
+     * @param encryptionKeyUrl - EncryptionKeyUrl to encrypt the displayName.
+     * @param groupType - Type of the group to create.
+     */
+    )
+  }, {
+    key: "createContactGroup",
+    value: (function () {
+      var _createContactGroup = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15(displayName, encryptionKeyUrl, groupType) {
+        var loggerContext, encryptionKeyUrlFinal, isExistingGroup, encryptedDisplayName, groupInfo, _this$groups, response, group, contactResponse, errorInfo, errorStatus;
+        return _regenerator.default.wrap(function _callee15$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CONTACTS_FILE,
+                method: this.createContactGroup.name
+              };
+              _Logger.default.info("Creating contact group ".concat(displayName), loggerContext);
+              _context16.t0 = encryptionKeyUrl;
+              if (_context16.t0) {
+                _context16.next = 7;
+                break;
+              }
+              _context16.next = 6;
+              return this.fetchEncryptionKeyUrl();
+            case 6:
+              _context16.t0 = _context16.sent;
+            case 7:
+              encryptionKeyUrlFinal = _context16.t0;
+              if (!(this.groups === undefined)) {
+                _context16.next = 11;
+                break;
+              }
+              _context16.next = 11;
+              return this.getContacts();
+            case 11:
+              if (!(this.groups && this.groups.length)) {
+                _context16.next = 16;
+                break;
+              }
+              isExistingGroup = this.groups.find(function (group) {
+                return group.displayName === displayName;
+              });
+              if (!isExistingGroup) {
+                _context16.next = 16;
+                break;
+              }
+              _Logger.default.warn("Group name ".concat(displayName, " already exists."), loggerContext);
+              return _context16.abrupt("return", {
+                statusCode: 400,
+                data: {
+                  error: 'Group displayName already exists'
+                },
+                message: _constants.FAILURE_MESSAGE
+              });
+            case 16:
+              _context16.next = 18;
+              return this.webex.internal.encryption.encryptText(encryptionKeyUrlFinal, displayName);
+            case 18:
+              encryptedDisplayName = _context16.sent;
+              groupInfo = {
+                schemas: _constants2.CONTACTS_SCHEMA,
+                displayName: encryptedDisplayName,
+                groupType: groupType || _types2.GroupType.NORMAL,
+                encryptionKeyUrl: encryptionKeyUrlFinal
+              };
+              _context16.prev = 20;
+              _context16.next = 23;
+              return this.webex.request({
+                // eslint-disable-next-line no-underscore-dangle
+                uri: "".concat(this.webex.internal.services._serviceUrls.contactsService, "/").concat(_constants2.ENCRYPT_FILTER, "/").concat(_constants2.USERS, "/").concat(_constants2.GROUP_FILTER),
+                method: _types.HTTP_METHODS.POST,
+                body: groupInfo
+              });
+            case 23:
+              response = _context16.sent;
+              group = response.body;
+              group.displayName = displayName;
+              contactResponse = {
+                statusCode: Number(response[_constants.STATUS_CODE]),
+                data: {
+                  group: group
+                },
+                message: _constants.SUCCESS_MESSAGE
+              };
+              (_this$groups = this.groups) === null || _this$groups === void 0 ? void 0 : _this$groups.push(group);
+              return _context16.abrupt("return", contactResponse);
+            case 31:
+              _context16.prev = 31;
+              _context16.t1 = _context16["catch"](20);
+              _Logger.default.warn('Unable to create contact group.', loggerContext);
+              errorInfo = _context16.t1;
+              errorStatus = (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext);
+              return _context16.abrupt("return", errorStatus);
+            case 37:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee15, this, [[20, 31]]);
+      }));
+      function createContactGroup(_x14, _x15, _x16) {
+        return _createContactGroup.apply(this, arguments);
+      }
+      return createContactGroup;
+    }()
+    /**
+     * Deletes a contact group.
+     * @param groupId - GroupId of the group to delete.
+     */
+    )
+  }, {
+    key: "deleteContactGroup",
+    value: (function () {
+      var _deleteContactGroup = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16(groupId) {
+        var loggerContext, _this$groups2, _this$groups4, response, contactResponse, groupToDelete, _this$groups3, errorInfo, errorStatus;
+        return _regenerator.default.wrap(function _callee16$(_context17) {
+          while (1) switch (_context17.prev = _context17.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CONTACTS_FILE,
+                method: this.deleteContactGroup.name
+              };
+              _context17.prev = 1;
+              _Logger.default.info("Deleting contact group: ".concat(groupId), loggerContext);
+              _context17.next = 5;
+              return this.webex.request({
+                // eslint-disable-next-line no-underscore-dangle
+                uri: "".concat(this.webex.internal.services._serviceUrls.contactsService, "/").concat(_constants2.ENCRYPT_FILTER, "/").concat(_constants2.USERS, "/").concat(_constants2.GROUP_FILTER, "/").concat(groupId),
+                method: _types.HTTP_METHODS.DELETE
+              });
+            case 5:
+              response = _context17.sent;
+              contactResponse = {
+                statusCode: Number(response[_constants.STATUS_CODE]),
+                data: {},
+                message: _constants.SUCCESS_MESSAGE
+              };
+              groupToDelete = (_this$groups2 = this.groups) === null || _this$groups2 === void 0 ? void 0 : _this$groups2.findIndex(function (group) {
+                return group.groupId === groupId;
+              });
+              if (groupToDelete !== undefined && groupToDelete !== -1) {
+                (_this$groups3 = this.groups) === null || _this$groups3 === void 0 ? void 0 : _this$groups3.splice(groupToDelete, 1);
+              }
+              if (!((_this$groups4 = this.groups) !== null && _this$groups4 !== void 0 && _this$groups4.length)) {
+                this.defaultGroupId = '';
+              }
+              return _context17.abrupt("return", contactResponse);
+            case 13:
+              _context17.prev = 13;
+              _context17.t0 = _context17["catch"](1);
+              _Logger.default.warn("Unable to delete contact group ".concat(groupId), loggerContext);
+              errorInfo = _context17.t0;
+              errorStatus = (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext);
+              return _context17.abrupt("return", errorStatus);
+            case 19:
+            case "end":
+              return _context17.stop();
+          }
+        }, _callee16, this, [[1, 13]]);
+      }));
+      function deleteContactGroup(_x17) {
+        return _deleteContactGroup.apply(this, arguments);
+      }
+      return deleteContactGroup;
+    }()
+    /**
+     * Creates a custom contact.
+     * @param contactInfo - Contact object to create.
+     */
+    )
+  }, {
+    key: "createContact",
+    value: (function () {
+      var _createContact = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17(contactInfo) {
+        var loggerContext, contact, defaultGroupId, requestBody, encryptedContact, _encryptedContact, response, newContact, contactResponse, decryptedContacts, _this$contacts, _this$contacts2, errorInfo, errorStatus;
+        return _regenerator.default.wrap(function _callee17$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CONTACTS_FILE,
+                method: this.createContact.name
+              };
+              _Logger.default.info("Request to create contact: contactType: ".concat(contactInfo.contactType), loggerContext);
+              _context18.prev = 2;
+              contact = _objectSpread({}, contactInfo);
+              if (contact.encryptionKeyUrl) {
+                _context18.next = 8;
+                break;
+              }
+              _context18.next = 7;
+              return this.fetchEncryptionKeyUrl();
+            case 7:
+              contact.encryptionKeyUrl = _context18.sent;
+            case 8:
+              if (!(!contact.groups || contact.groups.length === 0)) {
+                _context18.next = 13;
+                break;
+              }
+              _context18.next = 11;
+              return this.fetchDefaultGroup();
+            case 11:
+              defaultGroupId = _context18.sent;
+              contact.groups = [defaultGroupId];
+            case 13:
+              contact.schemas = _constants2.CONTACTS_SCHEMA;
+              requestBody = {};
+              _context18.t0 = contact.contactType;
+              _context18.next = _context18.t0 === _types2.ContactType.CUSTOM ? 18 : _context18.t0 === _types2.ContactType.CLOUD ? 23 : 30;
+              break;
+            case 18:
+              _context18.next = 20;
+              return this.encryptContact(contact);
+            case 20:
+              encryptedContact = _context18.sent;
+              requestBody = encryptedContact;
+              return _context18.abrupt("break", 31);
+            case 23:
+              if (contact.contactId) {
+                _context18.next = 25;
+                break;
+              }
+              return _context18.abrupt("return", {
+                statusCode: 400,
+                data: {
+                  error: 'contactId is required for contactType:CLOUD.'
+                },
+                message: _constants.FAILURE_MESSAGE
+              });
+            case 25:
+              _context18.next = 27;
+              return this.encryptContact(contact);
+            case 27:
+              _encryptedContact = _context18.sent;
+              requestBody = _encryptedContact;
+              return _context18.abrupt("break", 31);
+            case 30:
+              return _context18.abrupt("return", {
+                statusCode: 400,
+                data: {
+                  error: 'Unknown contactType received.'
+                },
+                message: _constants.FAILURE_MESSAGE
+              });
+            case 31:
+              _context18.next = 33;
+              return this.webex.request({
+                // eslint-disable-next-line no-underscore-dangle
+                uri: "".concat(this.webex.internal.services._serviceUrls.contactsService, "/").concat(_constants2.ENCRYPT_FILTER, "/").concat(_constants2.USERS, "/").concat(_constants2.CONTACT_FILTER),
+                method: _types.HTTP_METHODS.POST,
+                body: requestBody
+              });
+            case 33:
+              response = _context18.sent;
+              newContact = response.body;
+              contact.contactId = newContact.contactId;
+              contactResponse = {
+                statusCode: Number(response[_constants.STATUS_CODE]),
+                data: {
+                  contact: contact
+                },
+                message: _constants.SUCCESS_MESSAGE
+              };
+              if (!(contact.contactType === _types2.ContactType.CLOUD)) {
+                _context18.next = 44;
+                break;
+              }
+              _context18.next = 40;
+              return this.fetchContactFromDSS(Object.fromEntries([[newContact.contactId, newContact]]));
+            case 40:
+              decryptedContacts = _context18.sent;
+              if (decryptedContacts.length && decryptedContacts[0]) {
+                (_this$contacts = this.contacts) === null || _this$contacts === void 0 ? void 0 : _this$contacts.push(decryptedContacts[0]);
+              }
+              _context18.next = 45;
+              break;
+            case 44:
+              (_this$contacts2 = this.contacts) === null || _this$contacts2 === void 0 ? void 0 : _this$contacts2.push(contact);
+            case 45:
+              return _context18.abrupt("return", contactResponse);
+            case 48:
+              _context18.prev = 48;
+              _context18.t1 = _context18["catch"](2);
+              _Logger.default.warn('Failed to create contact.', {
+                file: _constants2.CONTACTS_FILE,
+                method: this.createContact.name
+              });
+              errorInfo = _context18.t1;
+              errorStatus = (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext);
+              return _context18.abrupt("return", errorStatus);
+            case 54:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee17, this, [[2, 48]]);
+      }));
+      function createContact(_x18) {
+        return _createContact.apply(this, arguments);
+      }
+      return createContact;
+    }()
+    /**
+     * Delete a contact.
+     * @param contactId - ContactId of the contact to delete.
+     */
+    )
+  }, {
+    key: "deleteContact",
+    value: (function () {
+      var _deleteContact = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18(contactId) {
+        var loggerContext, _this$contacts3, response, contactResponse, contactToDelete, _this$contacts4, errorInfo, errorStatus;
+        return _regenerator.default.wrap(function _callee18$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              loggerContext = {
+                file: _constants2.CONTACTS_FILE,
+                method: this.deleteContact.name
+              };
+              _context19.prev = 1;
+              _Logger.default.info("Deleting contact : ".concat(contactId), loggerContext);
+              _context19.next = 5;
+              return this.webex.request({
+                // eslint-disable-next-line no-underscore-dangle
+                uri: "".concat(this.webex.internal.services._serviceUrls.contactsService, "/").concat(_constants2.ENCRYPT_FILTER, "/").concat(_constants2.USERS, "/").concat(_constants2.CONTACT_FILTER, "/").concat(contactId),
+                method: _types.HTTP_METHODS.DELETE
+              });
+            case 5:
+              response = _context19.sent;
+              contactResponse = {
+                statusCode: Number(response[_constants.STATUS_CODE]),
+                data: {},
+                message: _constants.SUCCESS_MESSAGE
+              };
+              contactToDelete = (_this$contacts3 = this.contacts) === null || _this$contacts3 === void 0 ? void 0 : _this$contacts3.findIndex(function (contact) {
+                return contact.contactId === contactId;
+              });
+              if (contactToDelete !== undefined && contactToDelete !== -1) {
+                (_this$contacts4 = this.contacts) === null || _this$contacts4 === void 0 ? void 0 : _this$contacts4.splice(contactToDelete, 1);
+              }
+              return _context19.abrupt("return", contactResponse);
+            case 12:
+              _context19.prev = 12;
+              _context19.t0 = _context19["catch"](1);
+              _Logger.default.warn("Unable to delete contact ".concat(contactId), loggerContext);
+              errorInfo = _context19.t0;
+              errorStatus = (0, _Utils.serviceErrorCodeHandler)(errorInfo, loggerContext);
+              return _context19.abrupt("return", errorStatus);
+            case 18:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee18, this, [[1, 12]]);
+      }));
+      function deleteContact(_x19) {
+        return _deleteContact.apply(this, arguments);
+      }
+      return deleteContact;
+    }()
+    /**
+     * @ignore
+     */
+    )
+  }, {
+    key: "getSDKConnector",
+    value: function getSDKConnector() {
+      return this.sdkConnector;
+    }
+  }]);
+  return ContactsClient;
+}();
+/**
+ * Creates a ContactsClient instance
+ *
+ * @param {WebexSDK} webex - `Webex SDK`instance.
+ * @param {LoggerInterface} logger - An instance implementing LoggerInterface used to set the log level for the module.
+ */
+var createContactsClient = exports.createContactsClient = function createContactsClient(webex, logger) {
+  return new ContactsClient(webex, logger);
+};
+//# sourceMappingURL=ContactsClient.js.map