@wavemaker-ai/app-ng-runtime 1.0.0-rc.647469

package/variables/esm2022/manager/action/login-action.manager.mjs

@@ -0,0 +1,180 @@
+import { getClonedObject, triggerFn } from '@wm/core';
+import { BaseActionManager } from './base-action.manager';
+import { CONSTANTS, VARIABLE_CONSTANTS } from '../../constants/variables.constants';
+import { appManager, dialogService, initiateCallback, routerService, securityService } from '../../util/variable/variables.utils';
+import { each, get, isBoolean, isEmpty, isObject, set } from "lodash-es";
+export class LoginActionManager extends BaseActionManager {
+    validate(params) {
+        let err, paramKey, remembermeKey;
+        const LOGIN_PARAM_REMEMBER_ME = 'j_rememberme';
+        const LOGIN_PARAM_REMEMBER_ME_OLD = ['rememberme', 'remembermecheck'];
+        // for older projects
+        LOGIN_PARAM_REMEMBER_ME_OLD.forEach((old_key) => {
+            if (isBoolean(params[old_key])) {
+                remembermeKey = old_key;
+            }
+        });
+        remembermeKey = remembermeKey || LOGIN_PARAM_REMEMBER_ME;
+        // check remember me
+        params[remembermeKey] = isBoolean(params[remembermeKey]) ? params[remembermeKey] : false;
+        for (paramKey in params) {
+            if (params.hasOwnProperty(paramKey) &&
+                (params[paramKey] === '' || params[paramKey] === undefined)) {
+                err = 'Please provide required credentials';
+                break;
+            }
+        }
+        return err;
+    }
+    migrateOldParams(params) {
+        const loginParams = {}, paramMigrationMap = {
+            'usernametext': 'j_username',
+            'username': 'j_username',
+            'passwordtext': 'j_password',
+            'password': 'j_password',
+            'remembermecheck': 'j_rememberme',
+            'rememberme': 'j_rememberme'
+        };
+        each(params, function (value, key) {
+            if (paramMigrationMap[key]) {
+                loginParams[paramMigrationMap[key]] = value;
+            }
+            else {
+                loginParams[key] = value;
+            }
+        });
+        return loginParams;
+    }
+    /*
+         * This method is used to redirect the user to app base path
+         * After successful navigation to the base path, will reload the app
+    */
+    redirectToAppBasePath() {
+        routerService.navigate(['/']).then(nav => {
+            if (nav) {
+                window.location.reload();
+            }
+        });
+    }
+    login(variable, options, success, error) {
+        let newDataSet;
+        options = options || {};
+        // If login info provided along explicitly with options, don't look into the variable bindings for the same
+        const loginInfo = options.loginInfo || options.input || variable.dataBinding;
+        // client side validation
+        const errMsg = this.validate(loginInfo);
+        /* if error message initialized, return error */
+        if (errMsg) {
+            triggerFn(error, errMsg);
+            initiateCallback('onError', variable, errMsg);
+            return;
+        }
+        // Triggering 'onBeforeUpdate' and considering
+        let params = getClonedObject(loginInfo);
+        const output = initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_UPDATE, variable, params);
+        if (isObject(output)) {
+            params = output;
+        }
+        else if (output === false) {
+            triggerFn(error);
+            return;
+        }
+        // migrate old params to new
+        params = this.migrateOldParams(params);
+        // get previously loggedInUser name (if any)
+        const lastLoggedInUsername = get(securityService.get(), 'userInfo.userName');
+        this.notifyInflight(variable, true);
+        variable.promise = securityService.appLogin(params, (response) => {
+            // Closing login dialog after successful login
+            dialogService.close('CommonLoginDialog');
+            /*
+             * Get fresh security config
+             * Get App variables. if not loaded
+             * Update loggedInUser variable with new user details
+             */
+            appManager.reloadAppData().
+                then((config) => {
+                // EVENT: ON_RESULT
+                initiateCallback(VARIABLE_CONSTANTS.EVENT.RESULT, variable, get(config, 'userInfo'));
+                // EVENT: ON_PREPARESETDATA
+                newDataSet = initiateCallback(VARIABLE_CONSTANTS.EVENT.PREPARE_SETDATA, variable, get(config, 'userInfo'));
+                if (newDataSet) {
+                    // setting newDataSet as the response to service variable onPrepareSetData
+                    set(config, 'userInfo', newDataSet);
+                }
+                // hide the spinner after all the n/w calls are completed
+                this.notifyInflight(variable, false, response);
+                triggerFn(success);
+                setTimeout(() => {
+                    // EVENT: ON_SUCCESS
+                    initiateCallback(VARIABLE_CONSTANTS.EVENT.SUCCESS, variable, get(config, 'userInfo'));
+                    /* handle navigation if defaultSuccessHandler on variable is true */
+                    if (variable.useDefaultSuccessHandler) {
+                        const isSameUserReloggedIn = lastLoggedInUsername === params['j_username'];
+                        // if first time user logging in or same user re-logging in, execute n/w calls failed before logging in
+                        if (!lastLoggedInUsername || isSameUserReloggedIn) {
+                            appManager.executeSessionFailureRequests();
+                        }
+                        // get redirectTo page from URL and remove it from URL
+                        const redirectPage = securityService.getCurrentRouteQueryParam('redirectTo'), noRedirect = appManager.noRedirect();
+                        // Get query params(page params of page being redirected to) and append to the URL after login.
+                        const queryParamsObj = securityService.getRedirectedRouteQueryParams();
+                        // The redirectTo param isn't required after login
+                        if (queryParamsObj.redirectTo) {
+                            delete queryParamsObj.redirectTo;
+                        }
+                        appManager.noRedirect(false);
+                        // first time login
+                        if (!lastLoggedInUsername) {
+                            // if redirect page found, navigate to it.
+                            if (!isEmpty(redirectPage)) {
+                                routerService.navigate([`/${redirectPage}`], { queryParams: queryParamsObj });
+                            }
+                            else if (!noRedirect) {
+                                // simply reset the URL, route handling will take care of page redirection
+                                routerService.navigate([`/`]);
+                            }
+                        }
+                        else {
+                            // login after a session timeout
+                            // if redirect page found and same user logs in again, just navigate to redirect page
+                            if (!isEmpty(redirectPage)) {
+                                // same user logs in again, just redirect to the redirectPage
+                                if (lastLoggedInUsername === params['j_username']) {
+                                    routerService.navigate([`/${redirectPage}`], { queryParams: queryParamsObj });
+                                }
+                                else {
+                                    // different user logs in, reload the app and discard the redirectPage
+                                    this.redirectToAppBasePath();
+                                }
+                            }
+                            else {
+                                const securityConfig = securityService.get(), sessionTimeoutLoginMode = get(securityConfig, 'loginConfig.sessionTimeout.type') || 'PAGE';
+                                // if in dialog mode and a new user logs in OR login happening through page, reload the app
+                                if (!isSameUserReloggedIn || sessionTimeoutLoginMode !== 'DIALOG') {
+                                    this.redirectToAppBasePath();
+                                }
+                            }
+                        }
+                    }
+                    // EVENT: ON_CAN_UPDATE
+                    initiateCallback(VARIABLE_CONSTANTS.EVENT.CAN_UPDATE, variable, get(config, 'userInfo'));
+                });
+            });
+        }, (e) => {
+            // EVENT: ON_RESULT
+            initiateCallback(VARIABLE_CONSTANTS.EVENT.RESULT, variable, e);
+            this.notifyInflight(variable, false, e);
+            const errorMsg = e.error || 'Invalid credentials.';
+            const xhrObj = e.details;
+            /* if in RUN mode, trigger error events associated with the variable */
+            if (CONSTANTS.isRunMode) {
+                initiateCallback('onError', variable, errorMsg, xhrObj, true);
+            }
+            triggerFn(error, errorMsg, xhrObj);
+            // EVENT: ON_CAN_UPDATE
+            initiateCallback(VARIABLE_CONSTANTS.EVENT.CAN_UPDATE, variable, e);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"login-action.manager.js","sourceRoot":"","sources":["../../../../../projects/variables/src/manager/action/login-action.manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { getClonedObject, triggerFn } from '@wm/core';\n\nimport { BaseActionManager } from './base-action.manager';\nimport { CONSTANTS, VARIABLE_CONSTANTS } from '../../constants/variables.constants';\nimport { appManager, dialogService, initiateCallback, routerService, securityService } from '../../util/variable/variables.utils';\nimport {each, get, isBoolean, isEmpty, isObject, set} from \"lodash-es\";\n\nexport class LoginActionManager extends BaseActionManager {\n\n    private validate(params: any) {\n        let err, paramKey, remembermeKey;\n        const LOGIN_PARAM_REMEMBER_ME = 'j_rememberme';\n        const LOGIN_PARAM_REMEMBER_ME_OLD = ['rememberme', 'remembermecheck'];\n\n        // for older projects\n        LOGIN_PARAM_REMEMBER_ME_OLD.forEach((old_key) => {\n            if (isBoolean(params[old_key])) {\n                remembermeKey = old_key;\n            }\n        });\n\n        remembermeKey =  remembermeKey || LOGIN_PARAM_REMEMBER_ME;\n\n        // check remember me\n        params[remembermeKey] = isBoolean(params[remembermeKey]) ? params[remembermeKey] : false;\n\n        for (paramKey in params) {\n            if (params.hasOwnProperty(paramKey) &&\n                (params[paramKey] === '' || params[paramKey] === undefined)) {\n                err = 'Please provide required credentials';\n                break;\n            }\n        }\n\n        return err;\n    }\n\n    private migrateOldParams(params) {\n        const loginParams = {},\n            paramMigrationMap = {\n            'usernametext': 'j_username',\n            'username': 'j_username',\n            'passwordtext': 'j_password',\n            'password': 'j_password',\n            'remembermecheck': 'j_rememberme',\n            'rememberme': 'j_rememberme'\n        };\n\n        each(params, function (value, key) {\n            if (paramMigrationMap[key]) {\n                loginParams[paramMigrationMap[key]] = value;\n            } else {\n                loginParams[key] = value;\n            }\n        });\n        return loginParams;\n    }\n\n    /*\n         * This method is used to redirect the user to app base path\n         * After successful navigation to the base path, will reload the app\n    */\n    private redirectToAppBasePath() {\n        routerService.navigate(['/']).then(nav => {\n            if (nav) {\n                window.location.reload();\n            }\n        });\n    }\n\n    login(variable, options, success, error) {\n        let newDataSet;\n        options = options || {};\n\n        // If login info provided along explicitly with options, don't look into the variable bindings for the same\n        const loginInfo: any = options.loginInfo || options.input || variable.dataBinding;\n\n        // client side validation\n        const errMsg = this.validate(loginInfo);\n\n        /* if error message initialized, return error */\n        if (errMsg) {\n            triggerFn(error, errMsg);\n            initiateCallback('onError', variable, errMsg);\n            return;\n        }\n\n        // Triggering 'onBeforeUpdate' and considering\n        let params: any = getClonedObject(loginInfo);\n        const output: any = initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_UPDATE, variable, params);\n        if (isObject(output)) {\n            params = output;\n        } else if (output === false) {\n            triggerFn(error);\n            return;\n        }\n\n        // migrate old params to new\n        params = this.migrateOldParams(params);\n\n        // get previously loggedInUser name (if any)\n        const lastLoggedInUsername = get(securityService.get(), 'userInfo.userName');\n\n        this.notifyInflight(variable, true);\n        variable.promise = securityService.appLogin(params, (response) => {\n            // Closing login dialog after successful login\n            dialogService.close('CommonLoginDialog');\n\n            /*\n             * Get fresh security config\n             * Get App variables. if not loaded\n             * Update loggedInUser variable with new user details\n             */\n            appManager.reloadAppData().\n            then((config) => {\n                // EVENT: ON_RESULT\n                initiateCallback(VARIABLE_CONSTANTS.EVENT.RESULT, variable, get(config, 'userInfo'));\n                // EVENT: ON_PREPARESETDATA\n                newDataSet = initiateCallback(VARIABLE_CONSTANTS.EVENT.PREPARE_SETDATA, variable, get(config, 'userInfo'));\n                if (newDataSet) {\n                        // setting newDataSet as the response to service variable onPrepareSetData\n                    set(config, 'userInfo', newDataSet);\n                }\n                // hide the spinner after all the n/w calls are completed\n                this.notifyInflight(variable, false, response);\n                triggerFn(success);\n                setTimeout(() => {\n                    // EVENT: ON_SUCCESS\n                    initiateCallback(VARIABLE_CONSTANTS.EVENT.SUCCESS, variable, get(config, 'userInfo'));\n\n                    /* handle navigation if defaultSuccessHandler on variable is true */\n                    if (variable.useDefaultSuccessHandler) {\n                        const isSameUserReloggedIn = lastLoggedInUsername === params['j_username'];\n                        // if first time user logging in or same user re-logging in, execute n/w calls failed before logging in\n                        if (!lastLoggedInUsername || isSameUserReloggedIn) {\n                            appManager.executeSessionFailureRequests();\n                        }\n                        // get redirectTo page from URL and remove it from URL\n                        const redirectPage = securityService.getCurrentRouteQueryParam('redirectTo'),\n                            noRedirect = appManager.noRedirect();\n                        // Get query params(page params of page being redirected to) and append to the URL after login.\n                        const queryParamsObj = securityService.getRedirectedRouteQueryParams();\n                        // The redirectTo param isn't required after login\n                        if (queryParamsObj.redirectTo) {\n                            delete queryParamsObj.redirectTo;\n                        }\n                        appManager.noRedirect(false);\n                        // first time login\n                        if (!lastLoggedInUsername) {\n                            // if redirect page found, navigate to it.\n                            if (!isEmpty(redirectPage)) {\n                                routerService.navigate([`/${redirectPage}`], { queryParams : queryParamsObj});\n                            } else if (!noRedirect) {\n                                // simply reset the URL, route handling will take care of page redirection\n                                routerService.navigate([`/`]);\n                            }\n                        } else {\n                        // login after a session timeout\n                            // if redirect page found and same user logs in again, just navigate to redirect page\n                            if (!isEmpty(redirectPage)) {\n                                // same user logs in again, just redirect to the redirectPage\n                                if (lastLoggedInUsername === params['j_username']) {\n                                    routerService.navigate([`/${redirectPage}`], { queryParams : queryParamsObj});\n                                } else {\n                                    // different user logs in, reload the app and discard the redirectPage\n                                    this.redirectToAppBasePath();\n                                }\n                            } else {\n                                const securityConfig = securityService.get(),\n                                    sessionTimeoutLoginMode = get(securityConfig, 'loginConfig.sessionTimeout.type') || 'PAGE';\n                                // if in dialog mode and a new user logs in OR login happening through page, reload the app\n                                if (!isSameUserReloggedIn || sessionTimeoutLoginMode !== 'DIALOG') {\n                                    this.redirectToAppBasePath();\n                                }\n                            }\n\n                        }\n                    }\n                    // EVENT: ON_CAN_UPDATE\n                    initiateCallback(VARIABLE_CONSTANTS.EVENT.CAN_UPDATE, variable, get(config, 'userInfo'));\n                });\n\n            });\n        }, (e) => {\n            // EVENT: ON_RESULT\n            initiateCallback(VARIABLE_CONSTANTS.EVENT.RESULT, variable, e);\n            this.notifyInflight(variable, false, e);\n            const errorMsg = e.error || 'Invalid credentials.';\n            const xhrObj = e.details;\n            /* if in RUN mode, trigger error events associated with the variable */\n            if (CONSTANTS.isRunMode) {\n                initiateCallback('onError', variable, errorMsg, xhrObj, true);\n            }\n            triggerFn(error, errorMsg, xhrObj);\n            // EVENT: ON_CAN_UPDATE\n            initiateCallback(VARIABLE_CONSTANTS.EVENT.CAN_UPDATE, variable, e);\n        });\n    }\n}\n"]}

package/variables/esm2022/manager/action/logout-action.manager.mjs

@@ -0,0 +1,77 @@
+import { getValidJSON, triggerFn } from '@wm/core';
+import { BaseActionManager } from './base-action.manager';
+import { CONSTANTS, VARIABLE_CONSTANTS } from '../../constants/variables.constants';
+import { appManager, initiateCallback, securityService } from './../../util/variable/variables.utils';
+import { routerService } from '../../util/variable/variables.utils';
+export class LogoutActionManager extends BaseActionManager {
+    logout(variable, options, success, error) {
+        let handleError, redirectPage, output, newDataSet;
+        handleError = function (msg, details, xhrObj) {
+            /* if in RUN mode, trigger error events associated with the variable */
+            if (!CONSTANTS.isStudioMode) {
+                initiateCallback('onError', variable, msg, xhrObj);
+            }
+            triggerFn(error, msg, xhrObj);
+        };
+        // EVENT: ON_BEFORE_UPDATE
+        output = initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_UPDATE, variable, null);
+        if (output === false) {
+            triggerFn(error);
+            return;
+        }
+        securityService.isAuthenticated(isAuthenticated => {
+            if (isAuthenticated) {
+                this.notifyInflight(variable, true);
+                variable.promise = securityService.appLogout(response => {
+                    let redirectUrl = response.body;
+                    redirectUrl = getValidJSON(redirectUrl);
+                    // Reset Security Config.
+                    // $rootScope.isUserAuthenticated = false;
+                    appManager.reloadAppData().
+                        then(() => {
+                        this.notifyInflight(variable, false, redirectUrl);
+                        // EVENT: ON_RESULT
+                        initiateCallback(VARIABLE_CONSTANTS.EVENT.RESULT, variable, redirectUrl);
+                        // EVENT: ON_PREPARESETDATA
+                        newDataSet = initiateCallback(VARIABLE_CONSTANTS.EVENT.PREPARE_SETDATA, variable, redirectUrl);
+                        if (newDataSet) {
+                            // setting newDataSet as the response to service variable onPrepareSetData
+                            redirectUrl = newDataSet;
+                        }
+                        setTimeout(() => {
+                            // EVENT: ON_SUCCESS
+                            initiateCallback(VARIABLE_CONSTANTS.EVENT.SUCCESS, variable, redirectUrl);
+                            // EVENT: ON_CAN_UPDATE
+                            initiateCallback(VARIABLE_CONSTANTS.EVENT.CAN_UPDATE, variable, redirectUrl);
+                        });
+                    });
+                    // In case of CAS response will be the redirectUrl
+                    if (redirectUrl && redirectUrl.result) {
+                        window.location.href = redirectUrl.result;
+                    }
+                    else if (variable.useDefaultSuccessHandler) {
+                        redirectPage = variable.redirectTo;
+                        /* backward compatibility (index.html/login.html may be present in older projects) */
+                        if (!redirectPage || redirectPage === 'login.html' || redirectPage === 'index.html') {
+                            redirectPage = '';
+                        }
+                        routerService.navigate([`/${redirectPage}`]);
+                        // do not reload the mobile app.
+                        setTimeout(() => {
+                            // reloading in timeout as, firefox and safari are not updating the url before reload(WMS-7887)
+                            window.location.reload();
+                        });
+                    }
+                    triggerFn(success);
+                }, handleError);
+            }
+            else {
+                handleError('No authenticated user to logout.');
+            }
+        }, (err) => {
+            this.notifyInflight(variable, false, err);
+            handleError(err);
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logout-action.manager.js","sourceRoot":"","sources":["../../../../../projects/variables/src/manager/action/logout-action.manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { getValidJSON, triggerFn } from '@wm/core';\n\nimport { BaseActionManager } from './base-action.manager';\nimport { CONSTANTS, VARIABLE_CONSTANTS } from '../../constants/variables.constants';\nimport { appManager, initiateCallback, securityService } from './../../util/variable/variables.utils';\nimport { routerService } from '../../util/variable/variables.utils';\n\nexport class LogoutActionManager extends BaseActionManager {\n    logout(variable, options, success, error) {\n        let handleError,\n            redirectPage,\n            output,\n            newDataSet;\n\n        handleError = function (msg, details, xhrObj) {\n            /* if in RUN mode, trigger error events associated with the variable */\n            if (!CONSTANTS.isStudioMode) {\n                initiateCallback('onError', variable, msg, xhrObj);\n            }\n            triggerFn(error, msg, xhrObj);\n        };\n\n        // EVENT: ON_BEFORE_UPDATE\n        output = initiateCallback(VARIABLE_CONSTANTS.EVENT.BEFORE_UPDATE, variable, null);\n        if (output === false) {\n            triggerFn(error);\n            return;\n        }\n        securityService.isAuthenticated(isAuthenticated => {\n            if (isAuthenticated) {\n                this.notifyInflight(variable, true);\n                variable.promise = securityService.appLogout(response => {\n                    let redirectUrl = response.body;\n                    redirectUrl = getValidJSON(redirectUrl);\n                    // Reset Security Config.\n                    // $rootScope.isUserAuthenticated = false;\n                    appManager.reloadAppData().\n                    then(() => {\n                        this.notifyInflight(variable, false, redirectUrl);\n                        // EVENT: ON_RESULT\n                        initiateCallback(VARIABLE_CONSTANTS.EVENT.RESULT, variable, redirectUrl);\n                        // EVENT: ON_PREPARESETDATA\n                        newDataSet = initiateCallback(VARIABLE_CONSTANTS.EVENT.PREPARE_SETDATA, variable, redirectUrl);\n                        if (newDataSet) {\n                                // setting newDataSet as the response to service variable onPrepareSetData\n                                redirectUrl = newDataSet;\n                        }\n                        setTimeout(()=>{\n                            // EVENT: ON_SUCCESS\n                            initiateCallback(VARIABLE_CONSTANTS.EVENT.SUCCESS, variable, redirectUrl);\n                            // EVENT: ON_CAN_UPDATE\n                            initiateCallback(VARIABLE_CONSTANTS.EVENT.CAN_UPDATE, variable, redirectUrl);\n                        })\n                    });\n\n                    // In case of CAS response will be the redirectUrl\n                    if (redirectUrl && redirectUrl.result) {\n                        window.location.href = redirectUrl.result;\n                    } else if (variable.useDefaultSuccessHandler) {\n                        redirectPage = variable.redirectTo;\n                        /* backward compatibility (index.html/login.html may be present in older projects) */\n                        if (!redirectPage || redirectPage === 'login.html' || redirectPage === 'index.html') {\n                            redirectPage = '';\n                        }\n                        routerService.navigate([`/${redirectPage}`]);\n                        // do not reload the mobile app.\n                            setTimeout(() => {\n                                // reloading in timeout as, firefox and safari are not updating the url before reload(WMS-7887)\n                                window.location.reload();\n                            });\n                    }\n                    triggerFn(success);\n                }, handleError);\n            } else {\n                handleError('No authenticated user to logout.');\n            }\n        }, (err) => {\n            this.notifyInflight(variable, false, err);\n            handleError(err);\n        });\n    }\n}\n"]}

package/variables/esm2022/manager/action/navigation-action.manager.mjs

@@ -0,0 +1,8 @@
+import * as NVUtils from '../../util/action/navigation-action.utils';
+import { BaseActionManager } from './base-action.manager';
+export class NavigationActionManager extends BaseActionManager {
+    invoke(variable, options) {
+        NVUtils.navigate(variable, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi1hY3Rpb24ubWFuYWdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhcmlhYmxlcy9zcmMvbWFuYWdlci9hY3Rpb24vbmF2aWdhdGlvbi1hY3Rpb24ubWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLDJDQUEyQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRTFELE1BQU0sT0FBTyx1QkFBd0IsU0FBUSxpQkFBaUI7SUFFMUQsTUFBTSxDQUFDLFFBQVEsRUFBRSxPQUFPO1FBQ3BCLE9BQU8sQ0FBQyxRQUFRLENBQUMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3hDLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIE5WVXRpbHMgZnJvbSAnLi4vLi4vdXRpbC9hY3Rpb24vbmF2aWdhdGlvbi1hY3Rpb24udXRpbHMnO1xuaW1wb3J0IHsgQmFzZUFjdGlvbk1hbmFnZXIgfSBmcm9tICcuL2Jhc2UtYWN0aW9uLm1hbmFnZXInO1xuXG5leHBvcnQgY2xhc3MgTmF2aWdhdGlvbkFjdGlvbk1hbmFnZXIgZXh0ZW5kcyBCYXNlQWN0aW9uTWFuYWdlciB7XG5cbiAgICBpbnZva2UodmFyaWFibGUsIG9wdGlvbnMpIHtcbiAgICAgICAgTlZVdGlscy5uYXZpZ2F0ZSh2YXJpYWJsZSwgb3B0aW9ucyk7XG4gICAgfVxufVxuIl19

package/variables/esm2022/manager/action/notification-action.manager.mjs

@@ -0,0 +1,152 @@
+import { BaseActionManager } from './base-action.manager';
+import { initiateCallback, toasterService, dialogService } from '../../util/variable/variables.utils';
+import { getWmProjectProperties } from '@wm/core';
+import { capitalize, isString } from "lodash-es";
+export class NotificationActionManager extends BaseActionManager {
+    onToasterClick(variable) {
+        initiateCallback('onClick', variable, '');
+    }
+    onToasterHide(variable) {
+        initiateCallback('onHide', variable, '');
+    }
+    notifyViaToaster(variable, options) {
+        const type = (options.class || variable.dataBinding.class || 'info').toLowerCase(), body = options.message || variable.dataBinding.text, title = options.title, positionClass = 'toast-' + (options.position || variable.dataBinding.toasterPosition || 'bottom right').replace(' ', '-'), partialPage = variable.dataBinding.page, DEFAULT_DURATION = 3000;
+        let duration = parseInt(options.duration || variable.dataBinding.duration, null), toaster;
+        // duration
+        if (!duration) {
+            duration = (duration !== 0 && type === 'success') ? DEFAULT_DURATION : 0;
+        }
+        if (variable.dataBinding.content && variable.dataBinding.content === 'page' && partialPage) {
+            toaster = toasterService.showCustom(partialPage, { positionClass: positionClass, timeOut: duration,
+                partialParams: variable._binddataSet, context: variable._context });
+        }
+        else {
+            toaster = toasterService.show(type, title, body || null, { positionClass: positionClass, timeOut: duration, enableHtml: true });
+        }
+        // callbacks
+        // MEMORY LEAK FIX: Store subscriptions for cleanup (though toaster is short-lived, we track for safety)
+        if (variable.onClick) {
+            const onClickSubscription = toaster.onTap.subscribe(this.onToasterClick.bind(this, variable));
+            // Store subscription on toaster for cleanup (toaster handles its own lifecycle)
+            if (toaster && !toaster._subscriptions) {
+                toaster._subscriptions = [];
+            }
+            if (toaster && toaster._subscriptions) {
+                toaster._subscriptions.push(onClickSubscription);
+            }
+        }
+        if (variable.onHide) {
+            const onHideSubscription = toaster.onHidden.subscribe(this.onToasterHide.bind(this, variable));
+            // Store subscription on toaster for cleanup (toaster handles its own lifecycle)
+            if (toaster && !toaster._subscriptions) {
+                toaster._subscriptions = [];
+            }
+            if (toaster && toaster._subscriptions) {
+                toaster._subscriptions.push(onHideSubscription);
+            }
+        }
+    }
+    getDialogConfig(variable, options, dialogId, closeCallBackFn) {
+        return {
+            'title': options.title || variable.dataBinding.title,
+            'text': options.message || variable.dataBinding.text,
+            'okButtonText': options.okButtonText || variable.dataBinding.okButtonText || 'OK',
+            'cancelButtonText': options.cancelButtonText || variable.dataBinding.cancelButtonText || 'CANCEL',
+            'alerttype': options.alerttype || variable.dataBinding.alerttype || 'information',
+            onOk: () => {
+                // Close the action dialog after triggering onOk callback event
+                dialogService.close(dialogId, undefined, closeCallBackFn);
+            },
+            onCancel: () => {
+                initiateCallback('onCancel', variable, options.data);
+                // Close the action dialog after triggering onCancel callback event
+                dialogService.close(dialogId, undefined);
+            },
+            onClose: () => {
+                initiateCallback('onClose', variable, options.data);
+            }
+        };
+    }
+    notifyViaDialog(variable, options) {
+        const isPrefabType = getWmProjectProperties().type === 'PREFAB';
+        const dialogPrefix = isPrefabType ? 'Prefab' : 'Common';
+        const dialogId = dialogPrefix + capitalize(variable.operation) + 'Dialog';
+        const closeCallBackFn = () => initiateCallback('onOk', variable, options.data);
+        let dialogConfig = this.getDialogConfig(variable, options, dialogId, closeCallBackFn);
+        dialogConfig = isPrefabType ? dialogConfig : { notification: dialogConfig };
+        dialogService.open(dialogId, undefined, dialogConfig);
+    }
+    // *********************************************************** PUBLIC ***********************************************************//
+    notify(variable, options, success, error) {
+        const operation = variable.operation;
+        options = options || {};
+        if (operation === 'toast') {
+            this.notifyViaToaster(variable, options);
+        }
+        else {
+            this.notifyViaDialog(variable, options);
+        }
+    }
+    getMessage(variable) {
+        return variable.dataBinding.text;
+    }
+    setMessage(variable, text) {
+        if (isString(text)) {
+            variable.dataBinding.text = text;
+        }
+        return variable.dataBinding.text;
+    }
+    getOkButtonText(variable) {
+        return variable.dataBinding.okButtonText;
+    }
+    setOkButtonText(variable, text) {
+        if (isString(text)) {
+            variable.dataBinding.okButtonText = text;
+        }
+        return variable.dataBinding.okButtonText;
+    }
+    getToasterDuration(variable) {
+        return variable.dataBinding.duration;
+    }
+    setToasterDuration(variable, duration) {
+        variable.dataBinding.duration = duration;
+        return variable.dataBinding.duration;
+    }
+    getToasterClass(variable) {
+        return variable.dataBinding.class;
+    }
+    setToasterClass(variable, type) {
+        if (isString(type)) {
+            variable.dataBinding.class = type;
+        }
+        return variable.dataBinding.class;
+    }
+    getToasterPosition(variable) {
+        return variable.dataBinding.class;
+    }
+    setToasterPosition(variable, position) {
+        if (isString(position)) {
+            variable.dataBinding.position = position;
+        }
+        return variable.dataBinding.position;
+    }
+    getAlertType(variable) {
+        return variable.dataBinding.alerttype;
+    }
+    setAlertType(variable, alerttype) {
+        if (isString(alerttype)) {
+            variable.dataBinding.alerttype = alerttype;
+        }
+        return variable.dataBinding.alerttype;
+    }
+    getCancelButtonText(variable) {
+        return variable.dataBinding.cancelButtonText;
+    }
+    setCancelButtonText(variable, text) {
+        if (isString(text)) {
+            variable.dataBinding.cancelButtonText = text;
+        }
+        return variable.dataBinding.cancelButtonText;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"notification-action.manager.js","sourceRoot":"","sources":["../../../../../projects/variables/src/manager/action/notification-action.manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseActionManager } from './base-action.manager';\nimport { initiateCallback, toasterService, dialogService } from '../../util/variable/variables.utils';\nimport { getWmProjectProperties } from '@wm/core';\nimport {capitalize, isString} from \"lodash-es\";\n\nexport class NotificationActionManager extends BaseActionManager {\n\n    private onToasterClick(variable) {\n        initiateCallback('onClick', variable, '');\n    }\n\n    private onToasterHide(variable) {\n        initiateCallback('onHide', variable, '');\n    }\n\n    private notifyViaToaster(variable, options) {\n        const type = (options.class || variable.dataBinding.class || 'info').toLowerCase(),\n            body = options.message || variable.dataBinding.text,\n            title = options.title,\n            positionClass = 'toast-' + (options.position || variable.dataBinding.toasterPosition || 'bottom right').replace(' ', '-'),\n            partialPage = variable.dataBinding.page,\n            DEFAULT_DURATION = 3000;\n        let duration = parseInt(options.duration || variable.dataBinding.duration, null),\n            toaster;\n\n        // duration\n        if (!duration) {\n            duration = (duration !== 0 && type === 'success') ? DEFAULT_DURATION : 0;\n        }\n        if (variable.dataBinding.content && variable.dataBinding.content === 'page' && partialPage) {\n            toaster = toasterService.showCustom(partialPage, {positionClass: positionClass, timeOut: duration,\n                partialParams: variable._binddataSet, context: variable._context});\n        } else {\n            toaster = toasterService.show(type, title, body || null, {positionClass: positionClass, timeOut: duration, enableHtml: true});\n        }\n\n        // callbacks\n        // MEMORY LEAK FIX: Store subscriptions for cleanup (though toaster is short-lived, we track for safety)\n        if (variable.onClick) {\n            const onClickSubscription = toaster.onTap.subscribe( this.onToasterClick.bind(this, variable) );\n            // Store subscription on toaster for cleanup (toaster handles its own lifecycle)\n            if (toaster && !toaster._subscriptions) {\n                toaster._subscriptions = [];\n            }\n            if (toaster && toaster._subscriptions) {\n                toaster._subscriptions.push(onClickSubscription);\n            }\n        }\n        if (variable.onHide) {\n            const onHideSubscription = toaster.onHidden.subscribe( this.onToasterHide.bind(this, variable) );\n            // Store subscription on toaster for cleanup (toaster handles its own lifecycle)\n            if (toaster && !toaster._subscriptions) {\n                toaster._subscriptions = [];\n            }\n            if (toaster && toaster._subscriptions) {\n                toaster._subscriptions.push(onHideSubscription);\n            }\n        }\n    }\n\n    private getDialogConfig(variable, options, dialogId, closeCallBackFn) {\n        return {\n            'title' : options.title || variable.dataBinding.title,\n            'text' : options.message || variable.dataBinding.text,\n            'okButtonText' : options.okButtonText || variable.dataBinding.okButtonText || 'OK',\n            'cancelButtonText' : options.cancelButtonText || variable.dataBinding.cancelButtonText || 'CANCEL',\n            'alerttype' : options.alerttype || variable.dataBinding.alerttype || 'information',\n            onOk: () => {\n                // Close the action dialog after triggering onOk callback event\n                dialogService.close(dialogId, undefined, closeCallBackFn);\n            },\n            onCancel: () => {\n                initiateCallback('onCancel', variable, options.data);\n                // Close the action dialog after triggering onCancel callback event\n                dialogService.close(dialogId, undefined);\n            },\n            onClose: () => {\n                initiateCallback('onClose', variable, options.data);\n            }\n        };\n    }\n\n    private notifyViaDialog(variable, options) {\n        const isPrefabType = getWmProjectProperties().type === 'PREFAB';\n        const dialogPrefix = isPrefabType ? 'Prefab' : 'Common';\n        const dialogId = dialogPrefix + capitalize(variable.operation) + 'Dialog';\n        const closeCallBackFn = () => initiateCallback('onOk', variable, options.data);\n\n\n        let dialogConfig: any = this.getDialogConfig(variable, options, dialogId, closeCallBackFn);\n        dialogConfig = isPrefabType ? dialogConfig : { notification: dialogConfig };\n        dialogService.open(dialogId, undefined, dialogConfig);\n    }\n\n// *********************************************************** PUBLIC ***********************************************************//\n\n    notify(variable, options, success, error) {\n        const operation = variable.operation;\n        options = options || {};\n\n        if (operation === 'toast') {\n            this.notifyViaToaster(variable, options);\n        } else {\n            this.notifyViaDialog(variable, options);\n        }\n    }\n\n    getMessage(variable) {\n        return variable.dataBinding.text;\n    }\n\n    setMessage(variable, text) {\n        if (isString(text)) {\n            variable.dataBinding.text = text;\n        }\n        return variable.dataBinding.text;\n    }\n\n    getOkButtonText(variable) {\n        return variable.dataBinding.okButtonText;\n    }\n    setOkButtonText(variable, text) {\n        if (isString(text)) {\n            variable.dataBinding.okButtonText = text;\n        }\n        return variable.dataBinding.okButtonText;\n    }\n\n    getToasterDuration(variable) {\n        return variable.dataBinding.duration;\n    }\n\n    setToasterDuration(variable, duration) {\n        variable.dataBinding.duration = duration;\n        return variable.dataBinding.duration;\n    }\n\n    getToasterClass(variable) {\n        return variable.dataBinding.class;\n    }\n\n    setToasterClass(variable, type) {\n        if (isString(type)) {\n            variable.dataBinding.class = type;\n        }\n        return variable.dataBinding.class;\n    }\n\n    getToasterPosition(variable) {\n        return variable.dataBinding.class;\n    }\n\n    setToasterPosition(variable, position) {\n        if (isString(position)) {\n            variable.dataBinding.position = position;\n        }\n        return variable.dataBinding.position;\n    }\n\n    getAlertType(variable) {\n        return variable.dataBinding.alerttype;\n    }\n\n    setAlertType(variable, alerttype) {\n        if (isString(alerttype)) {\n            variable.dataBinding.alerttype = alerttype;\n        }\n        return variable.dataBinding.alerttype;\n    }\n\n    getCancelButtonText(variable) {\n        return variable.dataBinding.cancelButtonText;\n    }\n\n    setCancelButtonText(variable, text) {\n        if (isString(text)) {\n            variable.dataBinding.cancelButtonText = text;\n        }\n        return variable.dataBinding.cancelButtonText;\n    }\n}\n"]}

package/variables/esm2022/manager/variable/base-variable.manager.mjs

@@ -0,0 +1,81 @@
+import { httpService, processBinding } from '../../util/variable/variables.utils';
+import { appManager } from './../../util/variable/variables.utils';
+import { extend } from "lodash-es";
+export class BaseVariableManager {
+    initBinding(variable, bindSource, bindTarget) {
+        processBinding(variable, variable._context, bindSource, bindTarget);
+    }
+    notifyInflight(variable, status, data, options) {
+        appManager.notify('toggle-variable-state', {
+            variable: variable,
+            active: status,
+            data: data,
+            options: options
+        });
+    }
+    /**
+     * This method sets the variable parameter requestTrackId to X-WM-Request-Track-Id which is received in the response headers.
+     * @param response
+     */
+    setRequestTrackId(response, variable) {
+        const requestTrackId = response?.headers?.get('x-wm-request-track-id');
+        if (requestTrackId) {
+            variable._requestTrackId = requestTrackId;
+        }
+    }
+    /**
+     * This method makes the final angular http call that returns an observable.
+     * We attach this observable to variable to cancel a network call
+     * @param requestParams
+     * @param variable
+     * @param dbOperation
+     */
+    httpCall(requestParams, variable, params) {
+        return new Promise((resolve, reject) => {
+            variable._observable = httpService.sendCallAsObservable(requestParams, params).subscribe((response) => {
+                if (response && response.type) {
+                    this.setRequestTrackId(response, variable);
+                    resolve(response);
+                }
+            }, (err) => {
+                this.setRequestTrackId(err, variable);
+                if (httpService.isPlatformSessionTimeout(err)) {
+                    // send the notification manually to hide any context spinners on page.
+                    // [TODO]: any spinners on widget listening on this variable will also go off. Need to see an approach to sovle that.
+                    this.notifyInflight(variable, false, err);
+                    // MEMORY LEAK FIX: Store subscription for cleanup (though it's a one-time promise resolver)
+                    const error401Subscription = err._401Subscriber.asObservable().subscribe(response => {
+                        resolve(response);
+                        // Unsubscribe after resolution
+                        if (error401Subscription && !error401Subscription.closed) {
+                            error401Subscription.unsubscribe();
+                        }
+                    }, e => {
+                        reject(e);
+                        // Unsubscribe after rejection
+                        if (error401Subscription && !error401Subscription.closed) {
+                            error401Subscription.unsubscribe();
+                        }
+                    });
+                }
+                else {
+                    reject(err);
+                }
+            });
+        });
+    }
+    /**
+     * This method prepares the options parameter for variable callbacks.
+     * @param xhrObj, The xhrObj to be passed
+     * @param moreOptions, any other info to be passed in the options param
+     */
+    prepareCallbackOptions(xhrObj, moreOptions) {
+        let options = {};
+        options['xhrObj'] = xhrObj;
+        if (moreOptions) {
+            extend(options, moreOptions);
+        }
+        return options;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-variable.manager.js","sourceRoot":"","sources":["../../../../../projects/variables/src/manager/variable/base-variable.manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { httpService, processBinding } from '../../util/variable/variables.utils';\nimport { appManager} from './../../util/variable/variables.utils';\nimport { AdvancedOptions } from '../../advanced-options';\nimport {extend} from \"lodash-es\";\n\nexport abstract class BaseVariableManager {\n\n    initBinding(variable, bindSource?, bindTarget?) {\n        processBinding(variable, variable._context, bindSource, bindTarget);\n    }\n\n    notifyInflight(variable, status: boolean, data?: any, options?: any) {\n        appManager.notify('toggle-variable-state', {\n            variable: variable,\n            active: status,\n            data: data,\n            options: options\n        });\n    }\n\n    /**\n     * This method sets the variable parameter requestTrackId to X-WM-Request-Track-Id which is received in the response headers.\n     * @param response\n     */\n    setRequestTrackId(response, variable) {\n        const requestTrackId = response?.headers?.get('x-wm-request-track-id');\n        if (requestTrackId) {\n            variable._requestTrackId = requestTrackId;\n        }\n    }\n\n    /**\n     * This method makes the final angular http call that returns an observable.\n     * We attach this observable to variable to cancel a network call\n     * @param requestParams\n     * @param variable\n     * @param dbOperation\n     */\n    httpCall(requestParams, variable, params?: any) {\n        return new Promise((resolve, reject) => {\n            variable._observable = httpService.sendCallAsObservable(requestParams, params).subscribe((response: any) => {\n                if (response && response.type) {\n                    this.setRequestTrackId(response, variable);\n                    resolve(response);\n                }\n            }, (err: any) => {\n                this.setRequestTrackId(err, variable);\n                if (httpService.isPlatformSessionTimeout(err)) {\n                    // send the notification manually to hide any context spinners on page.\n                    // [TODO]: any spinners on widget listening on this variable will also go off. Need to see an approach to sovle that.\n                    this.notifyInflight(variable, false, err);\n                    // MEMORY LEAK FIX: Store subscription for cleanup (though it's a one-time promise resolver)\n                    const error401Subscription = err._401Subscriber.asObservable().subscribe(\n                        response => {\n                            resolve(response);\n                            // Unsubscribe after resolution\n                            if (error401Subscription && !error401Subscription.closed) {\n                                error401Subscription.unsubscribe();\n                            }\n                        },\n                        e => {\n                            reject(e);\n                            // Unsubscribe after rejection\n                            if (error401Subscription && !error401Subscription.closed) {\n                                error401Subscription.unsubscribe();\n                            }\n                        });\n                } else {\n                    reject(err);\n                }\n            });\n        });\n    }\n\n    /**\n     * This method prepares the options parameter for variable callbacks.\n     * @param xhrObj, The xhrObj to be passed\n     * @param moreOptions, any other info to be passed in the options param\n     */\n    prepareCallbackOptions(xhrObj: any, moreOptions? : any): AdvancedOptions {\n        let options: AdvancedOptions = {};\n        options['xhrObj'] = xhrObj;\n        if (moreOptions) {\n            extend(options, moreOptions);\n        }\n        return options;\n    }\n}\n"]}