cluedin-widget/dist/25.cluedin_frame-2.3.102.js

(window["webpackJsonp"] = window["webpackJsonp"] || []).push([[25],{

/***/ 2317:
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);

// EXTERNAL MODULE: ./node_modules/react/index.js
var react = __webpack_require__(0);
var react_default = /*#__PURE__*/__webpack_require__.n(react);

// EXTERNAL MODULE: ./node_modules/connected-react-router/lib/index.js
var lib = __webpack_require__(25);

// EXTERNAL MODULE: ./node_modules/react-redux/es/index.js + 18 modules
var es = __webpack_require__(8);

// EXTERNAL MODULE: ./node_modules/recompose/es/Recompose.js
var Recompose = __webpack_require__(6);

// EXTERNAL MODULE: ./node_modules/prop-types/index.js
var prop_types = __webpack_require__(1);
var prop_types_default = /*#__PURE__*/__webpack_require__.n(prop_types);

// EXTERNAL MODULE: ./node_modules/uxi/Widget/index.js
var Widget = __webpack_require__(40);

// EXTERNAL MODULE: ./node_modules/react-intl/lib/index.es.js
var index_es = __webpack_require__(4);

// EXTERNAL MODULE: ./node_modules/uxi/Button/index.js
var Button = __webpack_require__(18);
var Button_default = /*#__PURE__*/__webpack_require__.n(Button);

// EXTERNAL MODULE: ./node_modules/uxi/Base/index.js
var Base = __webpack_require__(72);

// EXTERNAL MODULE: ./core/modules/core/components/composites/form/LeftFormDecorator.js
var LeftFormDecorator = __webpack_require__(146);

// CONCATENATED MODULE: ./core/modules/sso/components/composites/SSOViewWhenUsingSSO.js






var SSOViewWhenUsingSSOStyle = {
  topSpacer: {
    marginTop: '15px'
  }
};

var SSOViewWhenUsingSSO_SSOViewWhenUsingSSO = function SSOViewWhenUsingSSO(_ref) {
  var onNavigate = _ref.onNavigate,
      currentSSOProvider = _ref.currentSSOProvider,
      selectedProvider = _ref.selectedProvider;
  var loginUrlContent;
  var logoutUrlContent;
  var changePasswordUrlContent;
  var issuerUrlContent;

  if (currentSSOProvider.LoginUrl) {
    loginUrlContent = react_default.a.createElement(LeftFormDecorator["a" /* default */], {
      label: react_default.a.createElement(index_es["FormattedMessage"], {
        id: "SSOViewWhenUsingSSO_LoginUrl"
      })
    }, currentSSOProvider.LoginUrl);
  }

  if (currentSSOProvider.LogoutUrl) {
    logoutUrlContent = react_default.a.createElement(LeftFormDecorator["a" /* default */], {
      label: react_default.a.createElement(index_es["FormattedMessage"], {
        id: "SSOViewWhenUsingSSO_LogoutUrl"
      })
    }, currentSSOProvider.LogoutUrl);
  }

  if (currentSSOProvider.ChangePasswordUrl) {
    changePasswordUrlContent = react_default.a.createElement(LeftFormDecorator["a" /* default */], {
      label: react_default.a.createElement(index_es["FormattedMessage"], {
        id: "SSOViewWhenUsingSSO_ChangePasswordUrl"
      })
    }, currentSSOProvider.ChangePasswordUrl);
  }

  if (currentSSOProvider.IssuerUrl) {
    issuerUrlContent = react_default.a.createElement(LeftFormDecorator["a" /* default */], {
      label: react_default.a.createElement(index_es["FormattedMessage"], {
        id: "SSOViewWhenUsingSSO_IssuerUrl"
      })
    }, currentSSOProvider.IssuerUrl);
  }

  return react_default.a.createElement(Base["DivPadding"], {
    padding: "S"
  }, react_default.a.createElement(LeftFormDecorator["a" /* default */], {
    label: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewWhenUsingSSO_AuthLabel"
    })
  }, react_default.a.createElement("div", null, selectedProvider.Name)), loginUrlContent, logoutUrlContent, changePasswordUrlContent, issuerUrlContent, react_default.a.createElement(LeftFormDecorator["a" /* default */], null, react_default.a.createElement("div", {
    style: SSOViewWhenUsingSSOStyle.topSpacer
  }, react_default.a.createElement(Button_default.a, {
    click: onNavigate,
    type: "primary",
    message: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewWhenUsingSSO_Action"
    })
  }))));
};

SSOViewWhenUsingSSO_SSOViewWhenUsingSSO.propTypes = {
  onNavigate: prop_types_default.a.func.isRequired,
  selectedProvider: prop_types_default.a.object.isRequired
};
SSOViewWhenUsingSSO_SSOViewWhenUsingSSO.defaultProps = {
  selectedProvider: {}
};
/* harmony default export */ var composites_SSOViewWhenUsingSSO = (SSOViewWhenUsingSSO_SSOViewWhenUsingSSO);
// EXTERNAL MODULE: ./node_modules/uxi/Alert/index.js
var Alert = __webpack_require__(24);
var Alert_default = /*#__PURE__*/__webpack_require__.n(Alert);

