@zengenti/contensis-react-base 3.0.2-beta.4 → 3.0.2-beta.40

package/cjs/{login-e711a19e.js → ChangePassword.container-a617190b.js}

@@ -1,13 +1,14 @@
 'use strict';
 
 var effects = require('@redux-saga/core/effects');
-var reducers = require('./reducers-73a03ef4.js');
-var ToJs = require('./ToJs-a9a8522b.js');
-var actions = require('./actions-8dc9e8de.js');
-var selectors = require('./selectors-656da4b7.js');
+var reducers = require('./reducers-9afb5f89.js');
+var ToJs = require('./ToJs-149fc5e1.js');
+var selectors = require('./selectors-46b689d0.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 }; }
 
@@ -30,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);
 
@@ -48,6 +48,7 @@ const clientCredentials = {
 var mapClientCredentials = (obj => mapJson__default["default"](obj, clientCredentials));
 
 // import { Client } from 'contensis-management-api';
+
 const getManagementApiClient = async ({
   bearerToken,
   bearerTokenExpiryDate,
@@ -57,14 +58,10 @@ const getManagementApiClient = async ({
   username,
   password
 }) => {
-  const rootUrl = SERVERS.api || SERVERS.cms;
-  /* global SERVERS */
-
-  const projectId = PROJECTS[0].id;
-  /* global PROJECTS */
+  const rootUrl = SERVERS.api || SERVERS.cms; /* global SERVERS */
+  const projectId = PROJECTS[0].id; /* global PROJECTS */
 
   let config = {};
-
   if (refreshToken) {
     config = {
       clientType: 'contensis_classic_refresh_token',
@@ -81,11 +78,17 @@ const getManagementApiClient = async ({
       }
     };
   }
-
-  const {
+  let {
     Client
   } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require('contensis-management-api')); });
-  const client = Client.create({ ...config,
+  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,
     rootUrl
   });
@@ -97,43 +100,9 @@ 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 */
+const requireOidc = process.env.NODE_ENV === 'development' ? WSFED_LOGIN === 'true' /* global WSFED_LOGIN */ : context$1.WSFED_LOGIN === 'true';
+const servers = SERVERS; /* global SERVERS */
 
 const userManagerConfig = typeof window !== 'undefined' ? {
   authority: `${servers.cms}/authenticate/`,
@@ -149,9 +118,7 @@ const createUserManager = async config => {
     try {
       const {
         UserManager
-      } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
-      /* webpackChunkName: "oidcclient" */
-      'oidc-client')); });
+      } = await Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require( /* webpackChunkName: "oidcclient" */'oidc-client')); });
       return new UserManager(config);
     } catch (e) {
       console.error('Exception in createUserManager: ', e);
@@ -160,50 +127,46 @@ 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 {
         localStorage
       } = window;
       const keys = [];
-
       for (let i = 0; i < localStorage.length; i++) {
         const key = localStorage.key(i);
         if (typeof key === 'string' && key.startsWith('oidc.')) keys.push(localStorage.key(i));
       }
-
       keys.forEach(key => localStorage.removeItem(key));
     }
   }
