@bnsights/bbsf-utilities 1.0.39 → 1.0.41

package/fesm2015/{bnsights-bbsf-utilities.js → bnsights-bbsf-utilities.mjs}

@@ -1,26 +1,26 @@
+import { DOCUMENT, CommonModule } from '@angular/common';
 import * as i0 from '@angular/core';
-import { Injectable, Injector, Inject, NgModule } from '@angular/core';
-import * as i4 from '@angular/router';
-import { Router, RouterModule } from '@angular/router';
-import * as i1 from '@ngx-translate/core';
+import { Injectable, Inject, inject, NgModule } from '@angular/core';
+import * as i1$1 from '@angular/router';
+import { RouterModule } from '@angular/router';
+import * as i4 from '@ngx-translate/core';
 import { TranslateService } from '@ngx-translate/core';
+import * as i1$2 from 'ng-block-ui';
 import { BlockUI, BlockUIModule } from 'ng-block-ui';
+import * as i2 from 'ngx-toastr';
 import { ToastrService, ToastrModule } from 'ngx-toastr';
-import { HttpModule } from '@angular/http';
+import * as i4$1 from 'ngx-cookie-service';
+import { CookieService } from 'ngx-cookie-service';
 import { __decorate, __awaiter, __rest } from 'tslib';
-import * as i1$1 from '@angular/common/http';
-import { HttpHeaders, HttpClient, HttpParams } from '@angular/common/http';
-import { BehaviorSubject, Subject, Observable, throwError } from 'rxjs';
+import * as i1 from '@angular/common/http';
+import { HttpParams, HttpHeaders } from '@angular/common/http';
+import { Subject, Observable, throwError, BehaviorSubject } from 'rxjs';
 import { JwtHelperService } from '@auth0/angular-jwt';
-import * as i5 from 'ngx-cookie-service';
-import { CookieService } from 'ngx-cookie-service';
-import { takeUntil, tap, map } from 'rxjs/operators';
 import { plainToClass } from 'class-transformer';
-import * as i1$2 from '@angular/common';
-import { DOCUMENT, CommonModule } from '@angular/common';
+import { takeUntil, tap, map } from 'rxjs/operators';
 import JSZip from 'jszip';
 import { fragment, create } from 'xmlbuilder2';
-import VNode from 'virtual-dom/vnode/vnode';
+import VNode$1 from 'virtual-dom/vnode/vnode';
 import VText from 'virtual-dom/vnode/vtext';
 import HTMLToVDOM from 'html-to-vdom';
 import { cloneDeep } from 'lodash';
@@ -28,357 +28,418 @@ import { nanoid } from 'nanoid';
 import isVNode from 'virtual-dom/vnode/is-vnode';
 import isVText from 'virtual-dom/vnode/is-vtext';
 import escape from 'escape-html';
-import sizeOf from 'image-size';
+import colorNames from 'color-name';
 import imageToBase64 from 'image-to-base64';
 import mimeTypes from 'mime-types';
-import colorNames from 'color-name';
+import sizeOf from 'image-size';
 
-class BBSFTranslateService extends TranslateService {
-}
-BBSFTranslateService.ɵprov = i0.ɵɵdefineInjectable({ factory: function BBSFTranslateService_Factory() { return new BBSFTranslateService(i0.ɵɵinject(i1.TranslateStore), i0.ɵɵinject(i1.TranslateLoader), i0.ɵɵinject(i1.TranslateCompiler), i0.ɵɵinject(i1.TranslateParser), i0.ɵɵinject(i1.MissingTranslationHandler), i0.ɵɵinject(i1.USE_DEFAULT_LANG), i0.ɵɵinject(i1.USE_STORE), i0.ɵɵinject(i1.USE_EXTEND), i0.ɵɵinject(i1.DEFAULT_LANGUAGE)); }, token: BBSFTranslateService, providedIn: "root" });
-BBSFTranslateService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
+class User {
+}
 
-// This file can be replaced during build by using the `fileReplacements` array.
-// `ng build ---prod` replaces `environment.ts` with `environment.prod.ts`.
-// The list of file replacements can be found in `angular.json`.
-const environment = Object.assign({}, window.Environment);
-/*
- * In development mode, to ignore zone related error stack frames such as
- * `zone.run`, `zoneDelegate.invokeTask` for easier debugging, you can
- * import the following file, but please comment it out in production mode
- * because it will have performance impact when throw error
- */
-// import 'zone.js/dist/zone-error';  // Included with Angular CLI.
+var AuthenticationModes;
+(function (AuthenticationModes) {
+    AuthenticationModes["Forms"] = "Forms";
+    AuthenticationModes["UAEPass"] = "UAEPass";
+    AuthenticationModes["WindowsAD"] = "WindowsAD";
+    AuthenticationModes["AzureAD"] = "AzureAD";
+})(AuthenticationModes || (AuthenticationModes = {}));
 
-class EnvironmentService {
-    getEnvironmentObject() {
-        return environment;
+class AppearanceConfigurationService {
+    constructor(configService) {
+        this.configService = configService;
     }
-    getBaseUrl() {
-        let Url = environment["BBSF_BaseURL"];
-        return Url;
+    getLayoutTheme() {
+        return this.configService.getConfigurationValue('AnonymousLayout_Theme');
     }
-    getApiUrl() {
-        let Url = environment["BBSF_ApiUrl"];
-        return Url;
+    getFooterText() {
+        return this.configService.getConfigurationValue('AnonymousLayout_FooterText');
     }
-    getProductionMode() {
-        let Mode = environment["BBSF_IsProduction"];
-        return Mode;
+    getPageTitle() {
+        return this.configService.getConfigurationValue('AnonymousLayout_PageTitle');
     }
-    getDefaultLanguage() {
-        let Mode = environment["BBSF_DefaultLanguage"];
-        return Mode;
+    getFavIcon() {
+        return this.configService.getConfigurationValue('AnonymousLayout_FavIcon');
     }
-    getIdentityServerUrl() {
-        let Url = environment["BBSF_IdentityServerUrl"];
-        return Url;
+    getCustomStyles() {
+        return this.configService.getConfigurationValue('AnonymousLayout_CustomStyles');
     }
-    getIsIdentityServerExternal() {
-        let Mode = environment["BBSF_IsExternalIdentityServer"];
-        return Mode;
+    getLogo() {
+        return this.configService.getConfigurationValue('AnonymousLayout_Logo');
     }
-    getIsIdentityServerClientId() {
-        let Mode = environment["BBSF_IdentityServer_Client_Id"];
-        return Mode;
+}
+AppearanceConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AppearanceConfigurationService, deps: [{ token: ConfigurationService }], target: i0.ɵɵFactoryTarget.Injectable });
+AppearanceConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AppearanceConfigurationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AppearanceConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: ConfigurationService }]; } });
+
+class ConfigurationService {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+        this.httpClient.get("./assets/config/configurations.json").subscribe(data => {
+            ConfigurationService.JsonData = data;
+        });
     }
-    getIsIdentityServerClientSecret() {
-        let Mode = environment["BBSF_IdentityServer_Client_Secret"];
-        return Mode;
+    getConfigurationValue(key) {
+        return ConfigurationService.JsonData[key];
     }
 }
-EnvironmentService.AreaList = [];
-EnvironmentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EnvironmentService_Factory() { return new EnvironmentService(); }, token: EnvironmentService, providedIn: "root" });
-EnvironmentService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
+ConfigurationService.JsonData = [];
+ConfigurationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ConfigurationService, deps: [{ token: i1.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+ConfigurationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ConfigurationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ConfigurationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }]; } });
 