// EXTERNAL MODULE: ./node_modules/uxi/Layout/Flex.js
var Flex = __webpack_require__(54);
var Flex_default = /*#__PURE__*/__webpack_require__.n(Flex);

// EXTERNAL MODULE: ./core/config/index.js + 4 modules
var config = __webpack_require__(11);

// CONCATENATED MODULE: ./core/modules/sso/components/composites/SSOViewWhenUsingCluedin.js









var SSOViewWhenUsingCluedInStyle = {
  topSpacer: {
    marginTop: '15px'
  },
  domain: {
    fontWeight: 'bold'
  }
};

var SSOViewWhenUsingCluedin_SSOViewWhenUsingCluedIn = function SSOViewWhenUsingCluedIn(_ref) {
  var hasTeamDomain = _ref.hasTeamDomain,
      clientId = _ref.clientId,
      onNavigate = _ref.onNavigate,
      domain = _ref.domain;
  var content;

  if (hasTeamDomain && domain) {
    content = react_default.a.createElement("div", null, react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewWhenUsingCluedIn_hasTeamDomainPart1"
    }), react_default.a.createElement("span", {
      style: SSOViewWhenUsingCluedInStyle.domain
    }, "@", domain), react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewWhenUsingCluedIn_hasTeamDomainPart2"
    }), react_default.a.createElement("a", {
      href: config["g" /* location */].goToSignUp(clientId)
    }, react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewWhenUsingCluedIn_hasTeamDomainPart3"
    })), ".");
  } else if (hasTeamDomain && !domain) {
    content = react_default.a.createElement(Alert_default.a, {
      type: "danger"
    }, react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewWhenUsingCluedIn_AllowDomainSignupWithoutDomain"
    }));
  } else {
    content = react_default.a.createElement("div", null, react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewWhenUsingCluedIn_NoAllowDomainSignup"
    }));
  }

  return react_default.a.createElement(Base["DivPadding"], {
    padding: "S"
  }, react_default.a.createElement(LeftFormDecorator["a" /* default */], {
    label: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewWhenUsingCluedIn_LabelAuthType"
    })
  }, react_default.a.createElement("div", null, react_default.a.createElement(index_es["FormattedMessage"], {
    id: "SSOViewWhenUsingCluedIn_UserNameAndPassword"
  }))), react_default.a.createElement(LeftFormDecorator["a" /* default */], {
    label: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewWhenUsingCluedIn_EmailDomain"
    })
  }, content), react_default.a.createElement(Flex_default.a, {
    style: {
      paddingTop: '16px',
      borderTop: '1px solid #cecece',
      justifyContent: 'flex-end'
    }
  }, react_default.a.createElement(Button_default.a, {
    click: onNavigate,
    className: "__test_change-authentication-type",
    type: "primary",
    message: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewWhenUsingCluedIn_ChangeAction"
    })
  })));
};

SSOViewWhenUsingCluedin_SSOViewWhenUsingCluedIn.displayName = 'SSOViewWhenUsingCluedIn';
SSOViewWhenUsingCluedin_SSOViewWhenUsingCluedIn.propTypes = {
  hasTeamDomain: prop_types_default.a.bool.isRequired,
  clientId: prop_types_default.a.string.isRequired,
  onNavigate: prop_types_default.a.func.isRequired,
  domain: prop_types_default.a.string.isRequired
};
/* harmony default export */ var SSOViewWhenUsingCluedin = (SSOViewWhenUsingCluedin_SSOViewWhenUsingCluedIn);
// CONCATENATED MODULE: ./core/modules/sso/components/composites/SSOView.js







var SSOView_SSOView = function SSOView(_ref) {
  var teamDomain = _ref.teamDomain,
      hasTeamDomain = _ref.hasTeamDomain,
      domain = _ref.domain,
      clientId = _ref.clientId,
      navigate = _ref.navigate,
      isFetching = _ref.isFetching,
      isUsingSSO = _ref.isUsingSSO,
      currentSSOProvider = _ref.currentSSOProvider,
      selectedProvider = _ref.selectedProvider;
  var widgetContent;

  if (isUsingSSO) {
    widgetContent = !isFetching ? react_default.a.createElement(composites_SSOViewWhenUsingSSO, {
      onNavigate: navigate,
      currentSSOProvider: currentSSOProvider,
      provider: teamDomain.SingleSignOn // should use from call https://release23.auth.cluedin-test.online/api/account/sso?subdomain=[clientId]
      ,
      selectedProvider: selectedProvider
    }) : null;
  } else {
    widgetContent = !isFetching ? react_default.a.createElement(SSOViewWhenUsingCluedin, {
      hasTeamDomain: hasTeamDomain,
      domain: domain,
      clientId: clientId,
      onNavigate: navigate
    }) : null;
  }

  return react_default.a.createElement(Widget["Widget"], {
    style: {
      background: '#fff',
      marginBottom: '30px'
    },
    isLoading: isFetching,
    title: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "SSOViewContainer_AuthenticationStatus"
    })
  }, widgetContent);
};