-
-  static async LoginUser({
+  async LoginUser({
     username,
     password,
     clientCredentials
@@ -217,16 +180,17 @@ class LoginHelper {
     };
     let transientClient;
     let user;
-
     if (username && password) {
       // Get a management client with username and password
       transientClient = await getManagementApiClient({
         username,
         password
-      }); // Ensure the client has requested a bearer token
+      });
 
-      const [loginError, clientBearerToken] = await awaitToJs.to(transientClient.ensureBearerToken()); // Problem getting token with username and password
+      // Ensure the client has requested a bearer token
+      const [loginError, clientBearerToken] = await to.to(transientClient.ensureBearerToken());
 
+      // Problem getting token with username and password
       if (loginError) {
         authenticationState = {
           clientCredentials: null,
@@ -235,14 +199,14 @@ class LoginHelper {
           isAuthenticationError: loginError.name.includes('ContensisAuthenticationError'),
           isError: true
         };
-        LoginHelper.ClearCachedCredentials();
-      } // Got a token using username and password
-
+        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,
@@ -250,15 +214,14 @@ class LoginHelper {
           isError: false
         };
       }
-    } // If we have credentials supplied by a successful username and password login
+    }
+
+    // If we have credentials supplied by a successful username and password login
     // or clientCredentials supplied in the options argument we can continue to
     // fetch the user's details
-
-
     if (credentials) {
       const client = transientClient || (await getManagementApiClient(credentials));
       const [error, userDetails] = await LoginHelper.GetUserDetails(client);
-
       if (error) {
         authenticationState = {
           clientCredentials: null,
@@ -267,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,
@@ -281,27 +244,22 @@ class LoginHelper {
         };
       }
     }
-
     return {
       authenticationState,
       user
     };
   }
-
-  static LogoutUser(redirectPath) {
-    LoginHelper.ClearCachedCredentials();
-
+  LogoutUser(redirectPath) {
+    this.ClearCachedCredentials();
     if (LoginHelper.WSFED_LOGIN) {
       LoginHelper.WsFedLogout(redirectPath);
     } else {
       if (redirectPath) LoginHelper.ClientRedirectToPath(redirectPath);else LoginHelper.ClientRedirectToSignInPage();
     }
   }
-
   static ClientRedirectToHome(location) {
     if (typeof window != 'undefined') {
       let url = '/';
-
       if (location) {
         const {
           search,
@@ -310,12 +268,11 @@ class LoginHelper {
         url = search ? `${url}${search}` : url;
         url = hash ? `${url}${hash}` : url;
       }
-
       window.location.href = url;
     }
   }
-
   static async ClientRedirectToSignInPage(redirectPath) {
+    if (typeof location === 'undefined') return;
     if (LoginHelper.WSFED_LOGIN) {
       await LoginHelper.WsFedLogout();
       await LoginHelper.WsFedLogin();
@@ -326,20 +283,19 @@ 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') {
       if (typeof location !== 'undefined') window.location.href = redirectPath;
     } else LoginHelper.ClientRedirectToHome();
   }
-
   static async WsFedLogin(redirectUri) {
     const userManager = await createUserManager(userManagerConfig);
     userManager.signinRedirect({
@@ -348,22 +304,18 @@ class LoginHelper {
       redirect_uri: redirectUri || window.location.toString()
     });
   }
-
   static RemoveSecurityTokenQuery() {
     const params = new URLSearchParams(window.location.search);
-
     if (params.has('securitytoken') || params.has('securityToken')) {
       params.delete('securitytoken');
       params.delete('securityToken');
       window.location = `${window.location.pathname}${params.toString() ? `?${params}` : ''}`;
     }
   }
-
   static async WsFedLogout(redirectPath) {
     await fetch(`${LoginHelper.CMS_URL}/authenticate/logout?jsonResponseRequired=true`, {
       credentials: 'include'
     });
-
     if (redirectPath) {
       window.location = redirectPath;
     } else {
@@ -372,9 +324,8 @@ class LoginHelper {
       LoginHelper.RemoveSecurityTokenQuery();
     }
   }
-
   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',
@@ -387,34 +338,30 @@ class LoginHelper {
     if (error) return [{
       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
         }];
       }
-
       if (ApplicationData.length > 0) {
         let refreshToken;
         ApplicationData.forEach(item => {
           if (item.Key === 'ContensisSecurityRefreshToken') refreshToken = item.Value;
         });
-
         if (!refreshToken) {
           return [{
             message: 'Fetch credentials: Unable to find ContensisSecurityRefreshToken'
           }];
         }
-
         return [undefined, refreshToken];
       } else {
         return [{
@@ -426,92 +373,98 @@ class LoginHelper {
         message: `Fetch credentials error: ${response.status} ${response.statusText}`
       }];
     }
-  } // static isZengentiStaff(email) {
+  }
+
+  // static isZengentiStaff(email) {
   //   const emailRefs = ['@zengenti', '@contensis'];
+
   //   return emailRefs.some(emailRef => {
   //     if (email.includes(emailRef)) {
   //       return true;
   //     }
   //   });
   // }
-
-
 }
-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.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());
-
+    groupsError,
+    user = {},
+    groupsResult;
+  [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
-    })); // Set groups attribute in user object to be the items
+      includeInherited: true,
+      pageOptions: {
+        pageSize: 100
+      }
+    }));
+    // Set groups attribute in user object to be the items
     // array from the getUserGroups result
+    if (groupsResult && groupsResult.items) user.groups = groupsResult.items;
 
-    if (groupsResult && groupsResult.items) user.groups = groupsResult.items; //If groups call fails then log the error but allow the user to login still
+    //If groups call fails then log the error but allow the user to login still
     // eslint-disable-next-line no-console
-
     if (groupsError) console.log(groupsError);
   }
-
   return [userError, user];
 };
 
 const loginSagas = [effects.takeEvery(reducers.LOGIN_USER, loginUserSaga), effects.takeEvery(reducers.LOGOUT_USER, logoutUserSaga), effects.takeEvery(reducers.VALIDATE_USER, validateUserSaga), effects.takeEvery(reducers.SET_AUTHENTICATION_STATE, redirectAfterSuccessfulLoginSaga)];
 function* handleRequiresLoginSaga(action) {
   var _entry$sys;
-
   const {
+    cookies,
     entry,
+    path,
     requireLogin,
     routes: {
       ContentTypeMappings
     },
     staticRoute
   } = action;
-  let userLoggedIn = yield effects.select(ToJs.selectUserIsAuthenticated); // Check for a securityToken in querystring
+  let userLoggedIn = yield effects.select(ToJs.selectUserIsAuthenticated);
 
+  // Check for a securityToken in querystring
   const currentQs = selectors.queryParams(yield effects.select(selectors.selectCurrentSearch));
-  const securityToken = currentQs.securityToken || currentQs.securitytoken; // Check if any of the defined routes have "requireLogin" attribute
+  const securityToken = currentQs.securityToken || currentQs.securitytoken;
 
+  // Check if any of the defined routes have "requireLogin" attribute
   const {
     requireLogin: authRoute
   } = staticRoute && staticRoute.route || {};
   const {
     requireLogin: authContentType
-  } = entry && findContentTypeMapping(ContentTypeMappings, entry === null || entry === void 0 ? void 0 : (_entry$sys = entry.sys) === null || _entry$sys === void 0 ? void 0 : _entry$sys.contentTypeId) || {}; // If requireLogin, authRoute or authContentType has been specified as an
-  // array of groups we can merge all the arrays and match on any group supplied
+  } = entry && findContentTypeMapping(ContentTypeMappings, entry === null || entry === void 0 ? void 0 : (_entry$sys = entry.sys) === null || _entry$sys === void 0 ? void 0 : _entry$sys.contentTypeId) || {};
 