-class UtilityService {
-    constructor(translator, environmentService) {
-        this.translator = translator;
-        this.environmentService = environmentService;
-        this.isCreatedBefore = false;
+class AreaModel {
+}
+
+class ErrorModel {
+}
+
+class RequestOptionsModel {
+    constructor() {
+        this.disableSuccessNotification = false;
+        this.disableBlockUI = false;
+        this.disableErrorHandler = false;
+        this.responseType = "";
+        this.formGroup = null;
+        this.castResponsetoClass = true;
     }
-    getResourceValue(Key) {
-        let ResourceValue = this.translator.instant(Key);
-        return ResourceValue;
+}
+
+class WordDocumentModel {
+    constructor() {
+        this.options = new DocumentOptionsModel();
     }
-    getCurrentLanguage() {
-        let currentLanguage = this.environmentService.getDefaultLanguage();
-        let lang = localStorage.getItem('language');
-        if (lang)
-            currentLanguage = lang;
-        else
-            localStorage.setItem('language', currentLanguage);
-        return currentLanguage;
+}
+class DocumentOptionsModel {
+}
+
+class ControlValidationService {
+    constructor(utilityService) {
+        this.utilityService = utilityService;
+        this.requestOptions = new RequestOptionsModel();
+        this.isCreatedBefor = false;
     }
-    isCurrentLanguageEnglish() {
-        return this.getCurrentLanguage() == "en";
+    showGlobalError(errorMessage, formId, deleteOld) {
+        let globalErorrElement = document.getElementsByClassName('alert alert-InvalidValidation bg-light-danger text-danger');
+        if (globalErorrElement.length > 0) {
+            this.removeElementsByClass('alert alert-InvalidValidation bg-light-danger text-danger');
+        }
+        if (this.isCreatedBefor == true) {
+            this.removeElementsByClass('alert alert-InvalidValidation bg-light-danger text-danger');
+        }
+        // tslint:disable-next-line: prefer-const
+        if (!formId)
+            formId = "currentForm";
+        var object = document.getElementById(formId);
+        const tagName = 'div';
+        // tslint:disable-next-line: prefer-const
+        var elementToAppend = document.createElement(tagName); // Your tag name here
+        let message = "";
+        if (!errorMessage || (typeof errorMessage == "string")) {
+            if (localStorage.getItem('language') == "ar")
+                message = errorMessage ? errorMessage : "لديك بعص الأخطاء . من فضلك قم بالمراجعه ";
+            else
+                message = errorMessage ? errorMessage : "You have some validation errors. Please check below";
+            elementToAppend.innerHTML = "<ul class='list-unstyled m-0 py-3 d-flex align-items-center fs-6'><li><i class='fa fa-times-circle text-danger me-3 fs-2'></i>" + message + "</li></ul>";
+            elementToAppend.className += 'alert alert-InvalidValidation bg-light-danger text-danger';
+            elementToAppend.id += 'errorId';
+            // tslint:disable-next-line: prefer-for-of
+            const elementToAppen = elementToAppend.cloneNode(true);
+            // let targetElement = object.getElementsByClassName("b-control")[0];
+            object.insertBefore(elementToAppen, object.firstChild);
+        }
+        else {
+            let ul = document.createElement("ul");
+            elementToAppend.appendChild(ul);
+            for (const iterator of errorMessage) {
+                let li = document.createElement("li");
+                li.innerHTML = iterator;
+                ul.appendChild(li);
+            }
+            elementToAppend.className += 'alert alert-InvalidValidation bg-light-danger text-danger';
+            elementToAppend.id += 'errorId';
+            // tslint:disable-next-line: prefer-for-of
+            const elementToAppen = elementToAppend.cloneNode(true);
+            // let targetElement = object.getElementsByClassName("b-control")[0];
+            object.insertBefore(elementToAppen, object.firstChild);
+        }
+        this.isCreatedBefor = true;
     }
-    isCurrentLanguageArabic() {
-        return this.getCurrentLanguage() == "ar";
+    removeGlobalError() {
+        const removedList = document.getElementsByClassName('alert alert-InvalidValidation bg-light-danger text-danger');
+        // tslint:disable-next-line: prefer-for-of
+        for (let index = 0; index < removedList.length; index++) {
+            const element = removedList[index];
+            element.remove();
+        }
+        this.isCreatedBefor = false;
     }
-    notifySuccessMessage(Message, title, time, showHeader = true) {
-        let MessageTemplate = this.getResourceValue("SuccessMessage");
-        let titleTemplate;
-        if (Message) {
-            MessageTemplate = Message;
+    showInputErro(errors) {
+        // show error on top of form 
+        this.showGlobalError();
+        // remove old error from server
+        this.removeElementsByClass('errortemplet');
+        // Looping in error Object
+        for (const key in errors) {
+            if (errors.hasOwnProperty(key)) {
+                for (const iterator of errors[key]) {
+                    const input = document.querySelectorAll('[ng-reflect-name=' + key + ']')[0];
+                    if (input.attributes['ng-reflect-name'].value === key) {
+                        this.removeElementsByClass('erroclass-' + key);
+                        const tagName = 'p';
+                        const elementToAppend = document.createElement(tagName); // Your tag name here
+                        elementToAppend.innerHTML = iterator;
+                        elementToAppend.style.color = 'red';
+                        elementToAppend.className += 'errortemplet erroclass-' + key;
+                        const elementToappen = elementToAppend.cloneNode(true);
+                        input.parentNode.insertBefore(elementToappen, input.lastChild);
+                        break;
+                    }
+                }
+            }
         }
-        if (title) {
-            titleTemplate = title;
+    }
+    removeElementsByClass(className) {
+        const elements = document.getElementsByClassName(className);
+        while (elements.length > 0) {
+            elements[0].parentNode.removeChild(elements[0]);
         }
-        let toaster = AppInjector.get(ToastrService);
-        showHeader ? toaster.success(MessageTemplate, titleTemplate) : toaster.success(MessageTemplate);
     }
-    notifyErrorMessage(Message, title, time, showHeader = true) {
-        let MessageTemplate = this.getResourceValue("ErrorMessage");
-        let titleTemplate = this.getResourceValue("Error");
-        if (Message) {
-            MessageTemplate = Message;
+    renderServerErrors(form, err, requestOptions, formId) {
+        if (err.error == null) {
+            return;
         }
-        if (title) {
-            titleTemplate = title;
+        let errorsArray = [];
+        this.requestOptions = requestOptions;
+        if (err.error.validation_errors) {
+            err.error.validation_errors.forEach((element) => {
+                let fieldName = element.field;
+                let controlName = element.controlName;
+                let message = element.message;
+                if (form == null) {
+                    this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${message}`);
+                }
+                else if (controlName && !this.hasControlName(form, controlName)) {
+                    errorsArray.push(`${fieldName}: ${message}`);
+                }
+                else {
+                    this.setFieldError(form, controlName, fieldName, message);
+                    this.showGlobalError(null, formId);
+                }
+            });
+            if (errorsArray.length > 0)
+                this.showGlobalError(errorsArray, formId);
         }
-        const toaster = AppInjector.get(ToastrService);
-        showHeader ? toaster.error(MessageTemplate, titleTemplate) : toaster.error(MessageTemplate);
     }
-    notifyWarningMessage(Message, title, time, showHeader = true) {
-        let MessageTemplate = this.getResourceValue("WarningMessage");
-        let titleTemplate = this.getResourceValue("Warning");
-        if (Message) {
-            MessageTemplate = Message;
+    hasControlName(form, controlName) {
+        let control = form.get(controlName);
+        return control != null;
+    }
+    setFieldError(form, controlName, fieldName, message) {
+        let control = null;
+        if (controlName)
+            control = this.getControlFormNameByFieldName(form, controlName);
+        else
+            control = this.getControlFormNameByFieldName(form, fieldName.split('.')[0]);
+        let errors = { "errorMassage": message };
+        let fieldNameArray = fieldName.split('.');
+        if (fieldNameArray.length >= 1) {
+            switch (fieldNameArray[fieldNameArray.length - 1].toLocaleLowerCase()) {
+                case "english":
+                    let englishControl = control.get("English");
+                    englishControl.setErrors(errors);
+                    break;
+                case "arabic":
+                    let arabicControl = control.get("Arabic");
+                    arabicControl.setErrors(errors);
+                    break;
+                default:
+                    control.setErrors(errors);
+            }
         }
-        if (title) {
-            titleTemplate = title;
+        else {
+            this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${message}`);
         }
-        const toaster = AppInjector.get(ToastrService);
-        showHeader ? toaster.warning(MessageTemplate, titleTemplate) : toaster.warning(MessageTemplate);
-    }
-    startBlockUI() {
-        this.blockUI.start();
     }
-    stopBlockUI() {
-        this.blockUI.stop();
+    getControlFormNameByFieldName(form, fieldName) {
+        const formControls = form.controls;
+        let controlName = Object.keys(formControls).find(c => c.toLocaleLowerCase() === fieldName.toLocaleLowerCase());
+        let control = form.get(controlName);
+        return control;
     }
 }
-UtilityService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UtilityService_Factory() { return new UtilityService(i0.ɵɵinject(BBSFTranslateService), i0.ɵɵinject(EnvironmentService)); }, token: UtilityService, providedIn: "root" });
-UtilityService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-UtilityService.ctorParameters = () => [
-    { type: BBSFTranslateService },
-    { type: EnvironmentService }
-];
+ControlValidationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ControlValidationService, deps: [{ token: UtilityService }], target: i0.ɵɵFactoryTarget.Injectable });
+ControlValidationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ControlValidationService, providedIn: 'root' });
 __decorate([
     BlockUI()
-], UtilityService.prototype, "blockUI", void 0);
+], ControlValidationService.prototype, "blockUI", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ControlValidationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: UtilityService }]; }, propDecorators: { blockUI: [] } });
 
-class User {
-}
+// This file can be replaced during build by using the `fileReplacements` array.
+// `ng build ---prod` replaces `environment.ts` with `environment.prod.ts`.
+// The list of file replacements can be found in `angular.json`.
+const environment = Object.assign({}, window.Environment);
+/*
+ * In development mode, to ignore zone related error stack frames such as
+ * `zone.run`, `zoneDelegate.invokeTask` for easier debugging, you can
+ * import the following file, but please comment it out in production mode
+ * because it will have performance impact when throw error
+ */
+// import 'zone.js/dist/zone-error';  // Included with Angular CLI.
 
-const TOKEN_KEY = 'access_token';
-class AuthService {
-    constructor(injector, http, environmentService, translateService, router, cookieService, utilityService) {
-        this.injector = injector;
-        this.http = http;
-        this.environmentService = environmentService;
-        this.translateService = translateService;
-        this.router = router;
-        this.cookieService = cookieService;
-        this.utilityService = utilityService;
-        this.redirectUrl = '';
-        this.jwtHelper = new JwtHelperService();
-        this.isAuthenticatedSubject = new BehaviorSubject(this.hasToken());
-        this.isAuthenticate$ = this.isAuthenticatedSubject.asObservable();
-        this.user = this.getUserManager();
+class EnvironmentService {
+    getEnvironmentObject() {
+        return environment;
     }
-    hasToken() {
-        const token = this.cookieService.get(TOKEN_KEY);
-        return token && !this.jwtHelper.isTokenExpired(token);
+    getBaseUrl() {
+        return environment["BBSF_BaseURL"];
     }
-    getUserManager() {
-        const token = this.cookieService.get(TOKEN_KEY);
-        if (token)
-            this.handleAccessTokenWithoutLanguage(token);
-        return AuthService.user;
+    getApiUrl() {
+        return environment["BBSF_ApiUrl"];
     }
-    getUser() {
-        this.user = AuthService.user;
+    getProductionMode() {
+        return environment["BBSF_IsProduction"];
     }
-    storUser(User) {
-        AuthService.user = this.user = this.user;
+    getDefaultLanguage() {
+        return environment["BBSF_DefaultLanguage"];
     }
-    getCurrentUser() {
-        return AuthService.user;
+    getIdentityServerUrl() {
+        return environment["BBSF_IdentityServerUrl"];
     }
-    isAuthenticated() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return AuthService.user != null && !this.jwtHelper.isTokenExpired(AuthService.user.access_token);
-        });
+    getIsIdentityServerExternal() {
+        return environment["BBSF_IsExternalIdentityServer"];
     }
-    isUserInRole(allowedPermission) {
-        let selectedPermissionSetID = Number.parseInt(this.user.profile['selectedpermissionsetid']);
-        return allowedPermission.includes(selectedPermissionSetID);
+    getIsIdentityServerClientId() {
+        return environment["BBSF_IdentityServer_Client_Id"];
     }
-    authorizationHeaderValue() {
-        return AuthService.user
-            ? `${AuthService.user.token_type} ${AuthService.user.access_token}`
-            : '';
+    getIsIdentityServerClientSecret() {
+        return environment["BBSF_IdentityServer_Client_Secret"];
     }
-    name() {
-        return AuthService.user != null ? AuthService.user.profile.given_name : '';
+    getBBSFAuthenticationMode() {
+        let Mode = environment["BBSF_AuthenticationMode"];
+        return Mode;
     }
-    setUrl(url) {
-        localStorage.setItem('redirectUrl', url);
+    getUAEPassBaseUrl() {
+        let Mode = environment["UAEPass_BaseUrl"];
+        return Mode;
     }
-    getUrl() {
-        var _a;
-        return (_a = localStorage.getItem('redirectUrl')) !== null && _a !== void 0 ? _a : "/";
+    getUAEPassClientID() {
+        let Mode = environment["UAEPass_ClientID"];
+        return Mode;
     }
-    signout() {
-        AuthService.timers.map(t => clearInterval(t));
-        AuthService.timers = [];
-        if (!this.isAuthenticated()) {
-            this.cookieService.delete(TOKEN_KEY);
-            this.router.navigate(['/Admin/account/login']);
-        }
-        this.logout().subscribe(res => {
-            this.cookieService.delete(TOKEN_KEY);
-            this.router.navigate(['/Admin/account/login']);
-        });
+    getUAEPassRedirectUrl() {
+        let Mode = environment["UAEPass_RedirectUrl"];
+        return Mode;
     }
-    logout() {
-        const httpOptions = {
-            headers: new HttpHeaders({
-                'Content-Type': 'application/json',
-            }),
-        };
-        let ApiUrl = '/Account/';
-        return this.http.get(this.environmentService.getApiUrl() + ApiUrl + 'Logout', httpOptions);
+    getUAEPassAuthorizationEndPoint() {
+        let Mode = environment["UAEPass_AuthorizationEndPoint"];
+        return Mode;
     }
-    clearUserSessionClaims() {
-        const httpOptions = {
-            headers: new HttpHeaders({
-                'Content-Type': 'application/json',
-            }),
-        };
-        let ApiUrl = '/api/Home/';
-        return this.http.get(this.environmentService.getBaseUrl() + ApiUrl + 'ClearCurrentUserSession', httpOptions);
+    getUAEPassRedirectLogoutUrl() {
+        let Mode = environment["UAEPass_RedirectLogoutUrl"];
+        return Mode;
     }
-    handleAccessToken(response) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const token = response;
-            AuthService.user = new User();
-            AuthService.user.token_type = "Bearer";
-            AuthService.user.access_token = token;
-            AuthService.user.profile = this.jwtHelper.decodeToken(token);
-            AuthService.user.expires_at = this.jwtHelper.getTokenExpirationDate(token);
-            AuthService.timers.map(t => clearInterval(t));
-            AuthService.timers = [];
-            this.setTokenSeconds();
-            AuthService.timers.push(this.checkRefreshToken());
-            this.user = AuthService.user;
-            yield this.updateLanguage();
-            this.cookieService.set(TOKEN_KEY, token, null, null, null, true, 'Strict');
-            this.isAuthenticatedSubject.next(true);
-        });
+    getUAEPassLogoutEndPoint() {
+        let Mode = environment["UAEPass_LogoutEndPoint"];
+        return Mode;
     }
-    handleAccessTokenWithoutLanguage(response) {
-        const token = response;
-        AuthService.user = new User();
-        AuthService.user.token_type = "Bearer";
-        AuthService.user.access_token = token;
-        AuthService.user.profile = this.jwtHelper.decodeToken(token);
-        AuthService.user.expires_at = this.jwtHelper.getTokenExpirationDate(token);
-        this.setTokenSeconds();
-        this.user = AuthService.user;
-        this.cookieService.set(TOKEN_KEY, token, null, null, null, true, 'Strict');
-        this.isAuthenticatedSubject.next(true);
+    getIsEnableWindowsAuthentication() {
+        let Mode = environment["BBSF_Enable_WindowsAuthentication"];
+        return Mode.toLocaleLowerCase() == 'true';
     }
-    updateLanguage() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!localStorage.getItem('language') ||
-                localStorage.getItem('language') == this.user.profile.locale)
-                localStorage.setItem('language', this.user.profile.locale);
-            if (this.translateService.currentLang != localStorage.getItem('language')) {
-                this.translateService.resetLang(this.translateService.currentLang);
-                yield this.translateService
-                    .reloadLang(localStorage.getItem('language'))
-                    .subscribe((res) => {
-                    console.log(res);
-                });
-            }
+}
+EnvironmentService.areaList = [];
+EnvironmentService.AreaList = [];
+EnvironmentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+EnvironmentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: EnvironmentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: EnvironmentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class MasterLayoutService {
+    constructor(router, http, authService, stylesBundleService, translate, environmentService) {
+        this.router = router;
+        this.http = http;
+        this.authService = authService;
+        this.stylesBundleService = stylesBundleService;
+        this.translate = translate;
+        this.environmentService = environmentService;
+        this.apiUrl = '/api/Home/';
+    }
+    switchLang(lang, bundleEnglishName, bundleArabicName) {
+        this.changeLanguage(lang).subscribe((result) => {
+            this.updateUserInfo().subscribe((Value) => {
+                let UserInfoObject = Value;
+                this.authService.handleAccessToken(UserInfoObject.token);
+                this.stylesBundleService.loadThemes(lang, bundleEnglishName, bundleArabicName);
+                localStorage.setItem('language', lang);
+                this.translate.use(lang);
+            });
         });
     }
-    checkRefreshToken() {
-        let date = new Date();
-        return setInterval(() => {
-            if (Math.floor(AuthService.seconds) < 120 && this.isAuthenticated())
-                this.refresh();
-            AuthService.seconds--;
-        }, 1000);
+    reloadComponent() {
+        let currentUrl = this.router.url;
+        this.router.routeReuseStrategy.shouldReuseRoute = () => false;
+        this.router.onSameUrlNavigation = 'reload';
+        this.router.navigate([currentUrl]);
     }
-    setTokenSeconds() {
-        let date = new Date();
-        AuthService.seconds = (AuthService.user.expires_at - date) / 1000;
+    changeLanguage(key) {
+        let params = new HttpParams();
+        params = params.append('UserId', this.authService.user.profile.id);
+        params = params.append('LanguageKey', key);
+        return this.http.post(this.apiUrl + 'UpdateLanguage', null, null, params);
     }
-    refresh() {
-        const httpOptions = {
-            headers: new HttpHeaders({
-                'Content-Type': 'application/json',
-                'Authorization': this.authorizationHeaderValue(),
-            }),
-        };
-        let ApiUrl = '/api/Home/';
-        this.http.get(this.environmentService.getApiUrl() + ApiUrl + 'RefreshAccessToken', httpOptions).subscribe((res) => {
-            this.cookieService.delete(TOKEN_KEY);
-            this.handleAccessTokenWithoutLanguage(res.val);
+    logError(error) {
+        let params = new HttpParams();
+        params = params.append('error', error);
+        return this.http.post(this.apiUrl + 'LogError', null, null, params);
+    }
+    updateUserInfo() {
+        return this.http.get(this.apiUrl + 'UpdateUserInfo', null, null);
+    }
+    switchRole(permissionSetID) {
+        this.updateRole(permissionSetID).subscribe((result) => {
+            this.updateUserInfo().subscribe((Value) => {
+                let UserInfoObject = Value;
+                this.authService.handleAccessToken(UserInfoObject.token);
+            });
         });
     }
-}
-AuthService.user = null;
-AuthService.UserClaims = null;
-//refresh
-AuthService.timers = [];
-AuthService.seconds = 0;
-AuthService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AuthService_Factory() { return new AuthService(i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1$1.HttpClient), i0.ɵɵinject(EnvironmentService), i0.ɵɵinject(BBSFTranslateService), i0.ɵɵinject(i4.Router), i0.ɵɵinject(i5.CookieService), i0.ɵɵinject(UtilityService)); }, token: AuthService, providedIn: "root" });
-AuthService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-AuthService.ctorParameters = () => [
-    { type: Injector },
-    { type: HttpClient },
-    { type: EnvironmentService },
-    { type: BBSFTranslateService },
-    { type: Router },
-    { type: CookieService },
-    { type: UtilityService }
-];
-
-class RequestOptionsModel {
-    constructor() {
-        this.disableSuccessNotification = false;
-        this.disableBlockUI = false;
-        this.disableErrorHandler = false;
-        this.responseType = "";
-        this.formGroup = null;
-        this.castResponsetoClass = true;
+    updateRole(permissionSetID) {
+        let params = new HttpParams();
+        params = params.append('UserId', this.authService.user.profile.id);
+        params = params.append('RoleID', permissionSetID);
+        return this.http.post(this.apiUrl + 'SwitchRole', null, null, params);
     }
-}
+}
+MasterLayoutService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MasterLayoutService, deps: [{ token: i1$1.Router }, { token: RequestHandlerService }, { token: AuthService }, { token: StylesBundleService }, { token: i4.TranslateService }, { token: EnvironmentService }], target: i0.ɵɵFactoryTarget.Injectable });
+MasterLayoutService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MasterLayoutService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: MasterLayoutService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.Router }, { type: RequestHandlerService }, { type: AuthService }, { type: StylesBundleService }, { type: i4.TranslateService }, { type: EnvironmentService }]; } });
 
 class RequestHandlerService {
     constructor(http, authService, environmentService, utilityService, bbsfTranslateService, router) {
-        //using localStorage  to avoid call getCurrentLanguage() because it is not all to use async in constructor
         this.http = http;
         this.authService = authService;
         this.environmentService = environmentService;
@@ -388,6 +449,7 @@ class RequestHandlerService {
         this.requestOptions = new RequestOptionsModel();
         this.currentLanguage = "";
         this.onDestroy$ = new Subject();
+        //using localStorage  to avoid call getCurrentLanguage() because it is not all to use async in constructor
         this.bbsfTranslateService.onLangChange.subscribe((event) => {
             if (this.currentLanguage != event.lang) {
                 this.currentLanguage = event.lang;
@@ -409,7 +471,6 @@ class RequestHandlerService {
         let headers = this.getHeaders();
         if (!this.requestOptions.disableBlockUI)
             this.utilityService.startBlockUI();
-        let object;
         return this.http.get(this.environmentService.getApiUrl() + Url, { headers: headers, params: params }).pipe(takeUntil(this.onDestroy$), tap((result) => {
             if (!this.requestOptions.disableBlockUI)
                 this.utilityService.stopBlockUI();
@@ -559,17 +620,11 @@ class RequestHandlerService {
         });
     }
 }
-RequestHandlerService.decorators = [
-    { type: Injectable }
-];
-RequestHandlerService.ctorParameters = () => [
-    { type: HttpClient },
-    { type: AuthService },
-    { type: EnvironmentService },
-    { type: UtilityService },
-    { type: BBSFTranslateService },
-    { type: Router }
-];
+RequestHandlerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RequestHandlerService, deps: [{ token: i1.HttpClient }, { token: AuthService }, { token: EnvironmentService }, { token: UtilityService }, { token: BBSFTranslateService }, { token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+RequestHandlerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RequestHandlerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RequestHandlerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: AuthService }, { type: EnvironmentService }, { type: UtilityService }, { type: BBSFTranslateService }, { type: i1$1.Router }]; } });
 
 class StylesBundleService {
     constructor(document, translateService) {
@@ -610,366 +665,116 @@ class StylesBundleService {
         head.appendChild(style);
     }
 }
-StylesBundleService.ɵprov = i0.ɵɵdefineInjectable({ factory: function StylesBundleService_Factory() { return new StylesBundleService(i0.ɵɵinject(i1$2.DOCUMENT), i0.ɵɵinject(BBSFTranslateService)); }, token: StylesBundleService, providedIn: "root" });
-StylesBundleService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-StylesBundleService.ctorParameters = () => [
-    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: BBSFTranslateService }
-];
-
-class ControlValidationService {
-    constructor(utilityService) {
-        this.utilityService = utilityService;
-        this.requestOptions = new RequestOptionsModel();
-        this.isCreatedBefor = false;
-    }
-    showGlobalError(errorMessage, formId, deleteOld) {
-        let globalErorrElement = document.getElementsByClassName('alert alert-InvalidValidation bg-light-danger text-danger');
-        if (globalErorrElement.length > 0) {
-            this.removeElementsByClass('alert alert-InvalidValidation bg-light-danger text-danger');
-        }
-        if (this.isCreatedBefor == true) {
-            this.removeElementsByClass('alert alert-InvalidValidation bg-light-danger text-danger');
-        }
-        // tslint:disable-next-line: prefer-const
-        if (!formId)
-            formId = "currentForm";
-        var object = document.getElementById(formId);
-        const tagName = 'div';
-        // tslint:disable-next-line: prefer-const
-        var elementToAppend = document.createElement(tagName); // Your tag name here
-        let message = "";
-        if (!errorMessage || (typeof errorMessage == "string")) {
-            if (localStorage.getItem('language') == "ar")
-                message = errorMessage ? errorMessage : "لديك بعص الأخطاء . من فضلك قم بالمراجعه ";
-            else
-                message = errorMessage ? errorMessage : "You have some validation errors. Please check below";
-            elementToAppend.innerHTML = "<ul class='list-unstyled m-0 py-3 d-flex align-items-center fs-6'><li><i class='fa fa-times-circle text-danger me-3 fs-2'></i>" + message + "</li></ul>";
-            elementToAppend.className += 'alert alert-InvalidValidation bg-light-danger text-danger';
-            elementToAppend.id += 'errorId';
-            // tslint:disable-next-line: prefer-for-of
-            const elementToAppen = elementToAppend.cloneNode(true);
-            // let targetElement = object.getElementsByClassName("b-control")[0];
-            object.insertBefore(elementToAppen, object.firstChild);
-        }
-        else {
-            let ul = document.createElement("ul");
-            elementToAppend.appendChild(ul);
-            for (const iterator of errorMessage) {
-                let li = document.createElement("li");
-                li.innerHTML = iterator;
-                ul.appendChild(li);
-            }
-            elementToAppend.className += 'alert alert-InvalidValidation bg-light-danger text-danger';
-            elementToAppend.id += 'errorId';
-            // tslint:disable-next-line: prefer-for-of
-            const elementToAppen = elementToAppend.cloneNode(true);
-            // let targetElement = object.getElementsByClassName("b-control")[0];
-            object.insertBefore(elementToAppen, object.firstChild);
-        }
-        this.isCreatedBefor = true;
-    }
-    RemoveGlobalError() {
-        const removedList = document.getElementsByClassName('alert alert-InvalidValidation bg-light-danger text-danger');
-        // tslint:disable-next-line: prefer-for-of
-        for (let index = 0; index < removedList.length; index++) {
-            const element = removedList[index];
-            element.remove();
-        }
-        this.isCreatedBefor = false;
-    }
-    showInputErro(errors) {
-        // show error on top of form 
-        this.showGlobalError();
-        // remove old error from server
-        this.removeElementsByClass('errortemplet');
-        // Looping in error Object
-        for (const key in errors) {
-            if (errors.hasOwnProperty(key)) {
-                for (const iterator of errors[key]) {
-                    const input = document.querySelectorAll('[ng-reflect-name=' + key + ']')[0];
-                    if (input.attributes['ng-reflect-name'].value === key) {
-                        this.removeElementsByClass('erroclass-' + key);
-                        const tagName = 'p';
-                        const elementToAppend = document.createElement(tagName); // Your tag name here
-                        elementToAppend.innerHTML = iterator;
-                        elementToAppend.style.color = 'red';
-                        elementToAppend.className += 'errortemplet erroclass-' + key;
-                        const elementToappen = elementToAppend.cloneNode(true);
-                        input.parentNode.insertBefore(elementToappen, input.lastChild);
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    removeElementsByClass(className) {
-        const elements = document.getElementsByClassName(className);
-        while (elements.length > 0) {
-            elements[0].parentNode.removeChild(elements[0]);
-        }
-    }
-    renderServerErrors(form, err, requestOptions, formId) {
-        if (err.error == null) {
-            return;
-        }
-        let errorsArray = [];
-        this.requestOptions = requestOptions;
-        if (err.error.validation_errors) {
-            err.error.validation_errors.forEach((element) => {
-                let fieldName = element.field;
-                let controlName = element.controlName;
-                let message = element.message;
-                if (form == null) {
-                    this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${message}`);
-                }
-                else if (controlName && !this.hasControlName(form, controlName)) {
-                    errorsArray.push(`${fieldName}: ${message}`);
-                }
-                else {
-                    this.setFieldError(form, controlName, fieldName, message);
-                    this.showGlobalError(null, formId);
-                }
-            });
-            if (errorsArray.length > 0)
-                this.showGlobalError(errorsArray, formId);
-        }
-    }
-    hasControlName(form, controlName) {
-        let control = form.get(controlName);
-        return control != null;
-    }
-    setFieldError(form, controlName, fieldName, message) {
-        let control = null;
-        if (controlName)
-            control = this.getControlFormNameByFieldName(form, controlName);
-        else
-            control = this.getControlFormNameByFieldName(form, fieldName.split('.')[0]);
-        let errors = { "errorMassage": message };
-        let fieldNameArray = fieldName.split('.');
-        if (fieldNameArray.length >= 1) {
-            switch (fieldNameArray[fieldNameArray.length - 1].toLocaleLowerCase()) {
-                case "english":
-                    let englishControl = control.get("English");
-                    englishControl.setErrors(errors);
-                    break;
-                case "arabic":
-                    let arabicControl = control.get("Arabic");
-                    arabicControl.setErrors(errors);
-                    break;
-                default:
-                    control.setErrors(errors);
-            }
-        }
-        else {
-            this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${message}`);
-        }
-    }
-    getControlFormNameByFieldName(form, fieldName) {
-        const formControls = form.controls;
-        let controlName = Object.keys(formControls).find(c => c.toLocaleLowerCase() === fieldName.toLocaleLowerCase());
-        let control = form.get(controlName);
-        return control;
-    }
-}
-ControlValidationService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ControlValidationService_Factory() { return new ControlValidationService(i0.ɵɵinject(UtilityService)); }, token: ControlValidationService, providedIn: "root" });
-ControlValidationService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-ControlValidationService.ctorParameters = () => [
-    { type: UtilityService }
-];
-__decorate([
-    BlockUI()
-], ControlValidationService.prototype, "blockUI", void 0);
+StylesBundleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: StylesBundleService, deps: [{ token: DOCUMENT }, { token: BBSFTranslateService }], target: i0.ɵɵFactoryTarget.Injectable });
+StylesBundleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: StylesBundleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: StylesBundleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () {
+        return [{ type: Document, decorators: [{
+                        type: Inject,
+                        args: [DOCUMENT]
+                    }] }, { type: BBSFTranslateService }];
+    } });
 
-class MasterLayoutService {
-    constructor(router, http, authService, stylesBundleService, translate, environmentService) {
-        this.router = router;
-        this.http = http;
-        this.authService = authService;
-        this.stylesBundleService = stylesBundleService;
-        this.translate = translate;
-        this.environmentService = environmentService;
-        this.ApiUrl = '/api/Home/';
-    }
-    switchLang(lang, bundleEnglishName, bundleArabicName) {
-        this.changeLanguage(lang).subscribe((result) => {
-            this.updateUserInfo().subscribe((Value) => {
-                let UserInfoObject = Value;
-                this.authService.handleAccessToken(UserInfoObject.token);
-                this.stylesBundleService.loadThemes(lang, bundleEnglishName, bundleArabicName);
-                localStorage.setItem('language', lang);
-                this.translate.use(lang);
-            });
-        });
-    }
-    reloadComponent() {
-        let currentUrl = this.router.url;
-        this.router.routeReuseStrategy.shouldReuseRoute = () => false;
-        this.router.onSameUrlNavigation = 'reload';
-        this.router.navigate([currentUrl]);
-    }
-    changeLanguage(key) {
-        let params = new HttpParams();
-        params = params.append('UserId', this.authService.user.profile.id);
-        params = params.append('LanguageKey', key);
-        return this.http.post(this.ApiUrl + 'UpdateLanguage', null, null, params);
-    }
-    getUserClaims() {
-        return this.http.get(this.ApiUrl + 'GetUserClaims', null, null);
-    }
-    logError(error) {
-        let params = new HttpParams();
-        params = params.append('error', error);
-        return this.http.post(this.ApiUrl + 'LogError', null, null, params);
-    }
-    updateUserInfo() {
-        return this.http.get(this.ApiUrl + 'UpdateUserInfo', null, null);
-    }
-    switchRole(permissionSetID) {
-        this.updateRole(permissionSetID).subscribe((result) => {
-            this.updateUserInfo().subscribe((Value) => {
-                let UserInfoObject = Value;
-                this.authService.handleAccessToken(UserInfoObject.token);
-            });
-        });
-    }
-    updateRole(permissionSetID) {
-        let params = new HttpParams();
-        params = params.append('UserId', this.authService.user.profile.id);
-        params = params.append('RoleID', permissionSetID);
-        return this.http.post(this.ApiUrl + 'SwitchRole', null, null, params);
-    }
+class BBSFTranslateService extends TranslateService {
 }
-MasterLayoutService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MasterLayoutService_Factory() { return new MasterLayoutService(i0.ɵɵinject(i4.Router), i0.ɵɵinject(RequestHandlerService), i0.ɵɵinject(AuthService), i0.ɵɵinject(StylesBundleService), i0.ɵɵinject(i1.TranslateService), i0.ɵɵinject(EnvironmentService)); }, token: MasterLayoutService, providedIn: "root" });
-MasterLayoutService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
-MasterLayoutService.ctorParameters = () => [
-    { type: Router },
-    { type: RequestHandlerService },
-    { type: AuthService },
-    { type: StylesBundleService },
-    { type: TranslateService },
-    { type: EnvironmentService }
-];
+BBSFTranslateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFTranslateService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+BBSFTranslateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFTranslateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFTranslateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
 
-class ConfigurationService {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
-        this.httpClient.get("./assets/config/configurations.json").subscribe(data => {
-            ConfigurationService.JsonData = data;
-        });
-    }
-    getConfigurationValue(key) {
-        return ConfigurationService.JsonData[key];
-    }
-}
-ConfigurationService.JsonData = [];
-ConfigurationService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ConfigurationService_Factory() { return new ConfigurationService(i0.ɵɵinject(i1$1.HttpClient)); }, token: ConfigurationService, providedIn: "root" });
-ConfigurationService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-ConfigurationService.ctorParameters = () => [
-    { type: HttpClient }
-];
+const TranslationResolverService = () => {
+    let translateService = inject(BBSFTranslateService);
+    return translateService.getTranslation(translateService.currentLang);
+};
 
-let AppInjector;
-class BBSFUtilitiesModule {
-    constructor(injector) {
+class UtilityService {
+    constructor(translator, environmentService, injector) {
+        this.translator = translator;
+        this.environmentService = environmentService;
         this.injector = injector;
-        AppInjector = this.injector;
-    }
-}
-BBSFUtilitiesModule.decorators = [
-    { type: NgModule, args: [{
-                declarations: [],
-                imports: [
-                    CommonModule,
-                    BlockUIModule.forRoot(),
-                    HttpModule,
-                    RouterModule,
-                    ToastrModule.forRoot(),
-                ],
-                exports: [],
-                providers: [
-                    UtilityService,
-                    EnvironmentService,
-                    AuthService,
-                    RequestHandlerService,
-                    StylesBundleService,
-                    TranslateService,
-                    BBSFTranslateService,
-                    ControlValidationService,
-                    MasterLayoutService,
-                    ConfigurationService,
-                    CookieService
-                ]
-            },] }
-];
-BBSFUtilitiesModule.ctorParameters = () => [
-    { type: Injector }
-];
-
-class TranslationResolverService {
-    constructor(translateService) {
-        this.translateService = translateService;
+        this.isCreatedBefore = false;
     }
-    resolve() {
-        return this.translateService.getTranslation(this.translateService.currentLang);
+    getResourceValue(Key) {
+        let ResourceValue = this.translator.instant(Key);
+        return ResourceValue;
     }
-}
-TranslationResolverService.ɵprov = i0.ɵɵdefineInjectable({ factory: function TranslationResolverService_Factory() { return new TranslationResolverService(i0.ɵɵinject(BBSFTranslateService)); }, token: TranslationResolverService, providedIn: "root" });
-TranslationResolverService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-TranslationResolverService.ctorParameters = () => [
-    { type: BBSFTranslateService }
-];
-
-class AppearanceConfigurationService {
-    constructor(configService) {
-        this.configService = configService;
+    getCurrentLanguage() {
+        let currentLanguage = this.environmentService.getDefaultLanguage();
+        let lang = localStorage.getItem('language');
+        if (lang)
+            currentLanguage = lang;
+        else
+            localStorage.setItem('language', currentLanguage);
+        return currentLanguage;
     }
-    getLayoutTheme() {
-        return this.configService.getConfigurationValue('AnonymousLayout_Theme');
+    isCurrentLanguageEnglish() {
+        return this.getCurrentLanguage() == "en";
     }
-    getFooterText() {
-        return this.configService.getConfigurationValue('AnonymousLayout_FooterText');
+    isCurrentLanguageArabic() {
+        return this.getCurrentLanguage() == "ar";
     }
-    getPageTitle() {
-        return this.configService.getConfigurationValue('AnonymousLayout_PageTitle');
+    notifySuccessMessage(Message, title, time, showHeader = true) {
+        let MessageTemplate = this.getResourceValue("SuccessMessage");
+        let titleTemplate;
+        if (Message) {
+            MessageTemplate = Message;
+        }
+        if (title) {
+            titleTemplate = title;
+        }
+        let toaster = this.injector.get(ToastrService);
+        showHeader ? toaster.success(MessageTemplate, titleTemplate) : toaster.success(MessageTemplate);
     }
-    getFavIcon() {
-        return this.configService.getConfigurationValue('AnonymousLayout_FavIcon');
+    notifyErrorMessage(Message, title, time, showHeader = true) {
+        let MessageTemplate = this.getResourceValue("ErrorMessage");
+        let titleTemplate = this.getResourceValue("Error");
+        if (Message) {
+            MessageTemplate = Message;
+        }
+        if (title) {
+            titleTemplate = title;
+        }
+        const toaster = this.injector.get(ToastrService);
+        showHeader ? toaster.error(MessageTemplate, titleTemplate) : toaster.error(MessageTemplate);
     }
-    getCustomStyles() {
-        return this.configService.getConfigurationValue('AnonymousLayout_CustomStyles');
+    notifyWarningMessage(Message, title, time, showHeader = true) {
+        let MessageTemplate = this.getResourceValue("WarningMessage");
+        let titleTemplate = this.getResourceValue("Warning");
+        if (Message) {
+            MessageTemplate = Message;
+        }
+        if (title) {
+            titleTemplate = title;
+        }
+        const toaster = this.injector.get(ToastrService);
+        showHeader ? toaster.warning(MessageTemplate, titleTemplate) : toaster.warning(MessageTemplate);
     }
-    getLogo() {
-        return this.configService.getConfigurationValue('AnonymousLayout_Logo');
+    startBlockUI() {
+        this.blockUI.start();
+    }
+    stopBlockUI() {
+        this.blockUI.stop();
     }
 }
-AppearanceConfigurationService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AppearanceConfigurationService_Factory() { return new AppearanceConfigurationService(i0.ɵɵinject(ConfigurationService)); }, token: AppearanceConfigurationService, providedIn: "root" });
-AppearanceConfigurationService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root'
-            },] }
-];
-AppearanceConfigurationService.ctorParameters = () => [
-    { type: ConfigurationService }
-];
+UtilityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: UtilityService, deps: [{ token: BBSFTranslateService }, { token: EnvironmentService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+UtilityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: UtilityService, providedIn: 'root' });
+__decorate([
+    BlockUI()
+], UtilityService.prototype, "blockUI", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: UtilityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: BBSFTranslateService }, { type: EnvironmentService }, { type: i0.Injector }]; }, propDecorators: { blockUI: [] } });
 
 const contentTypesXML = `
     <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
@@ -1157,8 +962,7 @@ const generateCoreXML = (title = '', subject = '', creator = applicationName, ke
             <dcterms:created xsi:type="dcterms:W3CDTF">${createdAt instanceof Date ? createdAt.toISOString() : new Date().toISOString()}</dcterms:created>
             <dcterms:modified xsi:type="dcterms:W3CDTF">${modifiedAt instanceof Date ? modifiedAt.toISOString() : new Date().toISOString()}</dcterms:modified>
         </cp:coreProperties>
-    `;
-const ɵ0$8 = generateCoreXML;
+    `;
 
 const documentRelsXML = `
   <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
@@ -1196,8 +1000,7 @@ const generateNumberingXMLTemplate = () => `
         xmlns:w10="${namespaces.w10}"
         xmlns:wne="${namespaces.wne}">
         </w:numbering>
-    `;
-const ɵ0$7 = generateNumberingXMLTemplate;
+    `;
 
 const generateStylesXML = (font = defaultFont, fontSize = defaultFontSize, complexScriptFontSize = defaultFontSize) => `
   <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
@@ -1341,8 +1144,7 @@ const generateStylesXML = (font = defaultFont, fontSize = defaultFontSize, compl
 	  </w:rPr>
 	</w:style>
   </w:styles>
-  `;
-const ɵ0$6 = generateStylesXML;
+  `;
 
 const fontTableXML = `
     <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
@@ -1576,8 +1378,7 @@ const generateThemeXML = (font = defaultFont) => `
       </a:fmtScheme>
     </a:themeElements>
   </a:theme>
-`;
-const ɵ0$5 = generateThemeXML;
+`;
 
 const settingsXML = `
     <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
@@ -1639,7 +1440,6 @@ const generateDocumentTemplate = (width, height, orientation, margins) => `
         </w:body>
     </w:document>
   `;
-const ɵ0$4 = generateDocumentTemplate;
 const generateDocumentTemplateHeader = `
 <w:hdr
 xmlns:a="${namespaces.a}"
@@ -1809,8 +1609,7 @@ const vNodeHasChildren = (vNode) => vNode && vNode.children && Array.isArray(vNo
 const isValidUrl = (urlString) => {
     const urlRegex = /http(s)?:\/\/(\w+:?\w*@)?(\S+)(:\d+)?((?<=\.)\w+)+(\/([\w#!:.?+=&%@!\-/])*)?/gi;
     return Boolean(urlRegex.test(urlString));
-};
-const ɵ0$3 = isValidUrl;
+};
 
 // eslint-disable-next-line consistent-return
 const fixupColorCode = (colorCodeString) => {
@@ -1847,24 +1646,20 @@ const fixupColorCode = (colorCodeString) => {
         return '000000';
     }
 };
-const ɵ0$2 = fixupColorCode;
 const buildRunFontFragment = (fontName = defaultFont) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'rFonts')
     .att('@w', 'ascii', fontName)
     .att('@w', 'hAnsi', fontName)
     .up();
-const ɵ1$1 = buildRunFontFragment;
 const buildRunStyleFragment = (type = 'Hyperlink') => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'rStyle')
     .att('@w', 'val', type)
     .up();
-const ɵ2$1 = buildRunStyleFragment;
 const buildTableRowHeight = (tableRowHeight) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'trHeight')
     .att('@w', 'val', tableRowHeight)
     .att('@w', 'hRule', 'atLeast')
     .up();
-const ɵ3$1 = buildTableRowHeight;
 const buildVerticalAlignment = (verticalAlignment) => {
     if (verticalAlignment.toLowerCase() === 'middle') {
         verticalAlignment = 'center';
@@ -1874,61 +1669,49 @@ const buildVerticalAlignment = (verticalAlignment) => {
         .att('@w', 'val', verticalAlignment)
         .up();
 };
-const ɵ4 = buildVerticalAlignment;
 const buildVerticalMerge = (verticalMerge = 'continue') => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'vMerge')
     .att('@w', 'val', verticalMerge)
     .up();
-const ɵ5 = buildVerticalMerge;
 const buildColor = (colorCode) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'color')
     .att('@w', 'val', colorCode)
     .up();
-const ɵ6 = buildColor;
 const buildFontSize = (fontSize) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'sz')
     .att('@w', 'val', fontSize)
     .up();
-const ɵ7 = buildFontSize;
 const buildShading = (colorCode) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'shd')
     .att('@w', 'val', 'clear')
     .att('@w', 'fill', colorCode)
     .up();
-const ɵ8 = buildShading;
 const buildHighlight = (color = 'yellow') => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'highlight')
     .att('@w', 'val', color)
     .up();
-const ɵ9 = buildHighlight;
 const buildVertAlign = (type = 'baseline') => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'vertAlign')
     .att('@w', 'val', type)
     .up();
-const ɵ10 = buildVertAlign;
 const buildStrike = () => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'strike')
     .att('@w', 'val', true)
     .up();
-const ɵ11 = buildStrike;
 const buildBold = () => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'b')
     .up();
-const ɵ12 = buildBold;
 const buildItalics = () => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'i')
     .up();
-const ɵ13 = buildItalics;
 const buildUnderline = (type = 'single') => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'u')
     .att('@w', 'val', type)
     .up();
-const ɵ14 = buildUnderline;
 const buildLineBreak = (type = 'textWrapping') => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'br')
     .att('@w', 'type', type)
     .up();
-const ɵ15 = buildLineBreak;
 const buildBorder = (borderSide = 'top', borderSize = 0, borderSpacing = 0, borderColor = fixupColorCode('black'), borderStroke = 'single') => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', borderSide)
     .att('@w', 'val', borderStroke)
@@ -1936,13 +1719,11 @@ const buildBorder = (borderSide = 'top', borderSize = 0, borderSpacing = 0, bord
     .att('@w', 'space', borderSpacing)
     .att('@w', 'color', borderColor)
     .up();
-const ɵ16 = buildBorder;
 const buildTextElement = (text) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 't')
     .att('@xml', 'space', 'preserve')
     .txt(text)
     .up();
-const ɵ17 = buildTextElement;
 // eslint-disable-next-line consistent-return
 const fixupLineHeight = (lineHeight, fontSize) => {
     // FIXME: If line height is anything other than a number
@@ -1962,7 +1743,6 @@ const fixupLineHeight = (lineHeight, fontSize) => {
         return 240;
     }
 };
-const ɵ18 = fixupLineHeight;
 // eslint-disable-next-line consistent-return
 const fixupFontSize$1 = (fontSizeString) => {
     if (pointRegex.test(fontSizeString)) {
@@ -1976,7 +1756,6 @@ const fixupFontSize$1 = (fontSizeString) => {
         return pixelToHIP(matchedParts[1]);
     }
 };
-const ɵ19 = fixupFontSize$1;
 // eslint-disable-next-line consistent-return
 const fixupRowHeight = (rowHeightString) => {
     if (pointRegex.test(rowHeightString)) {
@@ -1998,7 +1777,6 @@ const fixupRowHeight = (rowHeightString) => {
         return inchToTWIP(matchedParts[1]);
     }
 };
-const ɵ20 = fixupRowHeight;
 // eslint-disable-next-line consistent-return
 const fixupColumnWidth = (columnWidthString) => {
     if (pointRegex.test(columnWidthString)) {
@@ -2018,7 +1796,6 @@ const fixupColumnWidth = (columnWidthString) => {
         return inchToTWIP(matchedParts[1]);
     }
 };
-const ɵ21 = fixupColumnWidth;
 // eslint-disable-next-line consistent-return
 const fixupMargin = (marginString) => {
     if (pointRegex.test(marginString)) {
@@ -2032,7 +1809,6 @@ const fixupMargin = (marginString) => {
         return pixelToTWIP(matchedParts[1]);
     }
 };
-const ɵ22 = fixupMargin;
 const modifiedStyleAttributesBuilder = (vNode, attributes, options) => {
     const modifiedAttributes = Object.assign({}, attributes);
     // styles
@@ -2100,7 +1876,6 @@ const modifiedStyleAttributesBuilder = (vNode, attributes, options) => {
     }
     return modifiedAttributes;
 };
-const ɵ23 = modifiedStyleAttributesBuilder;
 // html tag to formatting function
 // options are passed to the formatting function if needed
 const buildFormatting = (htmlTag, options) => {
@@ -2143,7 +1918,6 @@ const buildFormatting = (htmlTag, options) => {
     }
     return null;
 };
-const ɵ24 = buildFormatting;
 const buildRunProperties = (attributes) => {
     const runPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'rPr');
     if (attributes && attributes.constructor === Object) {
@@ -2164,7 +1938,6 @@ const buildRunProperties = (attributes) => {
     runPropertiesFragment.up();
     return runPropertiesFragment;
 };
-const ɵ25 = buildRunProperties;
 const buildRun = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
     const runFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'r');
     const runPropertiesFragment = buildRunProperties(cloneDeep(attributes));
@@ -2314,7 +2087,6 @@ const buildRun = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0,
     runFragment.up();
     return runFragment;
 });
-const ɵ26 = buildRun;
 const buildRunOrRuns = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
     if (isVNode(vNode) && vNode.tagName === 'span') {
         let runFragments = [];
@@ -2331,7 +2103,6 @@ const buildRunOrRuns = (vNode, attributes, docxDocumentInstance) => __awaiter(vo
         return tempRunFragments;
     }
 });
-const ɵ27 = buildRunOrRuns;
 const buildRunOrHyperLink = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
     if (isVNode(vNode) && vNode.tagName === 'a') {
         const relationshipId = docxDocumentInstance.createDocumentRelationships(docxDocumentInstance.relationshipFilename, hyperlinkType, vNode.properties && vNode.properties.href ? vNode.properties.href : '');
@@ -2356,7 +2127,6 @@ const buildRunOrHyperLink = (vNode, attributes, docxDocumentInstance) => __await
     const runFragments = yield buildRunOrRuns(vNode, attributes, docxDocumentInstance);
     return runFragments;
 });
-const ɵ28 = buildRunOrHyperLink;
 const buildNumberingProperties = (levelId, numberingId) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'numPr')
     .ele('@w', 'ilvl')
@@ -2366,13 +2136,11 @@ const buildNumberingProperties = (levelId, numberingId) => fragment({ namespaceA
     .att('@w', 'val', String(numberingId))
     .up()
     .up();
-const ɵ29 = buildNumberingProperties;
 const buildNumberingInstances = () => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'num')
     .ele('@w', 'abstractNumId')
     .up()
     .up();
-const ɵ30 = buildNumberingInstances;
 const buildSpacing = (lineSpacing, beforeSpacing, afterSpacing) => {
     const spacingFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'spacing');
     if (lineSpacing) {
@@ -2387,7 +2155,6 @@ const buildSpacing = (lineSpacing, beforeSpacing, afterSpacing) => {
     spacingFragment.att('@w', 'lineRule', 'auto').up();
     return spacingFragment;
 };
-const ɵ31 = buildSpacing;
 const buildIndentation = ({ left, right }) => {
     const indentationFragment = fragment({
         namespaceAlias: { w: namespaces.w },
@@ -2401,12 +2168,10 @@ const buildIndentation = ({ left, right }) => {
     indentationFragment.up();
     return indentationFragment;
 };
-const ɵ32 = buildIndentation;
 const buildPStyle = (style = 'Normal') => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'pStyle')
     .att('@w', 'val', style)
     .up();
-const ɵ33 = buildPStyle;
 const buildHorizontalAlignment = (horizontalAlignment) => {
     if (horizontalAlignment === 'justify') {
         horizontalAlignment = 'both';
@@ -2416,7 +2181,6 @@ const buildHorizontalAlignment = (horizontalAlignment) => {
         .att('@w', 'val', horizontalAlignment)
         .up();
 };
-const ɵ34 = buildHorizontalAlignment;
 const buildParagraphBorder = () => {
     const paragraphBorderFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'pBdr');
     const bordersObject = cloneDeep(paragraphBordersObject);
@@ -2430,7 +2194,6 @@ const buildParagraphBorder = () => {
     paragraphBorderFragment.up();
     return paragraphBorderFragment;
 };
-const ɵ35 = buildParagraphBorder;
 const buildParagraphProperties = (attributes) => {
     const paragraphPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'pPr');
     if (attributes && attributes.constructor === Object) {
@@ -2487,7 +2250,6 @@ const buildParagraphProperties = (attributes) => {
     paragraphPropertiesFragment.up();
     return paragraphPropertiesFragment;
 };
-const ɵ36 = buildParagraphProperties;
 const computeImageDimensions = (vNode, attributes) => {
     const { maximumWidth, originalWidth, originalHeight } = attributes;
     const aspectRatio = originalWidth / originalHeight;
@@ -2561,7 +2323,6 @@ const computeImageDimensions = (vNode, attributes) => {
     // eslint-disable-next-line no-param-reassign
     attributes.height = modifiedHeight;
 };
-const ɵ37 = computeImageDimensions;
 const buildParagraph = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
     const paragraphFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'p');
     const modifiedAttributes = modifiedStyleAttributesBuilder(vNode, attributes, {
@@ -2699,18 +2460,15 @@ const buildParagraph = (vNode, attributes, docxDocumentInstance) => __awaiter(vo
     paragraphFragment.up();
     return paragraphFragment;
 });
-const ɵ38 = buildParagraph;
 const buildGridSpanFragment = (spanValue) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'gridSpan')
     .att('@w', 'val', spanValue)
     .up();
-const ɵ39 = buildGridSpanFragment;
 const buildTableCellSpacing = (cellSpacing = 0) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'tblCellSpacing')
     .att('@w', 'w', cellSpacing)
     .att('@w', 'type', 'dxa')
     .up();
-const ɵ40 = buildTableCellSpacing;
 const buildTableCellBorders = (tableCellBorder) => {
     const tableCellBordersFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tcBorders');
     const { color, stroke } = tableCellBorder, borders = __rest(tableCellBorder, ["color", "stroke"]);
@@ -2723,13 +2481,11 @@ const buildTableCellBorders = (tableCellBorder) => {
     tableCellBordersFragment.up();
     return tableCellBordersFragment;
 };
-const ɵ41 = buildTableCellBorders;
 const buildTableCellWidth = (tableCellWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'tcW')
     .att('@w', 'w', fixupColumnWidth(tableCellWidth))
     .att('@w', 'type', 'dxa')
     .up();
-const ɵ42 = buildTableCellWidth;
 const buildTableCellProperties = (attributes) => {
     const tableCellPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tcPr');
     if (attributes && attributes.constructor === Object) {
@@ -2775,7 +2531,6 @@ const buildTableCellProperties = (attributes) => {
     tableCellPropertiesFragment.up();
     return tableCellPropertiesFragment;
 };
-const ɵ43 = buildTableCellProperties;
 const fixupTableCellBorder = (vNode, attributes) => {
     if (Object.prototype.hasOwnProperty.call(vNode.properties.style, 'border')) {
         if (vNode.properties.style.border === 'none' || vNode.properties.style.border === 0) {
@@ -2830,7 +2585,6 @@ const fixupTableCellBorder = (vNode, attributes) => {
         attributes.tableCellBorder = Object.assign(Object.assign({}, attributes.tableCellBorder), { right: borderSize, color: borderColor, stroke: borderStroke });
     }
 };
-const ɵ44 = fixupTableCellBorder;
 const buildTableCell = (vNode, attributes, rowSpanMap, columnIndex, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
     const tableCellFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tc');
     let modifiedAttributes = Object.assign({}, attributes);
@@ -2913,7 +2667,6 @@ const buildTableCell = (vNode, attributes, rowSpanMap, columnIndex, docxDocument
     tableCellFragment.up();
     return tableCellFragment;
 });
-const ɵ45 = buildTableCell;
 const buildRowSpanCell = (rowSpanMap, columnIndex, attributes) => {
     const rowSpanCellFragments = [];
     let spanObject = rowSpanMap.get(columnIndex.index);
@@ -2941,7 +2694,6 @@ const buildRowSpanCell = (rowSpanMap, columnIndex, attributes) => {
     }
     return rowSpanCellFragments;
 };
-const ɵ46 = buildRowSpanCell;
 const buildTableRowProperties = (attributes) => {
     const tableRowPropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'trPr');
     if (attributes && attributes.constructor === Object) {
@@ -2969,7 +2721,6 @@ const buildTableRowProperties = (attributes) => {
     tableRowPropertiesFragment.up();
     return tableRowPropertiesFragment;
 };
-const ɵ47 = buildTableRowProperties;
 const buildTableRow = (vNode, attributes, rowSpanMap, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
     const tableRowFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tr');
     const modifiedAttributes = Object.assign({}, attributes);
@@ -3024,11 +2775,9 @@ const buildTableRow = (vNode, attributes, rowSpanMap, docxDocumentInstance) => _
     tableRowFragment.up();
     return tableRowFragment;
 });
-const ɵ48 = buildTableRow;
 const buildTableGridCol = (gridWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'gridCol')
     .att('@w', 'w', String(gridWidth));
-const ɵ49 = buildTableGridCol;
 const buildTableGrid = (vNode, attributes) => {
     const tableGridFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblGrid');
     if (vNodeHasChildren(vNode)) {
@@ -3042,7 +2791,6 @@ const buildTableGrid = (vNode, attributes) => {
     tableGridFragment.up();
     return tableGridFragment;
 };
-const ɵ50 = buildTableGrid;
 const buildTableGridFromTableRow = (vNode, attributes) => {
     const tableGridFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblGrid');
     if (vNodeHasChildren(vNode)) {
@@ -3060,7 +2808,6 @@ const buildTableGridFromTableRow = (vNode, attributes) => {
     tableGridFragment.up();
     return tableGridFragment;
 };
-const ɵ51 = buildTableGridFromTableRow;
 const buildTableBorders = (tableBorder) => {
     const tableBordersFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblBorders');
     const { color, stroke } = tableBorder, borders = __rest(tableBorder, ["color", "stroke"]);
@@ -3073,19 +2820,16 @@ const buildTableBorders = (tableBorder) => {
     tableBordersFragment.up();
     return tableBordersFragment;
 };
-const ɵ52 = buildTableBorders;
 const buildTableWidth = (tableWidth) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', 'tblW')
     .att('@w', 'type', 'dxa')
     .att('@w', 'w', String(tableWidth))
     .up();
-const ɵ53 = buildTableWidth;
 const buildCellMargin = (side, margin) => fragment({ namespaceAlias: { w: namespaces.w } })
     .ele('@w', side)
     .att('@w', 'type', 'dxa')
     .att('@w', 'w', String(margin))
     .up();
-const ɵ54 = buildCellMargin;
 const buildTableCellMargins = (margin) => {
     const tableCellMarFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblCellMar');
     ['top', 'bottom'].forEach((side) => {
@@ -3098,7 +2842,6 @@ const buildTableCellMargins = (margin) => {
     });
     return tableCellMarFragment;
 };
-const ɵ55 = buildTableCellMargins;
 const buildTableProperties = (attributes) => {
     const tablePropertiesFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tblPr');
     if (attributes && attributes.constructor === Object) {
@@ -3135,7 +2878,6 @@ const buildTableProperties = (attributes) => {
     tablePropertiesFragment.up();
     return tablePropertiesFragment;
 };
-const ɵ56 = buildTableProperties;
 const cssBorderParser = (borderString) => {
     let [size, stroke, color] = borderString.split(' ');
     if (pointRegex.test(size)) {
@@ -3152,7 +2894,6 @@ const cssBorderParser = (borderString) => {
     color = color && fixupColorCode(color).toUpperCase();
     return [size, stroke, color];
 };
-const ɵ57 = cssBorderParser;
 const buildTable = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0, void 0, void 0, function* () {
     const tableFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'tbl');
     const modifiedAttributes = Object.assign({}, attributes);
@@ -3293,24 +3034,20 @@ const buildTable = (vNode, attributes, docxDocumentInstance) => __awaiter(void 0
     tableFragment.up();
     return tableFragment;
 });
-const ɵ58 = buildTable;
 const buildPresetGeometry = () => fragment({ namespaceAlias: { a: namespaces.a } })
     .ele('@a', 'prstGeom')
     .att('prst', 'rect')
     .up();
-const ɵ59 = buildPresetGeometry;
 const buildExtents = ({ width, height }) => fragment({ namespaceAlias: { a: namespaces.a } })
     .ele('@a', 'ext')
     .att('cx', width)
     .att('cy', height)
     .up();
-const ɵ60 = buildExtents;
 const buildOffset = () => fragment({ namespaceAlias: { a: namespaces.a } })
     .ele('@a', 'off')
     .att('x', '0')
     .att('y', '0')
     .up();
-const ɵ61 = buildOffset;
 const buildGraphicFrameTransform = (attributes) => {
     const graphicFrameTransformFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'xfrm');
     const offsetFragment = buildOffset();
@@ -3320,7 +3057,6 @@ const buildGraphicFrameTransform = (attributes) => {
     graphicFrameTransformFragment.up();
     return graphicFrameTransformFragment;
 };
-const ɵ62 = buildGraphicFrameTransform;
 const buildShapeProperties = (attributes) => {
     const shapeProperties = fragment({ namespaceAlias: { pic: namespaces.pic } }).ele('@pic', 'spPr');
     const graphicFrameTransformFragment = buildGraphicFrameTransform(attributes);
@@ -3330,11 +3066,9 @@ const buildShapeProperties = (attributes) => {
     shapeProperties.up();
     return shapeProperties;
 };
-const ɵ63 = buildShapeProperties;
 const buildFillRect = () => fragment({ namespaceAlias: { a: namespaces.a } })
     .ele('@a', 'fillRect')
     .up();
-const ɵ64 = buildFillRect;
 const buildStretch = () => {
     const stretchFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'stretch');
     const fillRectFragment = buildFillRect();
@@ -3342,7 +3076,6 @@ const buildStretch = () => {
     stretchFragment.up();
     return stretchFragment;
 };
-const ɵ65 = buildStretch;
 const buildSrcRectFragment = () => fragment({ namespaceAlias: { a: namespaces.a } })
     .ele('@a', 'srcRect')
     .att('b', '0')
@@ -3350,7 +3083,6 @@ const buildSrcRectFragment = () => fragment({ namespaceAlias: { a: namespaces.a
     .att('r', '0')
     .att('t', '0')
     .up();
-const ɵ66 = buildSrcRectFragment;
 const buildBinaryLargeImageOrPicture = (relationshipId) => fragment({
     namespaceAlias: { a: namespaces.a, r: namespaces.r },
 })
@@ -3359,7 +3091,6 @@ const buildBinaryLargeImageOrPicture = (relationshipId) => fragment({
     // FIXME: possible values 'email', 'none', 'print', 'hqprint', 'screen'
     .att('cstate', 'print')
     .up();
-const ɵ67 = buildBinaryLargeImageOrPicture;
 const buildBinaryLargeImageOrPictureFill = (relationshipId) => {
     const binaryLargeImageOrPictureFillFragment = fragment({
         namespaceAlias: { pic: namespaces.pic },
@@ -3373,18 +3104,15 @@ const buildBinaryLargeImageOrPictureFill = (relationshipId) => {
     binaryLargeImageOrPictureFillFragment.up();
     return binaryLargeImageOrPictureFillFragment;
 };
-const ɵ68 = buildBinaryLargeImageOrPictureFill;
 const buildNonVisualPictureDrawingProperties = () => fragment({ namespaceAlias: { pic: namespaces.pic } })
     .ele('@pic', 'cNvPicPr')
     .up();
-const ɵ69 = buildNonVisualPictureDrawingProperties;
 const buildNonVisualDrawingProperties = (pictureId, pictureNameWithExtension, pictureDescription = '') => fragment({ namespaceAlias: { pic: namespaces.pic } })
     .ele('@pic', 'cNvPr')
     .att('id', pictureId)
     .att('name', pictureNameWithExtension)
     .att('descr', pictureDescription)
     .up();
-const ɵ70 = buildNonVisualDrawingProperties;
 const buildNonVisualPictureProperties = (pictureId, pictureNameWithExtension, pictureDescription) => {
     const nonVisualPicturePropertiesFragment = fragment({
         namespaceAlias: { pic: namespaces.pic },
@@ -3397,7 +3125,6 @@ const buildNonVisualPictureProperties = (pictureId, pictureNameWithExtension, pi
     nonVisualPicturePropertiesFragment.up();
     return nonVisualPicturePropertiesFragment;
 };
-const ɵ71 = buildNonVisualPictureProperties;
 const buildPicture = ({ id, fileNameWithExtension, description, relationshipId, width, height, }) => {
     const pictureFragment = fragment({ namespaceAlias: { pic: namespaces.pic } }).ele('@pic', 'pic');
     const nonVisualPicturePropertiesFragment = buildNonVisualPictureProperties(id, fileNameWithExtension, description);
@@ -3409,7 +3136,6 @@ const buildPicture = ({ id, fileNameWithExtension, description, relationshipId,
     pictureFragment.up();
     return pictureFragment;
 };
-const ɵ72 = buildPicture;
 const buildGraphicData = (graphicType, attributes) => {
     const graphicDataFragment = fragment({ namespaceAlias: { a: namespaces.a } })
         .ele('@a', 'graphicData')
@@ -3421,7 +3147,6 @@ const buildGraphicData = (graphicType, attributes) => {
     graphicDataFragment.up();
     return graphicDataFragment;
 };
-const ɵ73 = buildGraphicData;
 const buildGraphic = (graphicType, attributes) => {
     const graphicFragment = fragment({ namespaceAlias: { a: namespaces.a } }).ele('@a', 'graphic');
     // TODO: Handle drawing type
@@ -3430,13 +3155,11 @@ const buildGraphic = (graphicType, attributes) => {
     graphicFragment.up();
     return graphicFragment;
 };
-const ɵ74 = buildGraphic;
 const buildDrawingObjectNonVisualProperties = (pictureId, pictureName) => fragment({ namespaceAlias: { wp: namespaces.wp } })
     .ele('@wp', 'docPr')
     .att('id', pictureId)
     .att('name', pictureName)
     .up();
-const ɵ75 = buildDrawingObjectNonVisualProperties;
 const buildWrapSquare = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
     .ele('@wp', 'wrapSquare')
     .att('wrapText', 'bothSides')
@@ -3445,12 +3168,10 @@ const buildWrapSquare = () => fragment({ namespaceAlias: { wp: namespaces.wp } }
     .att('distL', '228600')
     .att('distR', '228600')
     .up();
-const ɵ76 = buildWrapSquare;
 // eslint-disable-next-line no-unused-vars
 const buildWrapNone = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
     .ele('@wp', 'wrapNone')
     .up();
-const ɵ77 = buildWrapNone;
 const buildEffectExtentFragment = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
     .ele('@wp', 'effectExtent')
     .att('b', '0')
@@ -3458,13 +3179,11 @@ const buildEffectExtentFragment = () => fragment({ namespaceAlias: { wp: namespa
     .att('r', '0')
     .att('t', '0')
     .up();
-const ɵ78 = buildEffectExtentFragment;
 const buildExtent = ({ width, height }) => fragment({ namespaceAlias: { wp: namespaces.wp } })
     .ele('@wp', 'extent')
     .att('cx', width)
     .att('cy', height)
     .up();
-const ɵ79 = buildExtent;
 const buildPositionV = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
     .ele('@wp', 'positionV')
     .att('relativeFrom', 'paragraph')
@@ -3472,7 +3191,6 @@ const buildPositionV = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
     .txt('19050')
     .up()
     .up();
-const ɵ80 = buildPositionV;
 const buildPositionH = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
     .ele('@wp', 'positionH')
     .att('relativeFrom', 'column')
@@ -3480,13 +3198,11 @@ const buildPositionH = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
     .txt('19050')
     .up()
     .up();
-const ɵ81 = buildPositionH;
 const buildSimplePos = () => fragment({ namespaceAlias: { wp: namespaces.wp } })
     .ele('@wp', 'simplePos')
     .att('x', '0')
     .att('y', '0')
     .up();
-const ɵ82 = buildSimplePos;
 const buildAnchoredDrawing = (graphicType, attributes) => {
     const anchoredDrawingFragment = fragment({ namespaceAlias: { wp: namespaces.wp } })
         .ele('@wp', 'anchor')
@@ -3520,7 +3236,6 @@ const buildAnchoredDrawing = (graphicType, attributes) => {
     anchoredDrawingFragment.up();
     return anchoredDrawingFragment;
 };
-const ɵ83 = buildAnchoredDrawing;
 const buildInlineDrawing = (graphicType, attributes) => {
     const inlineDrawingFragment = fragment({ namespaceAlias: { wp: namespaces.wp } })
         .ele('@wp', 'inline')
@@ -3539,7 +3254,6 @@ const buildInlineDrawing = (graphicType, attributes) => {
     inlineDrawingFragment.up();
     return inlineDrawingFragment;
 };
-const ɵ84 = buildInlineDrawing;
 const buildDrawing = (inlineOrAnchored = false, graphicType, attributes) => {
     const drawingFragment = fragment({ namespaceAlias: { w: namespaces.w } }).ele('@w', 'drawing');
     const inlineOrAnchoredDrawingFragment = inlineOrAnchored
@@ -3549,12 +3263,6 @@ const buildDrawing = (inlineOrAnchored = false, graphicType, attributes) => {
     drawingFragment.up();
     return drawingFragment;
 };
-const ɵ85 = buildDrawing;
-
-const convertHTML$1 = HTMLToVDOM({
-    VNode,
-    VText,
-});
 // eslint-disable-next-line consistent-return, no-shadow
 const buildImage = (docxDocumentInstance, vNode, maximumWidth = null) => __awaiter(void 0, void 0, void 0, function* () {
     let response = null;
@@ -3590,7 +3298,7 @@ const buildImage = (docxDocumentInstance, vNode, maximumWidth = null) => __await
         const documentRelsId = docxDocumentInstance.createDocumentRelationships(docxDocumentInstance.relationshipFilename, imageType, `media/${response.fileNameWithExtension}`, internalRelationship);
         const imageBuffer = Buffer.from(response.fileContent, 'base64');
         const imageProperties = sizeOf(imageBuffer);
-        const imageFragment = yield buildParagraph(vNode, Object.assign(Object.assign({ type: 'picture', inlineOrAnchored: true, relationshipId: documentRelsId }, response), { maximumWidth: maximumWidth || docxDocumentInstance.availableDocumentSpace, originalWidth: imageProperties.width, originalHeight: imageProperties.height }), docxDocumentInstance);
+        const imageFragment = yield xmlBuilder.buildParagraph(vNode, Object.assign(Object.assign({ type: 'picture', inlineOrAnchored: true, relationshipId: documentRelsId }, response), { maximumWidth: maximumWidth || docxDocumentInstance.availableDocumentSpace, originalWidth: imageProperties.width, originalHeight: imageProperties.height }), docxDocumentInstance);
         return imageFragment;
     }
 });
@@ -3608,7 +3316,7 @@ const buildList = (vNode, docxDocumentInstance, xmlFragment) => __awaiter(void 0
         const tempVNodeObject = vNodeObjects.shift();
         if (isVText(tempVNodeObject.node) ||
             (isVNode(tempVNodeObject.node) && !['ul', 'ol', 'li'].includes(tempVNodeObject.node.tagName))) {
-            const paragraphFragment = yield buildParagraph(tempVNodeObject.node, {
+            const paragraphFragment = yield xmlBuilder.buildParagraph(tempVNodeObject.node, {
                 numbering: { levelId: tempVNodeObject.level, numberingId: tempVNodeObject.numberingId },
             }, docxDocumentInstance);
             xmlFragment.import(paragraphFragment);
@@ -3666,6 +3374,11 @@ const buildList = (vNode, docxDocumentInstance, xmlFragment) => __awaiter(void 0
         }
     }
     return listElements;
+});
+
+const convertHTML$1 = HTMLToVDOM({
+    VNode: VNode$1,
+    VText,
 });
 function findXMLEquivalent(docxDocumentInstance, vNode, xmlFragment) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -4314,11 +4027,10 @@ function _prepareImageParts(htmlSource) {
 }
 
 const convertHTML = HTMLToVDOM({
-    VNode,
+    VNode: VNode$1,
     VText,
 });
 const mergeOptions = (options, patch) => (Object.assign(Object.assign({}, options), patch));
-const ɵ0$1 = mergeOptions;
 const fixupFontSize = (fontSize) => {
     let normalizedFontSize;
     if (pointRegex.test(fontSize)) {
@@ -4334,7 +4046,6 @@ const fixupFontSize = (fontSize) => {
     }
     return normalizedFontSize;
 };
-const ɵ1 = fixupFontSize;
 const normalizeUnits = (dimensioningObject, defaultDimensionsProperty) => {
     let normalizedUnitResult = {};
     if (typeof dimensioningObject === 'object' && dimensioningObject !== null) {
@@ -4366,7 +4077,6 @@ const normalizeUnits = (dimensioningObject, defaultDimensionsProperty) => {
     }
     return normalizedUnitResult;
 };
-const ɵ2 = normalizeUnits;
 const normalizeDocumentOptions = (documentOptions) => {
     const normalizedDocumentOptions = Object.assign({}, documentOptions);
     Object.keys(documentOptions).forEach((key) => {
@@ -4384,7 +4094,6 @@ const normalizeDocumentOptions = (documentOptions) => {
     });
     return normalizedDocumentOptions;
 };
-const ɵ3 = normalizeDocumentOptions;
 // Ref: https://en.wikipedia.org/wiki/Office_Open_XML_file_formats
 // http://officeopenxml.com/anatomyofOOXML.php
 function addFilesToContainer(zip, htmlString, suppliedDocumentOptions, headerHTMLString, footerHTMLString) {
@@ -4511,7 +4220,6 @@ const minifyHTMLString = (htmlString) => {
         return null;
     }
 };
-const ɵ0 = minifyHTMLString;
 function generateContainer(htmlString, headerHTMLString, documentOptions = {}, footerHTMLString) {
     return __awaiter(this, void 0, void 0, function* () {
         const zip = new JSZip();
@@ -4570,28 +4278,278 @@ class WordDocumentService {
         });
     }
 }
-WordDocumentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function WordDocumentService_Factory() { return new WordDocumentService(); }, token: WordDocumentService, providedIn: "root" });
-WordDocumentService.decorators = [
-    { type: Injectable, args: [{
-                providedIn: 'root',
-            },] }
-];
+WordDocumentService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WordDocumentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+WordDocumentService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WordDocumentService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: WordDocumentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
 
-class WordDocumentModel {
-    constructor() {
-        this.options = new DocumentOptionsModel();
+const TOKEN_KEY = 'access_token';
+class AuthService {
+    constructor(injector, http, environmentService, translateService, router, cookieService, utilityService) {
+        this.injector = injector;
+        this.http = http;
+        this.environmentService = environmentService;
+        this.translateService = translateService;
+        this.router = router;
+        this.cookieService = cookieService;
+        this.utilityService = utilityService;
+        this.redirectUrl = '';
+        this.jwtHelper = new JwtHelperService();
+        this.isAuthenticatedSubject = new BehaviorSubject(this.hasToken());
+        this.isAuthenticate$ = this.isAuthenticatedSubject.asObservable();
+        this.user = this.getUserManager();
+    }
+    hasToken() {
+        const token = this.cookieService.get(TOKEN_KEY);
+        return token && !this.jwtHelper.isTokenExpired(token);
+    }
+    getUserManager() {
+        const token = this.cookieService.get(TOKEN_KEY);
+        if (token)
+            this.handleAccessTokenWithoutLanguage(token);
+        return AuthService.user;
+    }
+    getUser() {
+        this.user = AuthService.user;
+    }
+    storUser(User) {
+        AuthService.user = this.user = this.user;
+    }
+    getCurrentUser() {
+        return AuthService.user;
+    }
+    isAuthenticated() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return AuthService.user != null && !this.jwtHelper.isTokenExpired(AuthService.user.access_token);
+        });
+    }
+    isUserInRole(allowedPermission) {
+        let selectedPermissionSetID = Number.parseInt(this.user.profile['selectedpermissionsetid']);
+        return allowedPermission.includes(selectedPermissionSetID);
+    }
+    authorizationHeaderValue() {
+        return AuthService.user
+            ? `${AuthService.user.token_type} ${AuthService.user.access_token}`
+            : '';
+    }
+    name() {
+        return AuthService.user != null ? AuthService.user.profile.given_name : '';
+    }
+    setUrl(url) {
+        localStorage.setItem('redirectUrl', url);
+    }
+    getUrl() {
+        var _a;
+        return (_a = localStorage.getItem('redirectUrl')) !== null && _a !== void 0 ? _a : "/";
+    }
+    signOut() {
+        AuthService.timers.map(t => clearInterval(t));
+        AuthService.timers = [];
+        if (!this.isAuthenticated()) {
+            this.cookieService.delete(TOKEN_KEY);
+            this.router.navigate(['/Admin/account/login']);
+        }
+        this.logout().subscribe(res => {
+            this.cookieService.delete(TOKEN_KEY);
+            if (this.environmentService.getBBSFAuthenticationMode() == AuthenticationModes.UAEPass)
+                this.logoutFromUAEPass();
+            else
+                this.router.navigate(['/Admin/account/login']);
+        });
+    }
+    logout() {
+        const httpOptions = {
+            headers: new HttpHeaders({
+                'Content-Type': 'application/json',
+            }),
+        };
+        let ApiUrl = '/Account/';
+        return this.http.get(this.environmentService.getApiUrl() + ApiUrl + 'Logout', httpOptions);
+    }
+    clearUserSessionClaims() {
+        const httpOptions = {
+            headers: new HttpHeaders({
+                'Content-Type': 'application/json',
+            }),
+        };
+        let ApiUrl = '/api/Home/';
+        return this.http.get(this.environmentService.getBaseUrl() + ApiUrl + 'ClearCurrentUserSession', httpOptions);
+    }
+    handleAccessToken(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const token = response;
+            AuthService.user = new User();
+            AuthService.user.token_type = "Bearer";
+            AuthService.user.access_token = token;
+            AuthService.user.profile = this.jwtHelper.decodeToken(token);
+            AuthService.user.expires_at = this.jwtHelper.getTokenExpirationDate(token);
+            AuthService.timers.map(t => clearInterval(t));
+            AuthService.timers = [];
+            this.setTokenSeconds();
+            AuthService.timers.push(this.checkRefreshToken());
+            this.user = AuthService.user;
+            yield this.updateLanguage();
+            this.cookieService.set(TOKEN_KEY, token, null, null, null, true, 'Strict');
+            this.isAuthenticatedSubject.next(true);
+        });
+    }
+    handleAccessTokenWithoutLanguage(response) {
+        const token = response;
+        AuthService.user = new User();
+        AuthService.user.token_type = "Bearer";
+        AuthService.user.access_token = token;
+        AuthService.user.profile = this.jwtHelper.decodeToken(token);
+        AuthService.user.expires_at = this.jwtHelper.getTokenExpirationDate(token);
+        this.setTokenSeconds();
+        this.user = AuthService.user;
+        this.cookieService.set(TOKEN_KEY, token, null, null, null, true, 'Strict');
+        this.isAuthenticatedSubject.next(true);
+    }
+    updateLanguage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!localStorage.getItem('language') ||
+                localStorage.getItem('language') == this.user.profile.locale)
+                localStorage.setItem('language', this.user.profile.locale);
+            if (this.translateService.currentLang != localStorage.getItem('language')) {
+                this.translateService.resetLang(this.translateService.currentLang);
+                yield this.translateService
+                    .reloadLang(localStorage.getItem('language'))
+                    .subscribe((res) => {
+                    console.log(res);
+                });
+            }
+        });
+    }
+    checkRefreshToken() {
+        let date = new Date();
+        return setInterval(() => {
+            if (Math.floor(AuthService.seconds) < 120 && this.isAuthenticated())
+                this.refresh();
+            AuthService.seconds--;
+        }, 1000);
+    }
+    setTokenSeconds() {
+        let date = new Date();
+        AuthService.seconds = (AuthService.user.expires_at - date) / 1000;
+    }
+    refresh() {
+        const httpOptions = {
+            headers: new HttpHeaders({
+                'Content-Type': 'application/json',
+                'Authorization': this.authorizationHeaderValue(),
+            }),
+        };
+        let ApiUrl = '/api/Home/';
+        this.http.get(this.environmentService.getApiUrl() + ApiUrl + 'RefreshAccessToken', httpOptions).subscribe((res) => {
+            this.cookieService.delete(TOKEN_KEY);
+            this.handleAccessTokenWithoutLanguage(res.val);
+        });
+    }
+    loginWithUAEPass() {
+        const authEndpoint = `${this.environmentService.getUAEPassBaseUrl()}${this.environmentService.getUAEPassAuthorizationEndPoint()}`;
+        const queryParams = {
+            response_type: 'code',
+            client_id: `${this.environmentService.getUAEPassClientID()}`,
+            redirect_uri: `${this.environmentService.getBaseUrl()}${this.environmentService.getUAEPassRedirectUrl()}`,
+            scope: 'urn:uae:digitalid:profile:general urn:uae:digitalid:profile:general:profileType urn:uae:digitalid:profile:general:unifiedId',
+            state: 'pd3PgezRwk596u2yfRwqOgru',
+            acr_values: 'urn:safelayer:tws:policies:authentication:level:low'
+        };
+        const queryParamsString = Object.entries(queryParams)
+            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+            .join('&');
+        const loginUrl = `${authEndpoint}?${queryParamsString}`;
+        window.location.href = loginUrl;
+        return;
+    }
+    logoutFromUAEPass() {
+        const logoutEndpoint = `${this.environmentService.getUAEPassBaseUrl()}${this.environmentService.getUAEPassLogoutEndPoint()}`;
+        const queryParams = {
+            redirect_uri: `${this.environmentService.getBaseUrl()}`,
+        };
+        const queryParamsString = Object.entries(queryParams)
+            .map(([key, value]) => `${key}=${encodeURIComponent(value)}`)
+            .join('&');
+        const logoutUrl = `${logoutEndpoint}?${queryParamsString}`;
+        window.location.href = logoutUrl;
+        return;
     }
 }
-class DocumentOptionsModel {
-}
+AuthService.user = null;
+AuthService.UserClaims = null;
+//refresh
+AuthService.timers = [];
+AuthService.seconds = 0;
+AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthService, deps: [{ token: i0.Injector }, { token: i1.HttpClient }, { token: EnvironmentService }, { token: BBSFTranslateService }, { token: i1$1.Router }, { token: i4$1.CookieService }, { token: UtilityService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.HttpClient }, { type: EnvironmentService }, { type: BBSFTranslateService }, { type: i1$1.Router }, { type: i4$1.CookieService }, { type: UtilityService }]; } });
+
+class BBSFUtilitiesModule {
+}
+BBSFUtilitiesModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFUtilitiesModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+BBSFUtilitiesModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: BBSFUtilitiesModule, imports: [CommonModule,
+        RouterModule, i1$2.BlockUIModule, i2.ToastrModule] });
+BBSFUtilitiesModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFUtilitiesModule, providers: [
+        UtilityService,
+        EnvironmentService,
+        AuthService,
+        RequestHandlerService,
+        StylesBundleService,
+        TranslateService,
+        BBSFTranslateService,
+        ControlValidationService,
+        MasterLayoutService,
+        ConfigurationService,
+        CookieService
+    ], imports: [CommonModule,
+        RouterModule,
+        BlockUIModule.forRoot(),
+        ToastrModule.forRoot()] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: BBSFUtilitiesModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [
+                        CommonModule,
+                        RouterModule,
+                        BlockUIModule.forRoot(),
+                        ToastrModule.forRoot(),
+                    ],
+                    exports: [],
+                    providers: [
+                        UtilityService,
+                        EnvironmentService,
+                        AuthService,
+                        RequestHandlerService,
+                        StylesBundleService,
+                        TranslateService,
+                        BBSFTranslateService,
+                        ControlValidationService,
+                        MasterLayoutService,
+                        ConfigurationService,
+                        CookieService
+                    ]
+                }]
+        }] });
 
 /*
  * Public API Surface of @bnsights/bbsf-utilities
- */
+ */
+//Module
+//#endregion
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AppInjector, AppearanceConfigurationService, AuthService, BBSFTranslateService, BBSFUtilitiesModule, ConfigurationService, ControlValidationService, DocumentOptionsModel, EnvironmentService, MasterLayoutService, RequestHandlerService, RequestOptionsModel, StylesBundleService, TranslationResolverService, UtilityService, WordDocumentModel, WordDocumentService, environment };
-//# sourceMappingURL=bnsights-bbsf-utilities.js.map
+export { AppearanceConfigurationService, AuthService, AuthenticationModes, BBSFTranslateService, BBSFUtilitiesModule, ConfigurationService, ControlValidationService, DocumentOptionsModel, EnvironmentService, MasterLayoutService, RequestHandlerService, RequestOptionsModel, StylesBundleService, TranslationResolverService, UtilityService, WordDocumentModel, WordDocumentService, environment };
+//# sourceMappingURL=bnsights-bbsf-utilities.mjs.map