SSOView_SSOView.propTypes = {
  teamDomain: prop_types_default.a.object.isRequired,
  hasTeamDomain: prop_types_default.a.bool.isRequired,
  domain: prop_types_default.a.string.isRequired,
  clientId: prop_types_default.a.string.isRequired,
  navigate: prop_types_default.a.func.isRequired,
  selectedProvider: prop_types_default.a.object.isRequired,
  isFetching: prop_types_default.a.bool,
  isUsingSSO: prop_types_default.a.bool
};
SSOView_SSOView.defaultProps = {
  selectedProvider: {},
  isUsingSSO: false,
  isFetching: false
};
/* harmony default export */ var composites_SSOView = (SSOView_SSOView);
// EXTERNAL MODULE: ./core/modules/sso/actions.js + 1 modules
var actions = __webpack_require__(143);

// CONCATENATED MODULE: ./core/modules/sso/components/containers/SSOViewContainer.js





var EnhancedSSOView = Object(Recompose["b" /* compose */])(Object(Recompose["c" /* lifecycle */])({
  componentDidMount: function componentDidMount() {
    var fetchData = this.props.fetchData;
    fetchData();
  }
}))(composites_SSOView);

var mapToStateProps = function mapToStateProps(_ref) {
  var org = _ref.core.org,
      _ref$org = _ref.org,
      organization = _ref$org.organization,
      isFetchingOrganization = _ref$org.isFetchingOrganization,
      result = _ref.publicModule.result,
      _ref$sso = _ref.sso,
      isFetchingSSOProviders = _ref$sso.isFetchingSSOProviders,
      SSOProviders = _ref$sso.SSOProviders,
      isFetchingCurrentSSOProvider = _ref$sso.isFetchingCurrentSSOProvider,
      currentSSOProvider = _ref$sso.currentSSOProvider;
  var isFetching = isFetchingOrganization || isFetchingSSOProviders || isFetchingCurrentSSOProvider;
  var isUsingSSO = result && result.SingleSignOn;
  return {
    teamDomain: result,
    hasTeamDomain: organization && organization.AllowEmailDomainSignup,
    domain: organization ? organization.Domain : '',
    currentSSOProvider: currentSSOProvider,
    SSOProviders: SSOProviders,
    isFetching: isFetching,
    clientId: org,
    selectedProvider: !isFetching && isUsingSSO ? SSOProviders.find(function (p) {
      return p.Id === result.SingleSignOn.SingleSignOnProviderId;
    }) : undefined,
    isUsingSSO: isUsingSSO
  };
};

var SSOViewContainer_mapDispatchToProps = function mapDispatchToProps(dispatch) {
  return {
    fetchData: function fetchData() {
      dispatch(Object(actions["b" /* shouldFetchSSOProviders */])());
      dispatch(Object(actions["c" /* shouldFetchSSOValue */])());
    },
    navigate: function navigate() {
      dispatch(Object(lib["push"])('/admin/sso/settings'));
    }
  };
};

/* harmony default export */ var SSOViewContainer = (Object(es["connect"])(mapToStateProps, SSOViewContainer_mapDispatchToProps)(EnhancedSSOView));
// EXTERNAL MODULE: ./core/modules/apiToken/actions.js + 1 modules
var apiToken_actions = __webpack_require__(191);

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/extends.js
var helpers_extends = __webpack_require__(28);
var extends_default = /*#__PURE__*/__webpack_require__.n(helpers_extends);

// EXTERNAL MODULE: ./core/modules/core/components/Hocs/defaults/DefaultWrapper.js
var DefaultWrapper = __webpack_require__(292);

// EXTERNAL MODULE: ./core/modules/core/components/Hocs/defaults/withDefaultErrorHandling.js
var withDefaultErrorHandling = __webpack_require__(849);

// CONCATENATED MODULE: ./core/modules/core/components/Hocs/ListPage/withList.js
// The List Component is really the component that shows the Data
// The Filter Component is a specific Component that needs to be passed
// As the List duty is only to render data




var withList_withList = function withList(List) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  var Wrapper = options.Wrapper ? options.Wrapper : DefaultWrapper["a" /* default */];
  var DefaultErrorHandling = Object(withDefaultErrorHandling["b" /* default */])(options);
  var FilterBar = options.FilterBar ? options.FilterBar : null;
  return function (props) {
    return react_default.a.createElement(Wrapper, props, FilterBar && react_default.a.createElement(FilterBar, props), react_default.a.createElement(List, props), react_default.a.createElement(DefaultErrorHandling, props));
  };
};

/* harmony default export */ var ListPage_withList = (withList_withList);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/taggedTemplateLiteral.js
var taggedTemplateLiteral = __webpack_require__(7);
var taggedTemplateLiteral_default = /*#__PURE__*/__webpack_require__.n(taggedTemplateLiteral);

// EXTERNAL MODULE: ./node_modules/styled-components/dist/styled-components.browser.es.js
var styled_components_browser_es = __webpack_require__(5);

// CONCATENATED MODULE: ./core/modules/apiToken/components/composites/APITokenListWrapper.js


function _templateObject() {
  var data = taggedTemplateLiteral_default()(["\n  padding: 15px;\n  border-bottom: 1px solid #ccc;\n"]);

  _templateObject = function _templateObject() {
    return data;
  };

  return data;
}




