calcite-react/ArcgisAccount/useAccountManager.js

Calcite components for React

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _react = require("react");

var _propTypes = _interopRequireDefault(require("prop-types"));

var _accountManagerUtils = require("./accountManagerUtils");

var _accountManagerStorageUtils = require("./accountManagerStorageUtils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var useAccountManager = function useAccountManager() {
  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
    clientId: null,
    redirectUri: null,
    portalUrl: 'https://www.arcgis.com/sharing',
    popup: false,
    params: {
      force_login: false
    }
  };
  var name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'arcgis-account-manager';

  var _useState = (0, _react.useState)(name),
      _useState2 = _slicedToArray(_useState, 1),
      managerName = _useState2[0];

  var _useState3 = (0, _react.useState)(options),
      _useState4 = _slicedToArray(_useState3, 1),
      managerOptions = _useState4[0];

  var _getAccountManagerSto = (0, _accountManagerStorageUtils.getAccountManagerStorage)(managerName),
      accounts = _getAccountManagerSto.accounts,
      status = _getAccountManagerSto.status,
      active = _getAccountManagerSto.active,
      order = _getAccountManagerSto.order;

  var _useState5 = (0, _react.useState)({
    active: active,
    accounts: accounts,
    status: status,
    order: order
  }),
      _useState6 = _slicedToArray(_useState5, 2),
      accountManagerState = _useState6[0],
      setAccountManagerState = _useState6[1];
  /** Complete Login */


  (0, _react.useEffect)(function () {
    var _ref = status || {},
        loading = _ref.loading,
        authProps = _ref.authProps;

    if (loading) {
      var completeAddAccount =
      /*#__PURE__*/
      function () {
        var _ref2 = _asyncToGenerator(
        /*#__PURE__*/
        regeneratorRuntime.mark(function _callee() {
          var account, accountManager;
          return regeneratorRuntime.wrap(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  _context.next = 2;
                  return (0, _accountManagerUtils.completeLogin)(authProps);

                case 2:
                  account = _context.sent;

                  if (account && account.key) {
                    (0, _accountManagerStorageUtils.addAccountStorage)(managerName, account);
                  } //Update localStorage/ state


                  (0, _accountManagerStorageUtils.completeStatusStorage)(managerName);
                  accountManager = (0, _accountManagerStorageUtils.getAccountManagerStorage)(managerName);
                  setAccountManagerState(accountManager);

                case 7:
                case "end":
                  return _context.stop();
              }
            }
          }, _callee, this);
        }));

        return function completeAddAccount() {
          return _ref2.apply(this, arguments);
        };
      }();

      completeAddAccount();
    }
  }, [managerName, status]);
  /** Add Account */

  var addAccount = (0, _react.useCallback)(function () {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
    var setActive = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
    var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'OAuth2';
    // saving window.location.href (query params, etc) as originRoute
    var originRoute = window.location.href;

    var _ref3 = options ? options || {} : managerOptions || {},
        clientId = _ref3.clientId,
        redirectUri = _ref3.redirectUri,
        portalUrl = _ref3.portalUrl,
        popup = _ref3.popup,
        params = _ref3.params; //set localstorage status


    (0, _accountManagerStorageUtils.beginStatusStorage)(managerName, {
      clientId: clientId,
      redirectUri: redirectUri,
      portalUrl: portalUrl,
      popup: popup
    }, originRoute, setActive); //begin login

    (0, _accountManagerUtils.beginLogin)(managerName, {
      clientId: clientId,
      redirectUri: redirectUri,
      portalUrl: portalUrl,
      popup: popup,
      params: params
    }, setAccountManagerState, type);
  }, [managerOptions, managerName]);
  /** Logout Account: Remove token and session from user auth object and attempt revoke token*/

  var logoutAccount = (0, _react.useCallback)(
  /*#__PURE__*/
  _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee2() {
    var account,
        _ref5,
        session,
        token,
        key,
        valid,
        response,
        _status,
        accountManager,
        _args2 = arguments;

    return regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            account = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : null;
            _ref5 = account || {}, session = _ref5.session, token = _ref5.token, key = _ref5.key;
            valid = validAccount(account);

            if (!(session && token && valid)) {
              _context2.next = 14;
              break;
            }

            _context2.next = 6;
            return (0, _accountManagerUtils.logout)(account);

          case 6:
            response = _context2.sent;
            _status = JSON.stringify(response);
            console.log("Revoke token status: ".concat(_status)); //Update localStorage/ state

            (0, _accountManagerStorageUtils.logoutAccountStorage)(managerName, account);
            accountManager = (0, _accountManagerStorageUtils.getAccountManagerStorage)(managerName);
            setAccountManagerState(accountManager);
            _context2.next = 15;
            break;

          case 14:
            console.error("Invalid account object given to logoutAccount. Required fields: session/token/key. Fields received: {session: ".concat(session, ", token: ").concat(token, ", key: ").concat(key, "}"));

          case 15:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2, this);
  })), [accountManagerState, managerName]);
  /** Remove Account: Remove account from local storage and attempt revoke token*/

  var removeAccount = (0, _react.useCallback)(
  /*#__PURE__*/
  _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee3() {
    var account,
        valid,
        _ref7,
        session,
        token,
        key,
        response,
        _status2,
        accountManager,
        _args3 = arguments;

    return regeneratorRuntime.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            account = _args3.length > 0 && _args3[0] !== undefined ? _args3[0] : null;
            valid = validAccount(account);
            _ref7 = account || {}, session = _ref7.session, token = _ref7.token, key = _ref7.key;

            if (!valid) {
              _context3.next = 15;
              break;
            }

            if (!token) {
              _context3.next = 10;
              break;
            }

            _context3.next = 7;
            return (0, _accountManagerUtils.logout)(account);

          case 7:
            response = _context3.sent;
            _status2 = JSON.stringify(response);
            console.log("Revoke token status: ".concat(_status2));

          case 10:
            //Update localStorage/ state
            (0, _accountManagerStorageUtils.removeAccountStorage)(managerName, account);
            accountManager = (0, _accountManagerStorageUtils.getAccountManagerStorage)(managerName);
            setAccountManagerState(accountManager);
            _context3.next = 16;
            break;

          case 15:
            console.error("Invalid account object given to removeAccount. Required fields: session/key. Fields received: {session: ".concat(session, ", key: ").concat(key, "}"));

          case 16:
          case "end":
            return _context3.stop();
        }
      }
    }, _callee3, this);
  })), [accountManagerState, managerName]);
  /** Restore Account: Log in to an existing account that is logged out */

  var restoreAccount =
  /*#__PURE__*/
  function () {
    var _ref8 = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee4() {
      var account,
          _ref9,
          portal,
          _ref10,
          appInfo,
          portalHostname,
          user,
          _ref11,
          appId,
          _ref12,
          username,
          portalUrl,
          clientId,
          _ref13,
          authProps,
          _ref14,
          redirectUri,
          popup,
          originRoute,
          _args4 = arguments;

      return regeneratorRuntime.wrap(function _callee4$(_context4) {
        while (1) {
          switch (_context4.prev = _context4.next) {
            case 0:
              account = _args4.length > 0 && _args4[0] !== undefined ? _args4[0] : null;
              // Get type from account
              _ref9 = account || {}, portal = _ref9.portal;
              _ref10 = portal || {}, appInfo = _ref10.appInfo, portalHostname = _ref10.portalHostname, user = _ref10.user;
              _ref11 = appInfo || {}, appId = _ref11.appId;
              _ref12 = user || {}, username = _ref12.username;

              if (appId && portalHostname) {
                portalUrl = "https://".concat(portalHostname, "/sharing");
                clientId = appId;
                _ref13 = accountManagerState.status || {}, authProps = _ref13.authProps;
                _ref14 = authProps || {
                  popup: false
                }, redirectUri = _ref14.redirectUri, popup = _ref14.popup;
                originRoute = window.location.href;

                if (redirectUri) {
                  //set localstorage status
                  (0, _accountManagerStorageUtils.beginStatusStorage)(managerName, {
                    clientId: clientId,
                    redirectUri: redirectUri,
                    portalUrl: portalUrl,
                    popup: popup
                  }, originRoute); //begin login

                  (0, _accountManagerUtils.beginLogin)(managerName, {
                    clientId: clientId,
                    redirectUri: redirectUri,
                    portalUrl: portalUrl,
                    popup: popup,
                    params: {
                      force_login: true,
                      username: username
                    }
                  }, setAccountManagerState);
                } else {
                  console.error("Cannot restore account. Missing redirectUri and popup in accountManagerState.status: ".concat(accountManagerState.status));
                }
              } else {
                console.error("Cannot restore account. Missing clientId and portalUrl in account portal: ".concat(portal));
              }

            case 6:
            case "end":
              return _context4.stop();
          }
        }
      }, _callee4, this);
    }));

    return function restoreAccount() {
      return _ref8.apply(this, arguments);
    };
  }();
  /** Refresh Account */


  var refreshAccount =
  /*#__PURE__*/
  function () {
    var _ref15 = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee5() {
      var account,
          _ref16,
          portal,
          response,
          _ref17,
          appInfo,
          portalHostname,
          user,
          _ref18,
          appId,
          _ref19,
          username,
          portalUrl,
          clientId,
          _ref20,
          authProps,
          _ref21,
          redirectUri,
          popup,
          originRoute,
          _args5 = arguments;

      return regeneratorRuntime.wrap(function _callee5$(_context5) {
        while (1) {
          switch (_context5.prev = _context5.next) {
            case 0:
              account = _args5.length > 0 && _args5[0] !== undefined ? _args5[0] : null;
              _ref16 = account || {}, portal = _ref16.portal;
              response = (0, _accountManagerUtils.refresh)(account);

              if (response.success && response.session) {
                (0, _accountManagerStorageUtils.refreshAccountStorage)(managerName, {
                  key: account.key,
                  session: response.session
                });
              } else {
                if (portal) {
                  _ref17 = portal || {}, appInfo = _ref17.appInfo, portalHostname = _ref17.portalHostname, user = _ref17.user;
                  _ref18 = appInfo || {}, appId = _ref18.appId;
                  _ref19 = user || {}, username = _ref19.username;

                  if (appId && portalHostname) {
                    portalUrl = "https://".concat(portalHostname, "/sharing");
                    clientId = appId;
                    _ref20 = accountManagerState.status || {}, authProps = _ref20.authProps;
                    _ref21 = authProps || {
                      popup: false
                    }, redirectUri = _ref21.redirectUri, popup = _ref21.popup;
                    originRoute = window.location.href;

                    if (redirectUri) {
                      //set localstorage status
                      (0, _accountManagerStorageUtils.beginStatusStorage)(managerName, {
                        clientId: clientId,
                        redirectUri: redirectUri,
                        portalUrl: portalUrl,
                        popup: popup
                      }, originRoute); //begin login

                      (0, _accountManagerUtils.beginLogin)(managerName, {
                        clientId: clientId,
                        redirectUri: redirectUri,
                        portalUrl: portalUrl,
                        popup: popup,
                        params: {
                          force_login: true,
                          username: username
                        }
                      }, setAccountManagerState);
                    }
                  }
                }

                console.error("Cannot refresh session for account. Refresh operation failed: ".concat(response.error, ". Attempt to re-authenticate failed due to missing properties in account portal item."));
              }

            case 4:
            case "end":
              return _context5.stop();
          }
        }
      }, _callee5, this);
    }));

    return function refreshAccount() {
      return _ref15.apply(this, arguments);
    };
  }();
  /** Set the active account */


  var switchActiveAccount = (0, _react.useCallback)(function () {
    var account = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

    if (validAccount(account)) {
      (0, _accountManagerStorageUtils.switchActiveStorage)(managerName, account);
      var accountManager = (0, _accountManagerStorageUtils.getAccountManagerStorage)(managerName);
      setAccountManagerState(accountManager);
    }
  }, [accountManagerState, managerName]);
  /** Check token status */

  var verifyToken = (0, _react.useCallback)(
  /*#__PURE__*/
  function () {
    var _ref23 = _asyncToGenerator(
    /*#__PURE__*/
    regeneratorRuntime.mark(function _callee6(_ref22) {
      var session, token, _ref24, portal, result;

      return regeneratorRuntime.wrap(function _callee6$(_context6) {
        while (1) {
          switch (_context6.prev = _context6.next) {
            case 0:
              session = _ref22.session, token = _ref22.token;

              if (!(session && token)) {
                _context6.next = 16;
                break;
              }

              _context6.prev = 2;
              _ref24 = session || {}, portal = _ref24.portal;
              result = session.getToken(portal);

              if (!result) {
                _context6.next = 7;
                break;
              }

              return _context6.abrupt("return", true);

            case 7:
              return _context6.abrupt("return", false);

            case 10:
              _context6.prev = 10;
              _context6.t0 = _context6["catch"](2);
              console.error("Token status verification failed with error.  ".concat(_context6.t0));
              return _context6.abrupt("return", false);

            case 14:
              _context6.next = 17;
              break;

            case 16:
              return _context6.abrupt("return", false);

            case 17:
            case "end":
              return _context6.stop();
          }
        }
      }, _callee6, this, [[2, 10]]);
    }));

    return function (_x) {
      return _ref23.apply(this, arguments);
    };
  }(), []);
  /** Logout all accounts */

  var logoutAllAccounts = (0, _react.useCallback)(
  /*#__PURE__*/
  _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee8() {
    var accountManager;
    return regeneratorRuntime.wrap(function _callee8$(_context8) {
      while (1) {
        switch (_context8.prev = _context8.next) {
          case 0:
            Object.entries(accountManagerState.accounts).map(
            /*#__PURE__*/
            function () {
              var _ref27 = _asyncToGenerator(
              /*#__PURE__*/
              regeneratorRuntime.mark(function _callee7(_ref26) {
                var _ref28, key, account, _ref29, session, token, message, _status3;

                return regeneratorRuntime.wrap(function _callee7$(_context7) {
                  while (1) {
                    switch (_context7.prev = _context7.next) {
                      case 0:
                        _ref28 = _slicedToArray(_ref26, 2), key = _ref28[0], account = _ref28[1];
                        _ref29 = account || {}, session = _ref29.session, token = _ref29.token;

                        if (!(session && token)) {
                          _context7.next = 9;
                          break;
                        }

                        _context7.next = 5;
                        return (0, _accountManagerUtils.logout)(account);

                      case 5:
                        message = _context7.sent;
                        _status3 = JSON.stringify(message);
                        console.log("Revoke token status for account ".concat(key, ": ").concat(_status3)); //Update localStorage/ state

                        (0, _accountManagerStorageUtils.logoutAccountStorage)(managerName, account);

                      case 9:
                        return _context7.abrupt("return", account);

                      case 10:
                      case "end":
                        return _context7.stop();
                    }
                  }
                }, _callee7, this);
              }));

              return function (_x2) {
                return _ref27.apply(this, arguments);
              };
            }());
            accountManager = (0, _accountManagerStorageUtils.getAccountManagerStorage)(managerName);
            setAccountManagerState(accountManager);

          case 3:
          case "end":
            return _context8.stop();
        }
      }
    }, _callee8, this);
  })), [accountManagerState]);
  /** Remove all accounts */

  var removeAllAccounts = (0, _react.useCallback)(
  /*#__PURE__*/
  _asyncToGenerator(
  /*#__PURE__*/
  regeneratorRuntime.mark(function _callee10() {
    var accountManager;
    return regeneratorRuntime.wrap(function _callee10$(_context10) {
      while (1) {
        switch (_context10.prev = _context10.next) {
          case 0:
            Object.entries(accountManagerState.accounts).map(
            /*#__PURE__*/
            function () {
              var _ref32 = _asyncToGenerator(
              /*#__PURE__*/
              regeneratorRuntime.mark(function _callee9(_ref31) {
                var _ref33, key, account, _ref34, session, token, message, _status4;

                return regeneratorRuntime.wrap(function _callee9$(_context9) {
                  while (1) {
                    switch (_context9.prev = _context9.next) {
                      case 0:
                        _ref33 = _slicedToArray(_ref31, 2), key = _ref33[0], account = _ref33[1];
                        _ref34 = account || {}, session = _ref34.session, token = _ref34.token; //Revoke token

                        if (!(session && token)) {
                          _context9.next = 8;
                          break;
                        }

                        _context9.next = 5;
                        return (0, _accountManagerUtils.logout)(account);

                      case 5:
                        message = _context9.sent;
                        _status4 = JSON.stringify(message);
                        console.log("Revoke token status for account ".concat(key, ": ").concat(_status4));

                      case 8:
                        //Update localStorage/ state
                        (0, _accountManagerStorageUtils.removeAccountStorage)(managerName, account);
                        return _context9.abrupt("return", {});

                      case 10:
                      case "end":
                        return _context9.stop();
                    }
                  }
                }, _callee9, this);
              }));

              return function (_x3) {
                return _ref32.apply(this, arguments);
              };
            }());
            accountManager = (0, _accountManagerStorageUtils.getAccountManagerStorage)(managerName);
            setAccountManagerState(accountManager);

          case 3:
          case "end":
            return _context10.stop();
        }
      }
    }, _callee10, this);
  })), [accountManagerState]); // Helper Functions

  var validAccount = (0, _react.useCallback)(function () {
    var account = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;

    var _ref35 = account || {},
        key = _ref35.key;

    if (key) {
      var valid = accountManagerState ? accountManagerState.accounts[key] ? true : false : false;
      return valid;
    }

    var invalid = {
      warning: 'Invalid account',
      account: account,
      accountManagerState: accountManagerState
    };
    console.warn(invalid);
    return false;
  }, [accountManagerState]);
  return {
    accountManagerState: accountManagerState,
    addAccount: addAccount,
    logoutAccount: logoutAccount,
    logoutAllAccounts: logoutAllAccounts,
    removeAccount: removeAccount,
    removeAllAccounts: removeAllAccounts,
    restoreAccount: restoreAccount,
    refreshAccount: refreshAccount,
    switchActiveAccount: switchActiveAccount,
    verifyToken: verifyToken,
    getUserThumbnail: _accountManagerUtils.getUserThumbnail,
    getOrgThumbnail: _accountManagerUtils.getOrgThumbnail
  };
};
/**
 * Docs
 */


useAccountManager.propTypes = {
  /** Text object name for accountManager in local storage. */
  accountManagerName: _propTypes.default.string,

  /** Options for starting OAuth to include { clientId, redirectUri, portalUrl, popup, params }. Can also be set in addAccount function.  */
  options: _propTypes.default.object
};
useAccountManager.defaultProps = {
  accountManagerName: 'arcgis-account-manager',
  options: {
    clientId: null,
    redirectUri: null,
    portalUrl: 'https://www.arcgis.com/sharing',
    popup: false,
    params: {
      force_login: false
    }
  }
};
useAccountManager.displayName = 'useAccountManager';
var _default = useAccountManager;
exports.default = _default;