@colijnit/ioneconnector 256.1.2 → 256.1.3

package/build/provider/ajax.service.js

@@ -1,294 +1,337 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AjaxService = void 0;
-const backend_service_name_enum_1 = require("../enum/backend-service-name.enum");
-const base_backend_connection_service_1 = require("./base-backend-connection.service");
-const axios_1 = require("axios");
-const url_utils_1 = require("../utils/url-utils");
-const datasession_service_method_enum_1 = require("../enum/datasession-service-method.enum");
-const end_point_enum_1 = require("../enum/end-point.enum");
-const login_service_method_enum_1 = require("../enum/login-service-method.enum");
-class AjaxService extends base_backend_connection_service_1.BaseBackendConnectionService {
-    constructor(options) {
-        super(options);
-        this._showLoaderRequests = 0;
-        this._timeout = 180000;
-        if (options && options.timeoutInMs) {
-            this._timeout = options.timeoutInMs;
-        }
-    }
-    async connect() {
-        if (this.options && this.options.getAccessTokenFunction !== undefined) {
-            return this.localStorageService.loginResponse;
-        }
-        await this.loginService.getKeycloakParams();
-        await this.loginService.getCompanies();
-        const keycloakCode = this._getParameter("code");
-        const keycloakState = this._getParameter("state");
-        if (keycloakCode && keycloakState) {
-            let url = window.location.href;
-            url = url.replace('#', '?');
-            const uri = url.split("?")[0];
-            window.history.replaceState(null, "", uri);
-            return this.loginService.loginByKeycloakCode(keycloakCode, keycloakState, uri);
-        }
-        else {
-            if (this.loginService.keycloakParams && this.loginService.keycloakParams.isIdentityServerEnabled) {
-                this._redirectToIdentityServerRealm();
-            }
-            if (this.usePublicToken) {
-                if (this.localStorageService.publicToken) {
-                    return null;
-                }
-                await this.createPublicSession();
-                return null;
-            }
-            else {
-                if (this.localStorageService.sessionId) {
-                    return this.localStorageService.loginResponse;
-                }
-                let response = await this.loginService.loginAndCreateDataSession();
-                return response;
-            }
-        }
-    }
-    hasSession() {
-        return this.localStorageService.sessionId !== undefined;
-    }
-    isPublicSession() {
-        return this.usePublicToken;
-    }
-    async call(method, data = {}, showLoader = true, service = undefined, endPoint = end_point_enum_1.EndPoint.AjaxService, isPublicService = false, ownMessage) {
-        if (!service) {
-            if (!this.usePublicToken) {
-                service = backend_service_name_enum_1.BackendServiceName.LoginService;
-            }
-            else {
-                service = backend_service_name_enum_1.BackendServiceName.PublicService;
-            }
-        }
-        if (this.usePublicToken || (service === backend_service_name_enum_1.BackendServiceName.PublicService ||
-            service === backend_service_name_enum_1.BackendServiceName.LoginService ||
-            service === backend_service_name_enum_1.BackendServiceName.DatasessionService)) {
-            return this._doCall(method, data, showLoader, service, endPoint, isPublicService, ownMessage);
-        }
-        else {
-            return this._doCall(method, data, showLoader, service, endPoint, isPublicService, ownMessage);
-        }
-    }
-    async callBeacon(method, data = {}, service = undefined, endPoint = end_point_enum_1.EndPoint.AjaxService) {
-        if (!service) {
-            if (!this.usePublicToken) {
-                service = backend_service_name_enum_1.BackendServiceName.LoginService;
-            }
-            else {
-                service = backend_service_name_enum_1.BackendServiceName.PublicService;
-            }
-        }
-        if (navigator.sendBeacon) {
-            let messageToSend = JSON.stringify({
-                service: service,
-                method: method,
-                id: this.callId,
-                data: data,
-                dataSessionId: this.session ? this.session.dataSessionId : "",
-                windowSessionId: this.session ? this.session.windowsId : "1",
-                sessionId: this.session ? this.session.id : ""
-            });
-            navigator.sendBeacon(url_utils_1.UrlUtils.createReadableUrl(method, data, this.url, endPoint), messageToSend);
-        }
-    }
-    async login(request, encrypt) {
-        const response = await this.loginService.loginAndCreateDataSession(request, encrypt);
-        if (typeof response !== 'boolean') {
-            return response;
-        }
-    }
-    async confirmCode(upId, userName, confirmationCode, clientDeviceFingerprint, clientDeviceDescription, rememberClientDeviceForMFA) {
-        return this.loginService.confirmCode(upId, userName, confirmationCode, clientDeviceFingerprint, clientDeviceDescription, rememberClientDeviceForMFA);
-    }
-    async resetGoogleAuth(upId, userName) {
-        return this.loginService.resetGoogleAuth(upId, userName);
-    }
-    async changePassword(password, securityCode, upId) {
-        return this.loginService.changePassword(password, securityCode, upId);
-    }
-    async changePasswordAndActivateUser(password, securityCode, upId, reCaptchaResponse) {
-        return this.loginService.changePasswordAndActivateUser(password, securityCode, upId, reCaptchaResponse);
-    }
-    async sendResetPasswordOrInviteMessage(upId, userName, reCaptchaResponse) {
-        return this.loginService.sendResetPasswordOrInviteMessage(upId, userName, reCaptchaResponse);
-    }
-    async getUserNameBySecurityCode(securityCode, upId) {
-        return this.loginService.getUserNameBySecurityCode(securityCode, upId);
-    }
-    async getPublicKey() {
-        return this.loginService.getPublicKey();
-    }
-    close() {
-        if (this.usePublicToken) {
-            this.localStorageService.clear();
-            this.localStorageService.setPublicToken(undefined);
-            return this._doCall(datasession_service_method_enum_1.DatasessionServiceMethod.ClosePublicSession, {}, false, backend_service_name_enum_1.BackendServiceName.PublicService);
-        }
-        else {
-            return this.closeDataSession();
-        }
-    }
-    _doCall(method, data = {}, showLoader = true, service = undefined, endPoint = end_point_enum_1.EndPoint.AjaxService, isPublicService = false, ownMessage) {
-        if (!service) {
-            if (!this.usePublicToken) {
-                service = backend_service_name_enum_1.BackendServiceName.LoginService;
-            }
-            else {
-                service = backend_service_name_enum_1.BackendServiceName.PublicService;
-            }
-        }
-        if (showLoader) {
-            this.setShowLoaderRequests(this._showLoaderRequests + 1);
-        }
-        return new Promise(async (resolve, reject) => {
-            const url = url_utils_1.UrlUtils.createReadableUrl(method, data, this.url, endPoint);
-            let message;
-            if (ownMessage) {
-                message = JSON.stringify(ownMessage);
-            }
-            else {
-                if (this._methodNeedsAccessToken(method)) {
-                    await this._waitForAccessToken((data && service && service === backend_service_name_enum_1.BackendServiceName.LoginService) || method === datasession_service_method_enum_1.DatasessionServiceMethod.CreatePublicSession, this.usePublicToken);
-                }
-                if (this.usePublicToken && !isPublicService) {
-                    message = JSON.stringify({
-                        method: method,
-                        data: data,
-                        token: this.session.publicToken
-                    });
-                }
-                else {
-                    message = JSON.stringify({
-                        service: service,
-                        method: method,
-                        id: this.callId,
-                        data: data,
-                        dataSessionId: this.session ? this.session.dataSessionId : "",
-                        windowSessionId: this.session ? this.session.windowsId : "1",
-                        sessionId: this.session ? this.session.id : ""
-                    });
-                }
-            }
-            let headers = {
-                "Content-Type": "application/json; charset=utf-8"
-            };
-            const authorize = service !== backend_service_name_enum_1.BackendServiceName.PublicService && method !== login_service_method_enum_1.LoginServiceMethod.RefreshAccessToken;
-            if (authorize) {
-                headers.Authorization = `Bearer ${this.jwtService.jwt}`;
-            }
-            (0, axios_1.default)({
-                method: 'post',
-                url: url,
-                data: message,
-                withCredentials: authorize,
-                timeout: this._timeout,
-                headers: headers
-            }).then(response => {
-                if (response.data) {
-                    if (response.data.exception) {
-                        resolve(response.data.exception);
-                    }
-                    else {
-                        resolve(response.data.data);
-                    }
-                }
-            }).catch(error => {
-                if (showLoader) {
-                    this.setShowLoaderRequests(0);
-                }
-                if (error.code === "ECONNABORTED") {
-                    this.connectionAborted.next();
-                }
-                console.error(error);
-                reject();
-            });
-        }).then(response => {
-            if (showLoader) {
-                this.setShowLoaderRequests(this._showLoaderRequests - 1);
-            }
-            return new Promise((resolve) => { return resolve(response); });
-        });
-    }
-    _methodNeedsAccessToken(method) {
-        return this.methodWithoutAccessToken.indexOf(method) < 0;
-    }
-    async _waitForAccessToken(isLogin, publicToken) {
-        if (this.jwtService.retrievingToken) {
-            return new Promise((resolve) => {
-                if (window.hasOwnProperty('tokenRetrieved')) {
-                    window.tokenRetrieved.subscribe(() => {
-                        resolve(true);
-                    });
-                }
-                else {
-                    resolve(true);
-                }
-            });
-        }
-        await this.jwtService.getAccessToken(!isLogin);
-        if (publicToken) {
-            this.session.publicToken = this.jwtService.jwt;
-        }
-    }
-    setShowLoaderRequests(amount) {
-        this._showLoaderRequests = amount;
-        if (this._showLoaderRequests > 0) {
-            this.showLoader.next(true);
-        }
-        else {
-            this.showLoader.next(false);
-        }
-    }
-    _redirectToIdentityServerRealm() {
-        if (this.loginService.company && this.loginService.company.realmId && this.loginService.company.clientId) {
-            let state = this.localStorageService.keycloakState;
-            if (!state) {
-                state = this._createGuid();
-                this.localStorageService.setKeycloakState(state);
-            }
-            const redirectUrl = window.location.href;
-            const query = {
-                state: state,
-                client_id: this.loginService.company.clientId,
-                response_type: "code",
-                response_mode: "fragment",
-                redirect_uri: redirectUrl
-            };
-            const queryUrl = new URLSearchParams(query).toString();
-            const fullUrl = this.loginService.keycloakParams.keycloakUrl + "/realms/" + this.loginService.company.realmId + "/protocol/openid-connect/auth" + "?" + queryUrl;
-            window.location.href = fullUrl;
-        }
-        else {
-            console.error("Identity server information is not defined for the selected company");
-        }
-    }
-    _getParameter(parameterName) {
-        let url = window.location.href;
-        url = url.replace('#', '?');
-        parameterName = parameterName.replace(/[\[\]]/g, "\\$&");
-        const regex = new RegExp("[?&]" + parameterName + "(=([^&#]*)|&|#|$)");
-        const results = regex.exec(url);
-        if (!results) {
-            return null;
-        }
-        else if (!results[2]) {
-            return "";
-        }
-        return decodeURIComponent(results[2].replace(/\+/g, " "));
-    }
-    _createGuid() {
-        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-            const r = Math.random() * 16 | 0;
-            return (c === "x" ? r : (r & 0x3 | 0x8)).toString(16);
-        });
-    }
-}
-exports.AjaxService = AjaxService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AjaxService = void 0;
+const backend_service_name_enum_1 = require("../enum/backend-service-name.enum");
+const base_backend_connection_service_1 = require("./base-backend-connection.service");
+const axios_1 = require("axios");
+const url_utils_1 = require("../utils/url-utils");
+const datasession_service_method_enum_1 = require("../enum/datasession-service-method.enum");
+const end_point_enum_1 = require("../enum/end-point.enum");
+const login_service_method_enum_1 = require("../enum/login-service-method.enum");
+class AjaxService extends base_backend_connection_service_1.BaseBackendConnectionService {
+    constructor(options) {
+        super(options);
+        this._showLoaderRequests = 0;
+        this._timeout = 180000;
+        if (options && options.timeoutInMs) {
+            this._timeout = options.timeoutInMs;
+        }
+    }
+    async checkAndPrepareKeycloak() {
+        await this.loginService.getKeycloakParams();
+        await this.loginService.getCompanies();
+        const keycloakCode = this._getParameter("code");
+        const keycloakState = this._getParameter("state");
+        if (keycloakCode && keycloakState) {
+            let url = window.location.href;
+            url = url.replace('#', '?');
+            const uri = url.split("?")[0];
+            window.history.replaceState(null, "", uri);
+            this.usePublicToken = false;
+            return this.loginService.loginByKeycloakCode(keycloakCode, keycloakState, uri);
+        }
+        else {
+            if (this.loginService.keycloakParams && this.loginService.keycloakParams.isIdentityServerEnabled) {
+                this._redirectToIdentityServerRealm();
+            }
+        }
+    }
+    async connect(url, schema, version) {
+        const keycloakLoginData = this.sessionStorageService.getKeycloakLoginData();
+        if (keycloakLoginData) {
+            const userNameFromKeycloak = keycloakLoginData.userName;
+            const userObject = this.localStorageService.getUserObject(userNameFromKeycloak);
+            if (userObject && userObject.loginResponse) {
+                this.session.dataSessionId = userObject.dataSessionId;
+                this.session.id = userObject.sessionId;
+                this.usePublicToken = false;
+                return userObject.loginResponse;
+            }
+        }
+        if (this.usePublicToken) {
+            if (this.localStorageService.publicToken) {
+                return null;
+            }
+            await this.createPublicSession();
+            return null;
+        }
+        else {
+            let response;
+            if (this.localStorageService.sessionId) {
+                if (!this.localStorageService.loginResponse) {
+                    response = await this.userInfoService.getActiveUserInfo();
+                    if (response && response.upId && response.loginStatus === 'SUCCESS') {
+                        this.localStorageService.setLoginResponse(response);
+                    }
+                    else {
+                        return this._nativeLogin(url, schema, version);
+                    }
+                }
+                return this.localStorageService.loginResponse;
+            }
+            response = await this.checkAndPrepareKeycloak();
+            if (response) {
+                return response;
+            }
+            response = await this._nativeLogin(url, schema, version);
+            return response;
+        }
+    }
+    hasSession() {
+        return this.localStorageService.sessionId !== undefined;
+    }
+    isPublicSession() {
+        return this.usePublicToken;
+    }
+    async call(method, data = {}, showLoader = true, service = undefined, endPoint = end_point_enum_1.EndPoint.AjaxService, isPublicService = false, ownMessage, url) {
+        if (!service) {
+            if (!this.usePublicToken) {
+                service = backend_service_name_enum_1.BackendServiceName.LoginService;
+            }
+            else {
+                service = backend_service_name_enum_1.BackendServiceName.PublicService;
+            }
+        }
+        if (this.usePublicToken || (service === backend_service_name_enum_1.BackendServiceName.PublicService ||
+            service === backend_service_name_enum_1.BackendServiceName.LoginService ||
+            service === backend_service_name_enum_1.BackendServiceName.DatasessionService)) {
+            return this._doCall(method, data, showLoader, service, endPoint, isPublicService, ownMessage, url);
+        }
+        else {
+            return this._doCall(method, data, showLoader, service, endPoint, isPublicService, ownMessage, url);
+        }
+    }
+    async callBeacon(method, data = {}, service = undefined, endPoint = end_point_enum_1.EndPoint.AjaxService) {
+        if (!service) {
+            if (!this.usePublicToken) {
+                service = backend_service_name_enum_1.BackendServiceName.LoginService;
+            }
+            else {
+                service = backend_service_name_enum_1.BackendServiceName.PublicService;
+            }
+        }
+        if (navigator.sendBeacon) {
+            let messageToSend = JSON.stringify({
+                service: service,
+                method: method,
+                id: this.callId,
+                data: data,
+                dataSessionId: this.session ? this.session.dataSessionId : "",
+                windowSessionId: this.session ? this.session.windowsId : "1",
+                sessionId: this.session ? this.session.id : ""
+            });
+            navigator.sendBeacon(url_utils_1.UrlUtils.createReadableUrl(method, data, this.url, endPoint), messageToSend);
+        }
+    }
+    async login(request, encrypt) {
+        const response = await this.loginService.loginAndCreateDataSession(request, encrypt);
+        if (typeof response !== 'boolean') {
+            return response;
+        }
+    }
+    async confirmCode(upId, userName, confirmationCode, clientDeviceFingerprint, clientDeviceDescription, rememberClientDeviceForMFA) {
+        return this.loginService.confirmCode(upId, userName, confirmationCode, clientDeviceFingerprint, clientDeviceDescription, rememberClientDeviceForMFA);
+    }
+    async resetGoogleAuth(upId, userName) {
+        return this.loginService.resetGoogleAuth(upId, userName);
+    }
+    async changePassword(password, securityCode, upId) {
+        return this.loginService.changePassword(password, securityCode, upId);
+    }
+    async changePasswordAndActivateUser(password, securityCode, upId, reCaptchaResponse) {
+        return this.loginService.changePasswordAndActivateUser(password, securityCode, upId, reCaptchaResponse);
+    }
+    async sendResetPasswordOrInviteMessage(upId, userName, reCaptchaResponse) {
+        return this.loginService.sendResetPasswordOrInviteMessage(upId, userName, reCaptchaResponse);
+    }
+    async getUserNameBySecurityCode(securityCode, upId) {
+        return this.loginService.getUserNameBySecurityCode(securityCode, upId);
+    }
+    async getPublicKey() {
+        return this.loginService.getPublicKey();
+    }
+    clearStorageAndLogout() {
+        if (this.usePublicToken) {
+            this.localStorageService.clear();
+            this.localStorageService.setPublicToken(undefined);
+            this.callBeacon(datasession_service_method_enum_1.DatasessionServiceMethod.ClosePublicSession, {}, backend_service_name_enum_1.BackendServiceName.PublicService);
+        }
+        else {
+            this.loginService.clearAllStorage();
+        }
+    }
+    close() {
+        if (this.usePublicToken) {
+            this.localStorageService.clear();
+            this.localStorageService.setPublicToken(undefined);
+            return this._doCall(datasession_service_method_enum_1.DatasessionServiceMethod.ClosePublicSession, {}, false, backend_service_name_enum_1.BackendServiceName.PublicService);
+        }
+        else {
+            return this.closeDataSession();
+        }
+    }
+    _doCall(method, data = {}, showLoader = true, service = undefined, endPoint = end_point_enum_1.EndPoint.AjaxService, isPublicService = false, ownMessage, url) {
+        if (!service) {
+            if (!this.usePublicToken) {
+                service = backend_service_name_enum_1.BackendServiceName.LoginService;
+            }
+            else {
+                service = backend_service_name_enum_1.BackendServiceName.PublicService;
+            }
+        }
+        if (showLoader) {
+            this.setShowLoaderRequests(this._showLoaderRequests + 1);
+        }
+        return new Promise(async (resolve, reject) => {
+            const readableUrl = url_utils_1.UrlUtils.createReadableUrl(method, data, url ? url : this.url, endPoint);
+            let message;
+            if (ownMessage) {
+                message = JSON.stringify(ownMessage);
+            }
+            else {
+                if (this._methodNeedsAccessToken(method)) {
+                    await this._waitForAccessToken((data && service && service === backend_service_name_enum_1.BackendServiceName.LoginService) || method === datasession_service_method_enum_1.DatasessionServiceMethod.CreatePublicSession, this.usePublicToken);
+                }
+                if (this.usePublicToken && !isPublicService) {
+                    message = JSON.stringify({
+                        method: method,
+                        data: data,
+                        token: this.session.publicToken
+                    });
+                }
+                else {
+                    message = JSON.stringify({
+                        service: service,
+                        method: method,
+                        id: this.callId,
+                        data: data,
+                        dataSessionId: this.session ? this.session.dataSessionId : "",
+                        windowSessionId: this.session ? this.session.windowsId : "1",
+                        sessionId: this.session ? this.session.id : ""
+                    });
+                }
+            }
+            let headers = {
+                "Content-Type": "application/json; charset=utf-8"
+            };
+            const authorize = service !== backend_service_name_enum_1.BackendServiceName.PublicService && method !== login_service_method_enum_1.LoginServiceMethod.RefreshAccessToken;
+            if (authorize) {
+                headers.Authorization = `Bearer ${this.jwtService.jwt}`;
+            }
+            (0, axios_1.default)({
+                method: 'post',
+                url: readableUrl,
+                data: message,
+                withCredentials: authorize,
+                timeout: this._timeout,
+                headers: headers
+            }).then(response => {
+                if (response.data) {
+                    if (response.data.exception) {
+                        resolve(response.data.exception);
+                    }
+                    else {
+                        resolve(response.data.data);
+                    }
+                }
+            }).catch(error => {
+                if (showLoader) {
+                    this.setShowLoaderRequests(0);
+                }
+                if (error.code === "ECONNABORTED") {
+                    this.connectionAborted.next();
+                }
+                console.error(error);
+                reject();
+            });
+        }).then(response => {
+            if (showLoader) {
+                this.setShowLoaderRequests(this._showLoaderRequests - 1);
+            }
+            return new Promise((resolve) => { return resolve(response); });
+        });
+    }
+    _nativeLogin(url, schema, version) {
+        if (this.externalSourceId) {
+            return this.loginService.loginToExternalSource(this.externalSourceId, url, schema, version);
+        }
+        else {
+            return this.loginService.loginAndCreateDataSession();
+        }
+    }
+    _methodNeedsAccessToken(method) {
+        return this.methodWithoutAccessToken.indexOf(method) < 0;
+    }
+    async _waitForAccessToken(isLogin, publicToken) {
+        if (this.jwtService.retrievingToken) {
+            return new Promise((resolve) => {
+                if (window.hasOwnProperty('tokenRetrieved')) {
+                    window.tokenRetrieved.subscribe(() => {
+                        resolve(true);
+                    });
+                }
+                else {
+                    resolve(true);
+                }
+            });
+        }
+        await this.jwtService.getAccessToken(!isLogin);
+        if (publicToken) {
+            this.session.publicToken = this.jwtService.jwt;
+        }
+    }
+    setShowLoaderRequests(amount) {
+        this._showLoaderRequests = amount;
+        if (this._showLoaderRequests > 0) {
+            this.showLoader.next(true);
+        }
+        else {
+            this.showLoader.next(false);
+        }
+    }
+    _redirectToIdentityServerRealm() {
+        if (this.loginService.company && this.loginService.company.realmId && this.loginService.company.clientId) {
+            let state = this.localStorageService.keycloakState;
+            if (!state) {
+                state = this._createGuid();
+                this.localStorageService.setKeycloakState(state);
+            }
+            const redirectUrl = window.location.href;
+            const query = {
+                state: state,
+                client_id: this.loginService.company.clientId,
+                response_type: "code",
+                response_mode: "fragment",
+                redirect_uri: redirectUrl
+            };
+            const queryUrl = new URLSearchParams(query).toString();
+            const fullUrl = this.loginService.keycloakParams.keycloakUrl + "/realms/" + this.loginService.company.realmId + "/protocol/openid-connect/auth" + "?" + queryUrl;
+            window.location.href = fullUrl;
+        }
+        else {
+            console.error("Identity server information is not defined for the selected company");
+        }
+    }
+    _getParameter(parameterName) {
+        let url = window.location.href;
+        url = url.replace('#', '?');
+        parameterName = parameterName.replace(/[\[\]]/g, "\\$&");
+        const regex = new RegExp("[?&]" + parameterName + "(=([^&#]*)|&|#|$)");
+        const results = regex.exec(url);
+        if (!results) {
+            return null;
+        }
+        else if (!results[2]) {
+            return "";
+        }
+        return decodeURIComponent(results[2].replace(/\+/g, " "));
+    }
+    _createGuid() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = Math.random() * 16 | 0;
+            return (c === "x" ? r : (r & 0x3 | 0x8)).toString(16);
+        });
+    }
+}
+exports.AjaxService = AjaxService;
 //# sourceMappingURL=ajax.service.js.map