var WrapperDiv = styled_components_browser_es["default"].div(_templateObject());

var APITokenListWrapper_TokenWrapper = function TokenWrapper(_ref) {
  var children = _ref.children;
  return react_default.a.createElement(WrapperDiv, null, react_default.a.createElement("h3", null, react_default.a.createElement(index_es["FormattedMessage"], {
    id: "APITokenViewContainer_listOfTokens"
  })), children);
};

/* harmony default export */ var APITokenListWrapper = (APITokenListWrapper_TokenWrapper);
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/objectSpread.js
var objectSpread = __webpack_require__(2);
var objectSpread_default = /*#__PURE__*/__webpack_require__.n(objectSpread);

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/classCallCheck.js
var classCallCheck = __webpack_require__(12);
var classCallCheck_default = /*#__PURE__*/__webpack_require__.n(classCallCheck);

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/createClass.js
var createClass = __webpack_require__(13);
var createClass_default = /*#__PURE__*/__webpack_require__.n(createClass);

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js
var possibleConstructorReturn = __webpack_require__(14);
var possibleConstructorReturn_default = /*#__PURE__*/__webpack_require__.n(possibleConstructorReturn);

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/getPrototypeOf.js
var getPrototypeOf = __webpack_require__(15);
var getPrototypeOf_default = /*#__PURE__*/__webpack_require__.n(getPrototypeOf);

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/inherits.js
var inherits = __webpack_require__(16);
var inherits_default = /*#__PURE__*/__webpack_require__.n(inherits);

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/assertThisInitialized.js
var assertThisInitialized = __webpack_require__(27);
var assertThisInitialized_default = /*#__PURE__*/__webpack_require__.n(assertThisInitialized);

// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/defineProperty.js
var defineProperty = __webpack_require__(3);
var defineProperty_default = /*#__PURE__*/__webpack_require__.n(defineProperty);

// EXTERNAL MODULE: ./node_modules/uxi/Icons/index.js
var Icons = __webpack_require__(9);

// EXTERNAL MODULE: ./node_modules/uxi/Indicator/index.js
var Indicator = __webpack_require__(43);

// CONCATENATED MODULE: ./core/modules/apiToken/components/composites/APITokenViewStyle.style.js
/* harmony default export */ var APITokenViewStyle_style = ({
  wrapper: {
    padding: '15px',
    borderBottom: '1px solid #ccc'
  },
  vAlignChildren: {
    display: 'flex',
    alignItems: 'center',
    flexFlow: 'row wrap',
    margin: 0,
    justifyContent: 'center'
  },
  generateTokenForm: {
    margin: '30px 0',
    display: 'flex',
    alignItems: 'center',
    justifyContent: 'flex-start',
    flexFlow: 'row'
  },
  generateTokenFormSubmit: {
    marginLeft: 'auto'
  }
});
// EXTERNAL MODULE: ./node_modules/rc-tooltip/es/index.js + 36 modules
var rc_tooltip_es = __webpack_require__(56);

// EXTERNAL MODULE: ./core/modules/core/helpers/dom.js
var dom = __webpack_require__(291);

// CONCATENATED MODULE: ./core/modules/apiToken/components/composites/SecretInput.js















var styles = {
  wrapper: {
    display: 'flex',
    alignItems: 'center',
    margin: 0,
    flexFlow: 'row wrap'
  },
  input: {
    fontSize: '16px',
    padding: '7px 12px',
    flexGrow: '9',
    borderRadius: 0,
    maxWidth: '310px',
    border: '1px solid #d7d7d8',
    borderLeft: 'none',
    borderRight: 'none'
  },
  showHideBtn: {
    borderRadius: '3px 0 0 3px',
    minHeight: '34px'
  },
  pbCopyBtn: {
    borderRadius: '0 3px 3px 0',
    minHeight: '34px'
  }
};
var SecretInput_SecretInput =
/*#__PURE__*/
function (_Component) {
  inherits_default()(SecretInput, _Component);

  function SecretInput() {
    var _getPrototypeOf2;

    var _this;

    classCallCheck_default()(this, SecretInput);

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    _this = possibleConstructorReturn_default()(this, (_getPrototypeOf2 = getPrototypeOf_default()(SecretInput)).call.apply(_getPrototypeOf2, [this].concat(args)));

    defineProperty_default()(assertThisInitialized_default()(assertThisInitialized_default()(_this)), "state", {
      shown: false,
      copied: false
    });

    return _this;
  }

  createClass_default()(SecretInput, [{
    key: "handleCopyToClipBoard",
    value: function handleCopyToClipBoard() {
      var _this2 = this;

      Object(dom["a" /* copyToClipboard */])(this.props.token);
      this.setState({
        copied: true
      });
      var timeRef = setTimeout(function () {
        _this2.setState({
          copied: false
        });

        window.clearTimeout(timeRef);
      }, 2200);
    }
  }, {
    key: "toggleVisibility",
    value: function toggleVisibility() {
      this.setState({
        shown: !this.state.shown
      });
    }
  }, {
    key: "render",
    value: function render() {
      var token = this.props.token;
      var _this$state = this.state,
          shown = _this$state.shown,
          copied = _this$state.copied;
      var type = shown ? 'text' : 'password';
      var revealLabel = shown ? react_default.a.createElement(Icons["Visibilityunabled"], {
        size: "18"
      }) : react_default.a.createElement(Icons["Visibility"], {
        size: "18"
      });
      var copiedMsg = copied ? react_default.a.createElement(index_es["FormattedMessage"], {
        id: "APITokenViewContainer_copiedToClipboard"
      }) : react_default.a.createElement(index_es["FormattedMessage"], {
        id: "APITokenViewContainer_copyToClipboard"
      });
      var pbCopyIconBtn = react_default.a.createElement(rc_tooltip_es["default"], {
        placement: "top",
        trigger: "hover",
        overlay: copiedMsg
      }, react_default.a.createElement(Icons["Pbcopy"], {
        size: "18"
      }));
      return react_default.a.createElement("div", {
        style: styles.wrapper
      }, react_default.a.createElement(Button_default.a, {
        style: objectSpread_default()({}, styles.showHideBtn),
        message: revealLabel,
        click: this.toggleVisibility.bind(this)
      }), react_default.a.createElement("input", {
        style: styles.input,
        type: type,
        value: token
      }), react_default.a.createElement(Button_default.a, {
        style: objectSpread_default()({}, styles.pbCopyBtn),
        message: pbCopyIconBtn,
        click: this.handleCopyToClipBoard.bind(this)
      }));
    }
  }]);

  return SecretInput;
}(react["Component"]);