+  // If requireLogin, authRoute or authContentType has been specified as an
+  // array of groups we can merge all the arrays and match on any group supplied
   const routeRequiresGroups = [...(Array.isArray(authContentType) && authContentType || []), ...(Array.isArray(authRoute) && authRoute || []), ...(Array.isArray(requireLogin) && requireLogin || [])];
   const routeRequiresLogin = !!authContentType || !!authRoute || !!requireLogin;
-
   if (!userLoggedIn) {
     // 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
       });
-    } // otherwise do a non blocking put to handle validation in the background
+      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
     });
   }
-
   if (routeRequiresLogin) {
     // If a security token is in the querystring and we are not already
     // logged in something is wrong and we won't bother going on another redirect loop
@@ -523,15 +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
@@ -540,49 +494,60 @@ function* validateUserSaga({
       authenticationState: {
         isLoading: true
       }
-    }); // If we have just a security token we will call a CMS endpoint
+    });
+    // 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();
-    } // 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 (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();
       }
-    });
-  } // Tell any callers have we successfully logged in?
+      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) {
+      console.info(`Login user with refreshToken ${clientCredentials.refreshToken}`);
+      yield effects.call(loginUserSaga, {
+        clientCredentials,
+        cookies: login.cookies
+      });
+    }
+  }
 
+  // Tell any callers have we successfully logged in?
   return yield effects.select(ToJs.selectUserIsAuthenticated);
 }
-
 function* loginUserSaga(action = {}) {
   const {
     username,
     password,
-    clientCredentials
-  } = action; // If a WSFED_LOGIN site has dispatched the loginUser action
-  // just redirect them to the Identity Provider sign in
+    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
   if (action.type === reducers.LOGIN_USER && LoginHelper.WSFED_LOGIN) LoginHelper.ClientRedirectToSignInPage();
   const {
     authenticationState,
     user
-  } = yield LoginHelper.LoginUser({
+  } = yield login.LoginUser({
     username,
     password,
     clientCredentials
@@ -593,46 +558,42 @@ function* loginUserSaga(action = {}) {
     user
   });
 }
-
 const removeHostnamePart = path => {
   // eslint-disable-next-line no-console
   console.log(path);
-  const relativePath = '/' + path.split('/').splice(3).join('/'); // eslint-disable-next-line no-console
-
+  const relativePath = '/' + path.split('/').splice(3).join('/');
+  // eslint-disable-next-line no-console
   console.log(relativePath);
   return relativePath;
 };
-
 function* redirectAfterSuccessfulLoginSaga() {
   const isLoggedIn = yield effects.select(ToJs.selectUserIsAuthenticated);
   const {
     redirect_uri: redirectPath,
     ReturnURL: assetRedirectPath
   } = selectors.queryParams(yield effects.select(selectors.selectCurrentSearch));
-
   if (isLoggedIn && assetRedirectPath && typeof window != 'undefined') {
-    const path = removeHostnamePart(assetRedirectPath); // This has to be a hard href to get the app to
+    const path = removeHostnamePart(assetRedirectPath);
+    // This has to be a hard href to get the app to
     // leave React and hit the server for the IIS hosted assets
-
-    window.location.href = path; // yield put(setRoute(path)); // does not work in this scenario
+    window.location.href = path;
+    // yield put(setRoute(path)); // does not work in this scenario
   } else if (isLoggedIn && redirectPath) {
-    yield effects.put(actions.setRoute(redirectPath));
+    yield effects.put(selectors.setRoute(redirectPath));
   }
 }
-
 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');
-
   if (Object.keys(clientCredentials).length > 0) {
     const client = yield getManagementApiClient(clientCredentials);
     yield client.authenticate();
@@ -645,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-e711a19e.js.map
+exports.registerUser = registerUser;
+exports.useChangePassword = useChangePassword;
+exports.useForgotPassword = useForgotPassword;
+exports.useLogin = useLogin;
+exports.useRegistration = useRegistration;
+//# sourceMappingURL=ChangePassword.container-a617190b.js.map