@zengenti/contensis-react-base 3.0.2-beta.9 → 3.1.1-beta.0

package/cjs/{login-51b66359.js → ChangePassword.container-f3f94d8f.js}

@@ -2,11 +2,13 @@
 
 var effects = require('@redux-saga/core/effects');
 var reducers = require('./reducers-9afb5f89.js');
-var ToJs = require('./ToJs-61c03582.js');
-var selectors = require('./selectors-c76c2676.js');
+var ToJs = require('./ToJs-64970869.js');
+var selectors = require('./selectors-8e56cc34.js');
 var mapJson = require('jsonpath-mapper');
-var awaitToJs = require('await-to-js');
-var JSCookie = require('js-cookie');
+var to = require('await-to-js');
+var CookieConstants = require('./CookieConstants-000427db.js');
+var reactCookie = require('react-cookie');
+var reactRedux = require('react-redux');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -29,7 +31,6 @@ function _interopNamespace(e) {
 }
 
 var mapJson__default = /*#__PURE__*/_interopDefaultLegacy(mapJson);
-var JSCookie__default = /*#__PURE__*/_interopDefaultLegacy(JSCookie);
 
 const findContentTypeMapping = (ContentTypeMappings, contentTypeId) => ContentTypeMappings.find(ct => ct.contentTypeID === contentTypeId);
 
@@ -77,9 +78,15 @@ const getManagementApiClient = async ({
       }
     };
   }
-  const {
+  let {
     Client
   } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('contensis-management-api')); });