defineProperty_default()(SecretInput_SecretInput, "propTypes", {
  token: prop_types_default.a.string.isRequired
});

/* harmony default export */ var composites_SecretInput = (SecretInput_SecretInput);
// EXTERNAL MODULE: ./node_modules/uxi/Dialog/index.js
var Dialog = __webpack_require__(68);
var Dialog_default = /*#__PURE__*/__webpack_require__.n(Dialog);

// EXTERNAL MODULE: ./node_modules/uxi/Panel/index.js
var Panel = __webpack_require__(34);

// CONCATENATED MODULE: ./core/modules/apiToken/components/composites/APITokenRemovalConfirm.js






var APITokenRemovalConfirm_ApiTokenRemovalConfirm = function ApiTokenRemovalConfirm(_ref) {
  var tokenLabel = _ref.tokenLabel,
      onClose = _ref.onClose,
      onConfirm = _ref.onConfirm,
      show = _ref.show;
  return react_default.a.createElement(Dialog_default.a, {
    title: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "APITokenViewContainer_areYouSureAboutRevoking",
      values: {
        tokenLabel: tokenLabel
      }
    }),
    show: show,
    onClose: onClose
  }, react_default.a.createElement(Panel["PanelHeader"], {
    title: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "APITokenViewContainer_dialogRevokeWarning"
    }),
    style: {
      background: '#d13f48'
    },
    hasClose: true
  }), react_default.a.createElement(Panel["PanelContent"], {
    style: {
      padding: '30px'
    }
  }, react_default.a.createElement(index_es["FormattedMessage"], {
    id: "APITokenViewContainer_dialogRevokeWarning"
  })), react_default.a.createElement(Panel["PanelFooter"], {
    onClose: onClose,
    hasCancel: true
  }, react_default.a.createElement(Button_default.a, {
    className: "__test_integration_tokenList_dialogRevoque",
    message: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "APITokenViewContainer_dialogYesRevoke"
    }),
    type: "danger",
    onClick: onConfirm
  })));
};

/* harmony default export */ var APITokenRemovalConfirm = (APITokenRemovalConfirm_ApiTokenRemovalConfirm);
// CONCATENATED MODULE: ./core/modules/apiToken/components/composites/APITokenListItem.js















 // eslint-disable-line import/no-named-as-default


var APITokenListItem_APITokenListItem =
/*#__PURE__*/
function (_Component) {
  inherits_default()(APITokenListItem, _Component);

  function APITokenListItem() {
    var _getPrototypeOf2;

    var _this;

    classCallCheck_default()(this, APITokenListItem);

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    _this = possibleConstructorReturn_default()(this, (_getPrototypeOf2 = getPrototypeOf_default()(APITokenListItem)).call.apply(_getPrototypeOf2, [this].concat(args)));

    defineProperty_default()(assertThisInitialized_default()(assertThisInitialized_default()(_this)), "state", {
      open: false
    });

    defineProperty_default()(assertThisInitialized_default()(assertThisInitialized_default()(_this)), "handleOpen", function () {
      _this.setState({
        open: true
      });
    });

    defineProperty_default()(assertThisInitialized_default()(assertThisInitialized_default()(_this)), "handleClose", function () {
      _this.setState({
        open: false
      });
    });

    return _this;
  }

  createClass_default()(APITokenListItem, [{
    key: "handleRevokeTokenRequest",
    value: function handleRevokeTokenRequest() {
      var Id = this.props.currentApiToken.Id;
      this.props.onShouldRevokeToken(Id);
      this.handleClose();
    }
  }, {
    key: "render",
    value: function render() {
      var _this$props = this.props,
          currentApiToken = _this$props.currentApiToken,
          Name = _this$props.currentApiToken.Name,
          isFetchingGenerateApiToken = _this$props.isFetchingGenerateApiToken;
      var token = currentApiToken.AccessToken;
      var loadingSpinner = isFetchingGenerateApiToken ? react_default.a.createElement(Indicator["Loader"], null) : null;
      var tokenLabel = "".concat(Name);
      var revokeBtnMsg = react_default.a.createElement(index_es["FormattedMessage"], {
        id: "APITokenViewContainer_revoke"
      });
      return react_default.a.createElement("div", {
        className: "__test_integration_apiTokenListItem-".concat(Name),
        style: {
          marginBottom: '16px'
        }
      }, react_default.a.createElement("h5", null, tokenLabel), react_default.a.createElement("div", {
        style: objectSpread_default()({}, APITokenViewStyle_style.vAlignChildren, {
          alignItems: 'initial'
        })
      }, react_default.a.createElement("div", {
        style: {
          marginRight: 'auto',
          flexGrow: 9,
          paddingRight: '16px'
        }
      }, react_default.a.createElement(composites_SecretInput, {
        token: token
      })), react_default.a.createElement("span", {
        style: {
          marginLeft: 'auto',
          display: 'flex',
          alignItems: 'center'
        }
      }, loadingSpinner, react_default.a.createElement(Button_default.a, {
        className: "__test_integration_apiTokenListItem_revoqueBtn",
        click: this.handleOpen,
        message: revokeBtnMsg,
        icon: react_default.a.createElement(Icons["Delete"], null)
      }))), react_default.a.createElement(APITokenRemovalConfirm, {
        show: this.state.open,
        onClose: this.handleClose.bind(this),
        onConfirm: this.handleRevokeTokenRequest.bind(this)
      }));
    }
  }]);

  return APITokenListItem;
}(react["Component"]);
APITokenListItem_APITokenListItem.propTypes = {
  currentApiToken: prop_types_default.a.object.isRequired,
  isFetchingGenerateApiToken: prop_types_default.a.bool.isRequired
};
/* harmony default export */ var composites_APITokenListItem = (Object(index_es["injectIntl"])(APITokenListItem_APITokenListItem));
// CONCATENATED MODULE: ./core/modules/apiToken/components/composites/APITokenList.js


/* eslint-disable import/no-named-as-default */




var APITokenList_APITokenList = function APITokenList(props) {
  return react_default.a.createElement("div", null, props.currentApiTokens.filter(function (t) {
    return t.Active;
  }).map(function (t, i) {
    return react_default.a.createElement(composites_APITokenListItem, extends_default()({
      currentApiToken: t,
      index: i
    }, props));
  }));
};
APITokenList_APITokenList.displayName = 'APITokenList';
/* harmony default export */ var composites_APITokenList = (ListPage_withList(APITokenList_APITokenList, {
  Wrapper: APITokenListWrapper,
  noEntitiesMessage: 'No token found',
  normalizeProps: function normalizeProps(_ref) {
    var currentApiTokens = _ref.currentApiTokens,
        isFetchingApiToken = _ref.isFetchingApiToken;
    return {
      entities: currentApiTokens.filter(function (t) {
        return t.Active;
      }),
      isFetching: isFetchingApiToken
    };
  }
}));
// EXTERNAL MODULE: ./node_modules/uxi/Input/index.js
var Input = __webpack_require__(35);

// CONCATENATED MODULE: ./core/modules/apiToken/components/composites/APITokenError.js



var linkStyles = {
  color: 'white',
  fontWeight: 'bold',
  textDecoration: 'underline'
};

var APITokenError_APITokenError = function APITokenError() {
  return react_default.a.createElement(Alert_default.a, {
    type: "danger"
  }, react_default.a.createElement(index_es["FormattedMessage"], {
    id: "APITokenViewContainer_tokenGenericErrorLine1"
  }), react_default.a.createElement("br", null), react_default.a.createElement(index_es["FormattedMessage"], {
    id: "APITokenViewContainer_tokenGenericErrorLine2"
  }), react_default.a.createElement("br", null), react_default.a.createElement(index_es["FormattedMessage"], {
    id: "APITokenViewContainer_contactSupport",
    values: {
      support: react_default.a.createElement("a", {
        style: linkStyles,
        href: "mailto:support@cluedin.com"
      }, react_default.a.createElement(index_es["FormattedMessage"], {
        id: "APITokenViewContainer_support"
      }))
    }
  }));
};

/* harmony default export */ var composites_APITokenError = (APITokenError_APITokenError);
// CONCATENATED MODULE: ./core/modules/apiToken/components/composites/APITokenGenerateConfirm.js