+  if (typeof window === 'undefined') {
+    const {
+      UniversalClient
+    } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('contensis-management-api')); });
+    Client = UniversalClient;
+  }
   const client = Client.create({
     ...config,
     projectId,
@@ -93,32 +100,6 @@ const getManagementApiClient = async ({
   return client;
 };
 
-const COOKIE_VALID_DAYS = 1; // 0 = Session cookie
-
-// Override the default js-cookie conversion / encoding
-// methods so the written values work with Contensis sites
-const Cookies = JSCookie__default["default"].withConverter({
-  read: value => decodeURIComponent(value),
-  write: value => encodeURIComponent(value)
-});
-class CookieHelper {
-  static GetCookie(name) {
-    const cookie = Cookies.get(name);
-    if (typeof cookie === 'undefined') {
-      return null;
-    }
-    return cookie;
-  }
-  static SetCookie(name, value, maxAgeDays = COOKIE_VALID_DAYS) {
-    if (maxAgeDays === 0) Cookies.set(name, value);else Cookies.set(name, value, {
-      expires: maxAgeDays
-    });
-  }
-  static DeleteCookie(name) {
-    Cookies.remove(name);
-  }
-}
-
 const context$1 = typeof window != 'undefined' ? window : global;
 const requireOidc = process.env.NODE_ENV === 'development' ? WSFED_LOGIN === 'true' /* global WSFED_LOGIN */ : context$1.WSFED_LOGIN === 'true';
 const servers = SERVERS; /* global SERVERS */
@@ -146,30 +127,32 @@ const createUserManager = async config => {
 };
 
 /* eslint-disable require-atomic-updates */
-const LOGIN_COOKIE = 'ContensisCMSUserName';
-const REFRESH_TOKEN_COOKIE = 'RefreshToken';
 const context = typeof window != 'undefined' ? window : global;
 class LoginHelper {
-  static SetLoginCookies({
+  constructor(cookies) {
+    this.cookies = void 0;
+    this.cookies = cookies;
+  }
+  SetLoginCookies({
     contensisClassicToken,
     refreshToken
   }) {
-    console.info('SetLoginCookies:', LOGIN_COOKIE, contensisClassicToken, REFRESH_TOKEN_COOKIE, refreshToken);
-    if (contensisClassicToken) CookieHelper.SetCookie(LOGIN_COOKIE, contensisClassicToken);
-    if (refreshToken) CookieHelper.SetCookie(REFRESH_TOKEN_COOKIE, refreshToken);
+    console.info('SetLoginCookies:', CookieConstants.LOGIN_COOKIE, contensisClassicToken, CookieConstants.REFRESH_TOKEN_COOKIE, refreshToken);
+    if (contensisClassicToken) this.cookies.SetCookie(CookieConstants.LOGIN_COOKIE, contensisClassicToken);
+    if (refreshToken) this.cookies.SetCookie(CookieConstants.REFRESH_TOKEN_COOKIE, refreshToken);
   }
-  static GetCachedCredentials() {
+  GetCachedCredentials() {
     return {
       bearerToken: null,
       bearerTokenExpiryDate: null,
-      refreshToken: CookieHelper.GetCookie(REFRESH_TOKEN_COOKIE),
+      refreshToken: this.cookies.GetCookie(CookieConstants.REFRESH_TOKEN_COOKIE),
       refreshTokenExpiryDate: null,
-      contensisClassicToken: CookieHelper.GetCookie(LOGIN_COOKIE)
+      contensisClassicToken: this.cookies.GetCookie(CookieConstants.LOGIN_COOKIE)
     };
   }
-  static ClearCachedCredentials() {
-    CookieHelper.DeleteCookie(LOGIN_COOKIE);
-    CookieHelper.DeleteCookie(REFRESH_TOKEN_COOKIE);
+  ClearCachedCredentials() {
+    this.cookies.DeleteCookie(CookieConstants.LOGIN_COOKIE);
+    this.cookies.DeleteCookie(CookieConstants.REFRESH_TOKEN_COOKIE);
     if (LoginHelper.WSFED_LOGIN && typeof window !== 'undefined') {
       // remove any oidc keys left over in localStorage
       const {
@@ -183,7 +166,7 @@ class LoginHelper {
       keys.forEach(key => localStorage.removeItem(key));
     }
   }
-  static async LoginUser({
+  async LoginUser({
     username,
     password,
     clientCredentials
@@ -205,7 +188,7 @@ class LoginHelper {
       });
 
       // Ensure the client has requested a bearer token
-      const [loginError, clientBearerToken] = await awaitToJs.to(transientClient.ensureBearerToken());
+      const [loginError, clientBearerToken] = await to.to(transientClient.ensureBearerToken());
 
       // Problem getting token with username and password
       if (loginError) {
@@ -216,14 +199,14 @@ class LoginHelper {
           isAuthenticationError: loginError.name.includes('ContensisAuthenticationError'),
           isError: true
         };
-        LoginHelper.ClearCachedCredentials();
+        this.ClearCachedCredentials();
       }
 
       // Got a token using username and password
       if (clientBearerToken) {
         // Set credentials so we can continue to GetUserDetails
         credentials = mapClientCredentials(transientClient);
-        LoginHelper.SetLoginCookies(credentials);
+        this.SetLoginCookies(credentials);
         authenticationState = {
           clientCredentials: credentials,
           isAuthenticated: true,
@@ -247,11 +230,11 @@ class LoginHelper {
           isAuthenticationError: false,
           isError: true
         };
-        LoginHelper.ClearCachedCredentials();
+        this.ClearCachedCredentials();
       } else {
         // Ensure we get latest refreshToken and contensisClassicToken from the latest client
         const latestCredentials = mapClientCredentials(client);
-        LoginHelper.SetLoginCookies(latestCredentials);
+        this.SetLoginCookies(latestCredentials);
         user = userDetails;
         authenticationState = {
           clientCredentials: latestCredentials,
@@ -266,8 +249,8 @@ class LoginHelper {
       user
     };
   }
-  static LogoutUser(redirectPath) {
-    LoginHelper.ClearCachedCredentials();
+  LogoutUser(redirectPath) {
+    this.ClearCachedCredentials();
     if (LoginHelper.WSFED_LOGIN) {
       LoginHelper.WsFedLogout(redirectPath);
     } else {
@@ -289,6 +272,7 @@ class LoginHelper {
     }
   }
   static async ClientRedirectToSignInPage(redirectPath) {
+    if (typeof location === 'undefined') return;
     if (LoginHelper.WSFED_LOGIN) {
       await LoginHelper.WsFedLogout();
       await LoginHelper.WsFedLogin();
@@ -299,11 +283,13 @@ class LoginHelper {
       if (typeof location !== 'undefined' && redirectPath !== LoginHelper.LOGIN_ROUTE) location.replace(url);
     }
   }
-  static ClientRedirectToAccessDeniedPage(originalPath) {
+  static GetAccessDeniedRoute(originalPath) {
     let url = LoginHelper.ACCESS_DENIED_ROUTE;
-    if (originalPath === url) return;
-    if (typeof originalPath === 'string') url = `${url}?original_uri=${originalPath}`;
-    if (typeof location !== 'undefined') location.href = url;
+    if (originalPath !== url && typeof originalPath === 'string') url = `${url}?original_uri=${originalPath}`;
+    return url;
+  }
+  static ClientRedirectToAccessDeniedPage(originalPath) {
+    if (typeof location !== 'undefined') location.href = LoginHelper.GetAccessDeniedRoute(originalPath);
   }
   static ClientRedirectToPath(redirectPath) {
     if (typeof redirectPath === 'string') {
@@ -339,7 +325,7 @@ class LoginHelper {
     }
   }
   static async GetCredentialsForSecurityToken(securityToken) {
-    const [error, response] = await awaitToJs.to(fetch(`${LoginHelper.CMS_URL}/REST/Contensis/Security/IsAuthenticated`, {
+    const [error, response] = await to.to(fetch(`${LoginHelper.CMS_URL}/REST/Contensis/Security/IsAuthenticated`, {
       method: 'POST',
       headers: {
         Accept: 'application/json',
@@ -353,13 +339,14 @@ class LoginHelper {
       message: 'Failed to fetch credentials'
     }];
     if (response.ok) {
-      const [parseError, body] = await awaitToJs.to(response.json());
+      const [parseError, body] = await to.to(response.json());
       if (parseError) return [parseError];
       const {
         LogonResult,
         ApplicationData = []
       } = body;
       if (LogonResult !== 0) {
+        console.info(`Security token is invalid - LogonResult: ${LogonResult}`);
         return [{
           message: 'Security token is invalid',
           data: ApplicationData
@@ -402,14 +389,15 @@ LoginHelper.CMS_URL = SERVERS.cms /* global SERVERS */;
 LoginHelper.WSFED_LOGIN = process.env.NODE_ENV === 'development' ? WSFED_LOGIN === 'true' /* global WSFED_LOGIN */ : context.WSFED_LOGIN === 'true';
 LoginHelper.LOGIN_ROUTE = '/account/login';
 LoginHelper.ACCESS_DENIED_ROUTE = '/account/access-denied';
+LoginHelper.withCookies = cookieHelper => new LoginHelper(cookieHelper);
 LoginHelper.GetUserDetails = async client => {
   let userError,
     groupsError,
     user = {},
     groupsResult;
-  [userError, user] = await awaitToJs.to(client.security.users.getCurrent());
+  [userError, user] = await to.to(client.security.users.getCurrent());
   if (user && user.id) {
-    [groupsError, groupsResult] = await awaitToJs.to(client.security.users.getUserGroups({
+    [groupsError, groupsResult] = await to.to(client.security.users.getUserGroups({
       userId: user.id,
       includeInherited: true,
       pageOptions: {
@@ -431,7 +419,9 @@ const loginSagas = [effects.takeEvery(reducers.LOGIN_USER, loginUserSaga), effec
 function* handleRequiresLoginSaga(action) {
   var _entry$sys;
   const {
+    cookies,
     entry,
+    path,
     requireLogin,
     routes: {
       ContentTypeMappings
@@ -460,14 +450,18 @@ function* handleRequiresLoginSaga(action) {
     // If cookies or securityToken are found on any route change
     // always validate and login the user
     if (routeRequiresLogin) {
+      console.info(`Route requires login: ${path}`);
       // If routeRequiresLogin do a blocking call that returns userLoggedIn
       userLoggedIn = yield effects.call(validateUserSaga, {
+        cookies,
         securityToken
       });
+      console.info(`User logged in: ${userLoggedIn}`);
     }
     // otherwise do a non blocking put to handle validation in the background
     else yield effects.put({
       type: reducers.VALIDATE_USER,
+      cookies,
       securityToken
     });
   }
@@ -482,13 +476,16 @@ function* handleRequiresLoginSaga(action) {
       if (!groupMatch) LoginHelper.ClientRedirectToAccessDeniedPage(action.location.pathname);
     }
   }
+  return userLoggedIn;
 }
 function* validateUserSaga({
+  cookies,
   securityToken
 }) {
+  const login = LoginHelper.withCookies(cookies);
   // Check for refreshToken in cookies
-  let clientCredentials = LoginHelper.GetCachedCredentials();
-  if (securityToken || clientCredentials.refreshToken) {
+  let clientCredentials = login.GetCachedCredentials();
+  if (securityToken || clientCredentials.securityToken || clientCredentials.refreshToken) {
     // We only attempt to validate the user if one of the stored
     // tokens are found, in this case we set loading state manually
     // so we don't need to set and unset loading if there are no stored
@@ -500,26 +497,36 @@ function* validateUserSaga({
     });
     // If we have just a security token we will call a CMS endpoint
     // and provide us with a RefreshToken cookie we can use during login
-    const [error, refreshToken] = yield LoginHelper.GetCredentialsForSecurityToken(securityToken);
-    if (refreshToken) {
-      // Set cookies and reload values
-      LoginHelper.SetLoginCookies({
-        contensisClassicToken: securityToken,
-        refreshToken
-      });
-      clientCredentials = LoginHelper.GetCachedCredentials();
+    if (securityToken || clientCredentials.securityToken && !clientCredentials.refreshToken) {
+      const [error, refreshToken] = yield LoginHelper.GetCredentialsForSecurityToken(securityToken || clientCredentials.securityToken);
+      if (refreshToken) {
+        // Set cookies and reload values
+        login.SetLoginCookies({
+          contensisClassicToken: securityToken,
+          refreshToken
+        });
+        clientCredentials = login.GetCachedCredentials();
+      }
+      if (error) {
+        login.ClearCachedCredentials();
+        yield effects.put({
+          type: reducers.SET_AUTHENTICATION_STATE,
+          authenticationState: {
+            isError: true,
+            errorMessage: (error === null || error === void 0 ? void 0 : error.message) || error && 'toString' in error && error.toString()
+          }
+        });
+      }
     }
 
     // Log the user in if a refreshToken is found
-    if (clientCredentials.refreshToken) yield effects.call(loginUserSaga, {
-      clientCredentials
-    });else if (error) yield effects.put({
-      type: reducers.SET_AUTHENTICATION_STATE,
-      authenticationState: {
-        isError: true,
-        errorMessage: (error === null || error === void 0 ? void 0 : error.message) || error && 'toString' in error && error.toString()
-      }
-    });
+    if (clientCredentials.refreshToken) {
+      console.info(`Login user with refreshToken ${clientCredentials.refreshToken}`);
+      yield effects.call(loginUserSaga, {
+        clientCredentials,
+        cookies: login.cookies
+      });
+    }
   }
 
   // Tell any callers have we successfully logged in?
@@ -529,8 +536,10 @@ function* loginUserSaga(action = {}) {
   const {
     username,
     password,
-    clientCredentials
+    clientCredentials,
+    cookies
   } = action;
+  const login = LoginHelper.withCookies(cookies);
 
   // If a WSFED_LOGIN site has dispatched the loginUser action
   // just redirect them to the Identity Provider sign in
@@ -538,7 +547,7 @@ function* loginUserSaga(action = {}) {
   const {
     authenticationState,
     user
-  } = yield LoginHelper.LoginUser({
+  } = yield login.LoginUser({
     username,
     password,
     clientCredentials
@@ -574,13 +583,14 @@ function* redirectAfterSuccessfulLoginSaga() {
   }
 }
 function* logoutUserSaga({
-  redirectPath
+  redirectPath,
+  cookies
 }) {
   yield effects.put({
     type: reducers.SET_AUTHENTICATION_STATE,
     user: null
   });
-  yield LoginHelper.LogoutUser(redirectPath);
+  yield LoginHelper.withCookies(cookies).LogoutUser(redirectPath);
 }
 function* refreshSecurityToken() {
   const clientCredentials = yield effects.select(ToJs.selectClientCredentials, 'js');
@@ -596,10 +606,162 @@ function* refreshSecurityToken() {
   }
 }
 
+const loginUser = (username, password, cookies) => selectors.action(reducers.LOGIN_USER, {
+  username,
+  password,
+  cookies
+});
+const logoutUser = (redirectPath, cookies) => selectors.action(reducers.LOGOUT_USER, {
+  redirectPath,
+  cookies
+});
+const registerUser = (user, mappers) => selectors.action(reducers.REGISTER_USER, {
+  user,
+  mappers
+});
+const requestPasswordReset = userEmailObject => selectors.action(reducers.REQUEST_USER_PASSWORD_RESET, {
+  userEmailObject
+});
+const resetPassword = resetPasswordObject => selectors.action(reducers.RESET_USER_PASSWORD, {
+  resetPasswordObject
+});
+const changePassword = (userId, currentPassword, newPassword) => selectors.action(reducers.CHANGE_USER_PASSWORD, {
+  userId,
+  currentPassword,
+  newPassword
+});
+
+var actions = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  loginUser: loginUser,
+  logoutUser: logoutUser,
+  registerUser: registerUser,
+  requestPasswordReset: requestPasswordReset,
+  resetPassword: resetPassword,
+  changePassword: changePassword
+});
+
+const useLogin = () => {
+  const cookies = new ToJs.CookieHelper(...reactCookie.useCookies());
+  const dispatch = reactRedux.useDispatch();
+  const select = reactRedux.useSelector;
+  return {
+    loginUser: (username, password) => dispatch(loginUser(username, password, cookies)),
+    logoutUser: redirectPath => dispatch(logoutUser(redirectPath, cookies)),
+    errorMessage: select(ToJs.selectUserErrorMessage),
+    isAuthenticated: select(ToJs.selectUserIsAuthenticated),
+    isAuthenticationError: select(ToJs.selectUserIsAuthenticationError),
+    isError: select(ToJs.selectUserIsError),
+    isLoading: select(ToJs.selectUserIsLoading),
+    user: select(ToJs.selectUser),
+    // DEPRECATED: authenticationError is deprecated use isAuthenticationError instead
+    authenticationError: select(ToJs.selectUserIsAuthenticationError),
+    // DEPRECATED: authenticationErrorMessage is deprecated use errorMessage instead
+    authenticationErrorMessage: select(ToJs.selectUserErrorMessage),
+    // DEPRECATED: error is deprecated use isError instead
+    error: select(ToJs.selectUserIsError)
+  };
+};
+
+const LoginContainer = ({
+  children,
+  ...props
+}) => {
+  const userProps = useLogin();
+  return children(userProps);
+};
+LoginContainer.propTypes = {};
+var Login_container = ToJs.toJS(LoginContainer);
+
+const useRegistration = () => {
+  const dispatch = reactRedux.useDispatch();
+  const select = reactRedux.useSelector;
+  return {
+    registerUser: (user, mappers) => dispatch(registerUser(user, mappers)),
+    error: select(ToJs.selectUserRegistrationError),
+    isLoading: select(ToJs.selectUserRegistrationIsLoading),
+    isSuccess: select(ToJs.selectUserRegistrationIsSuccess),
+    user: select(ToJs.selectUserRegistration)
+  };
+};
+
+const RegistrationContainer = ({
+  children,
+  ...props
+}) => {
+  const userProps = useRegistration();
+  return children(userProps);
+};
+RegistrationContainer.propTypes = {};
+var Registration_container = ToJs.toJS(RegistrationContainer);
+
+const useForgotPassword = () => {
+  const dispatch = reactRedux.useDispatch();
+  const select = reactRedux.useSelector;
+  return {
+    isLoading: select(ToJs.selectPasswordResetRequestSending),
+    isSuccess: select(ToJs.selectPasswordResetRequestSent),
+    error: select(ToJs.selectPasswordResetRequestError),
+    requestPasswordReset: userEmailObject => dispatch(requestPasswordReset(userEmailObject)),
+    setNewPassword: {
+      queryString: select(selectors.selectCurrentSearch),
+      isLoading: select(ToJs.selectResetPasswordSending),
+      isSuccess: select(ToJs.selectResetPasswordSent),
+      error: select(ToJs.selectResetPasswordError),
+      submit: resetPasswordObject => dispatch(resetPassword(resetPasswordObject))
+    }
+  };
+};
+
+const ForgotPasswordContainer = ({
+  children,
+  ...props
+}) => {
+  const userProps = useForgotPassword();
+  return children(userProps);
+};
+ForgotPasswordContainer.propTypes = {};
+var ForgotPassword_container = ToJs.toJS(ForgotPasswordContainer);
+
+const useChangePassword = () => {
+  const dispatch = reactRedux.useDispatch();
+  const select = reactRedux.useSelector;
+  return {
+    isLoading: select(ToJs.selectChangePasswordSending),
+    isSuccess: select(ToJs.selectChangePasswordSent),
+    userId: select(ToJs.selectUserGuid),
+    isLoggedIn: select(ToJs.selectUserIsAuthenticated),
+    error: select(ToJs.selectChangePasswordError),
+    changePassword: (userId, currentPassword, newPassword) => dispatch(changePassword(userId, currentPassword, newPassword))
+  };
+};
+
+const ChangePasswordContainer = ({
+  children,
+  ...props
+}) => {
+  const userProps = useChangePassword();
+  return children(userProps);
+};
+ChangePasswordContainer.propTypes = {};
+var ChangePassword_container = ToJs.toJS(ChangePasswordContainer);
+
+exports.ChangePassword_container = ChangePassword_container;
+exports.ForgotPassword_container = ForgotPassword_container;
 exports.LoginHelper = LoginHelper;
+exports.Login_container = Login_container;
+exports.Registration_container = Registration_container;
+exports.actions = actions;
 exports.findContentTypeMapping = findContentTypeMapping;
 exports.getManagementApiClient = getManagementApiClient;
 exports.handleRequiresLoginSaga = handleRequiresLoginSaga;
 exports.loginSagas = loginSagas;
+exports.loginUser = loginUser;
+exports.logoutUser = logoutUser;
 exports.refreshSecurityToken = refreshSecurityToken;
-//# sourceMappingURL=login-51b66359.js.map
+exports.registerUser = registerUser;
+exports.useChangePassword = useChangePassword;
+exports.useForgotPassword = useForgotPassword;
+exports.useLogin = useLogin;
+exports.useRegistration = useRegistration;
+//# sourceMappingURL=ChangePassword.container-f3f94d8f.js.map