var APITokenGenerateConfirm_APITokenGenerateConfirm = function APITokenGenerateConfirm(_ref) {
  var open = _ref.open,
      onClose = _ref.onClose,
      onConfirm = _ref.onConfirm;
  return react_default.a.createElement(Dialog_default.a, {
    show: open,
    onClose: onClose
  }, react_default.a.createElement(Panel["PanelHeader"], {
    title: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "APITokenViewContainer_areYouSureAboutGenerating"
    }),
    style: {
      background: '#d13f48'
    },
    hasClose: true
  }), react_default.a.createElement(Panel["PanelContent"], {
    style: {
      padding: '30px'
    }
  }, react_default.a.createElement(index_es["FormattedMessage"], {
    id: "APITokenViewContainer_dialogGenerateWarning"
  })), react_default.a.createElement(Panel["PanelFooter"], {
    onClose: onClose,
    hasCancel: true
  }, react_default.a.createElement(Button_default.a, {
    className: "__test_integration_generateToken_dialogGenerate",
    message: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "APITokenViewContainer_dialogYesGenerate"
    }),
    type: "danger",
    onClick: onConfirm
  })));
};

/* harmony default export */ var composites_APITokenGenerateConfirm = (APITokenGenerateConfirm_APITokenGenerateConfirm);
// CONCATENATED MODULE: ./core/modules/apiToken/components/composites/APITokenGenerate.js
















var APITokenGenerate_APITokenGenerate =
/*#__PURE__*/
function (_Component) {
  inherits_default()(APITokenGenerate, _Component);

  function APITokenGenerate() {
    var _getPrototypeOf2;

    var _this;

    classCallCheck_default()(this, APITokenGenerate);

    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    _this = possibleConstructorReturn_default()(this, (_getPrototypeOf2 = getPrototypeOf_default()(APITokenGenerate)).call.apply(_getPrototypeOf2, [this].concat(args)));

    defineProperty_default()(assertThisInitialized_default()(assertThisInitialized_default()(_this)), "state", {
      open: false,
      tokenLabel: ''
    });

    defineProperty_default()(assertThisInitialized_default()(assertThisInitialized_default()(_this)), "handleOpen", function () {
      if (_this.state.tokenLabel && _this.state.isTokenValid) {
        _this.setState({
          open: true
        });
      } else {
        _this.setState({
          isTokenValid: false
        });
      }
    });

    defineProperty_default()(assertThisInitialized_default()(assertThisInitialized_default()(_this)), "handleClose", function () {
      _this.setState({
        open: false
      });
    });

    return _this;
  }

  createClass_default()(APITokenGenerate, [{
    key: "handleTokenLabelchange",
    value: function handleTokenLabelchange(e) {
      var value = e.target.value;
      var currentApiTokens = this.props.currentApiTokens;
      var isTokenValid = value.length > 2 && value.length <= 20;
      var isTokenUnique = !currentApiTokens.find(function (t) {
        return t.Name === value;
      });
      this.setState({
        tokenLabel: value,
        isTokenValid: isTokenValid,
        isTokenUnique: isTokenUnique
      });
    }
  }, {
    key: "handleGenerateTokenRequest",
    value: function handleGenerateTokenRequest() {
      var tokenLabel = this.state.tokenLabel;
      this.props.onShouldGenerateToken(tokenLabel);
      this.handleClose();
      this.setState({
        tokenLabel: ''
      });
    }
  }, {
    key: "render",
    value: function render() {
      var _this$props = this.props,
          somethingOddWithApiToken = _this$props.somethingOddWithApiToken,
          isFetchingGenerateApiToken = _this$props.isFetchingGenerateApiToken;
      var _this$state = this.state,
          tokenLabel = _this$state.tokenLabel,
          isTokenValid = _this$state.isTokenValid,
          isTokenUnique = _this$state.isTokenUnique,
          open = _this$state.open;
      var loadingSpinner = isFetchingGenerateApiToken === true ? react_default.a.createElement(Indicator["Loader"], {
        style: {
          marginRight: '15px'
        }
      }) : null;
      var errorContent = somethingOddWithApiToken ? react_default.a.createElement(composites_APITokenError, null) : null;
      var sectionTitleMsg = react_default.a.createElement(index_es["FormattedMessage"], {
        id: "APITokenViewContainer_generateTokens"
      });
      var tokenValidationErrorMsg = isTokenValid === false ? react_default.a.createElement(index_es["FormattedMessage"], {
        id: "APITokenViewContainer_generate_tokenValidationErrorText"
      }) : null;
      var notUniqueTokenErrorMsg = isTokenUnique === false ? react_default.a.createElement(index_es["FormattedMessage"], {
        id: "APITokenViewContainer_generate_tokenLabelAlreadyUsed"
      }) : null;
      return react_default.a.createElement("div", {
        style: APITokenViewStyle_style.wrapper
      }, errorContent, react_default.a.createElement("h3", null, sectionTitleMsg), react_default.a.createElement("p", null, react_default.a.createElement(index_es["FormattedMessage"], {
        id: "APITokenViewContainer_generate_instructions"
      })), react_default.a.createElement("div", {
        style: APITokenViewStyle_style.generateTokenForm
      }, react_default.a.createElement("div", null, react_default.a.createElement(index_es["FormattedMessage"], {
        id: "APITokenViewContainer_generate_tokenNameLabel"
      })), react_default.a.createElement("div", {
        style: {
          margin: '0 30px'
        }
      }, react_default.a.createElement(Input["TextField"], {
        className: "__test_integration_setNewTokenLabel",
        type: "text",
        value: tokenLabel,
        placeholder: "token name",
        isFullWidth: true,
        onChange: this.handleTokenLabelchange.bind(this),
        errorText: tokenValidationErrorMsg || notUniqueTokenErrorMsg
      })), react_default.a.createElement("div", {
        style: APITokenViewStyle_style.vAlignChildren
      }, loadingSpinner, react_default.a.createElement("div", {
        className: "__test_integration_generateToken",
        style: APITokenViewStyle_style.generateTokenFormSubmit
      }, react_default.a.createElement(Button_default.a, {
        click: this.handleOpen.bind(this),
        type: "primary",
        disabled: !isTokenValid || !isTokenUnique,
        message: react_default.a.createElement(index_es["FormattedMessage"], {
          id: "APITokenViewContainer_generate"
        })
      })))), react_default.a.createElement("p", null, react_default.a.createElement(index_es["FormattedMessage"], {
        id: "APITokenViewContainer_explanation"
      })), react_default.a.createElement("p", null, "You can find our API documentation at\xA0", react_default.a.createElement("a", {
        href: "https://cluedin.docs.apiary.io/",
        alt: "ClueIn API documentation",
        target: "_blank",
        rel: "noreferrer noopener"
      }, "cluedin.docs.apiary.io")), react_default.a.createElement(composites_APITokenGenerateConfirm, {
        open: open,
        onConfirm: this.handleGenerateTokenRequest.bind(this),
        onClose: this.handleClose.bind(this)
      }));
    }
  }]);

  return APITokenGenerate;
}(react["Component"]);

defineProperty_default()(APITokenGenerate_APITokenGenerate, "propTypes", {
  somethingOddWithApiToken: prop_types_default.a.bool.isRequired,
  isFetchingGenerateApiToken: prop_types_default.a.bool.isRequired,
  onShouldGenerateToken: prop_types_default.a.func.isRequired
});

/* harmony default export */ var composites_APITokenGenerate = (APITokenGenerate_APITokenGenerate);
// CONCATENATED MODULE: ./core/modules/apiToken/components/composites/APITokenView.js


/* eslint-disable import/no-named-as-default */







var APITokenView_APITokenView = function APITokenView(props) {
  return react_default.a.createElement(Widget["Widget"], {
    isLoading: props.isFetchingApiToken,
    style: {
      background: '#fff'
    },
    title: react_default.a.createElement(index_es["FormattedMessage"], {
      id: "APITokenViewContainer_header"
    })
  }, react_default.a.createElement(composites_APITokenGenerate, extends_default()({
    key: "0"
  }, props)), react_default.a.createElement(composites_APITokenList, extends_default()({
    key: "1"
  }, props)));
};

APITokenView_APITokenView.propTypes = {
  isFetchingApiToken: prop_types_default.a.bool.isRequired
};
APITokenView_APITokenView.defaultProps = {
  currentApiTokens: []
};
/* harmony default export */ var composites_APITokenView = (APITokenView_APITokenView);
// CONCATENATED MODULE: ./core/modules/apiToken/components/containers/APITokenViewContainer.js




var APITokenViewContainer = Object(Recompose["b" /* compose */])(Object(Recompose["c" /* lifecycle */])({
  componentDidMount: function componentDidMount() {
    var onShouldFetchApiToken = this.props.onShouldFetchApiToken;
    onShouldFetchApiToken();
  }
}))(composites_APITokenView);
var APITokenViewContainer_select = function select(_ref) {
  var apiToken = _ref.apiToken;
  return {
    currentApiTokens: apiToken.currentApiTokens,
    isFetchingApiToken: apiToken.isFetchingApiToken,
    isFetchingRevokeApiToken: apiToken.isFetchingRevokeApiToken,
    somethingOddWithApiToken: apiToken.somethingOddWithApiToken,
    isFetchingGenerateApiToken: apiToken.isFetchingGenerateApiToken
  };
};
var APITokenViewContainer_mapDispatchToProps = function mapDispatchToProps(dispatch) {
  return {
    onShouldFetchApiToken: function onShouldFetchApiToken() {
      return dispatch(Object(apiToken_actions["h" /* shouldFetchApiToken */])());
    },
    onShouldGenerateToken: function onShouldGenerateToken(tokenLabel) {
      return dispatch(Object(apiToken_actions["i" /* shouldGenerateToken */])(tokenLabel));
    },
    onShouldRevokeToken: function onShouldRevokeToken(token) {
      return dispatch(Object(apiToken_actions["j" /* shouldRevokeToken */])(token));
    }
  };
};
/* harmony default export */ var containers_APITokenViewContainer = (Object(es["connect"])(APITokenViewContainer_select, APITokenViewContainer_mapDispatchToProps)(APITokenViewContainer));
// CONCATENATED MODULE: ./core/modules/organization/components/pages/Settings.js


 // eslint-disable-line import/no-named-as-default

var Settings_Settings = function Settings() {
  return react_default.a.createElement("div", null, react_default.a.createElement(SSOViewContainer, null), react_default.a.createElement(containers_APITokenViewContainer, null));
};

/* harmony default export */ var pages_Settings = __webpack_exports__["default"] = (Settings_Settings);

/***/ })

}]);