@bnsights/bbsf-utilities 1.0.0

package/esm2015/lib/shared/services/controlvalidation.service.js

@@ -0,0 +1,151 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { BlockUI } from 'ng-block-ui';
+import { UtilityService } from './utility.service';
+import { RequestOptionsModel } from '../models/RequestOptionsModel';
+import * as i0 from "@angular/core";
+import * as i1 from "./utility.service";
+export class ControlValidationService {
+    constructor(utilityService) {
+        this.utilityService = utilityService;
+        this.requestOptions = new RequestOptionsModel();
+        this.isCreatedBefor = false;
+    }
+    showGlobalError(errorMessage) {
+        let globalErorrElement = document.getElementsByClassName('alert alert-danger alert-InvalidValidation');
+        if (globalErorrElement.length > 0) {
+            this.removeElementsByClass('alert alert-danger alert-InvalidValidation');
+        }
+        if (this.isCreatedBefor == true) {
+            this.removeElementsByClass('alert alert-danger alert-InvalidValidation');
+        }
+        // tslint:disable-next-line: prefer-const
+        var objects = document.querySelectorAll('form.ng-invalid.ng-touched');
+        const tagName = 'div';
+        // tslint:disable-next-line: prefer-const
+        var elementToAppend = document.createElement(tagName); // Your tag name here
+        let message = "";
+        if (localStorage.getItem('language') == "ar")
+            message = errorMessage ? errorMessage : "لديك بعص الأخطاء . من فضلك قم بالمراجعه ";
+        else
+            message = errorMessage ? errorMessage : "You have some validation errors. Please check below";
+        elementToAppend.innerHTML = "<ul><li>" + message + "</li></ul>";
+        elementToAppend.className += 'alert alert-danger alert-InvalidValidation';
+        elementToAppend.id += 'errorId';
+        // tslint:disable-next-line: prefer-for-of
+        for (let i = 0; i < objects.length; i++) {
+            // const elementToAppen = elementToAppend.cloneNode(true);
+            // objects[i].insertBefore(elementToAppen, objects[i].firstChild);
+            const elementToAppen = elementToAppend.cloneNode(true);
+            let targetElement = objects[i].getElementsByClassName("b-control")[0];
+            targetElement.parentNode.insertBefore(elementToAppen, targetElement);
+            this.isCreatedBefor = true;
+            break;
+        }
+    }
+    RemoveGlobalError() {
+        const removedList = document.getElementsByClassName('alert alert-danger alert-InvalidValidation');
+        // 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) {
+        if (err.error == null) {
+            return;
+        }
+        this.requestOptions = requestOptions;
+        err.error.validation_errors.forEach((element) => {
+            let fieldName = element.field;
+            let controlName = element.control_name;
+            let message = element.message;
+            if (form == null) {
+                this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${fieldName}: ${message}`);
+            }
+            else if (!this.hasControlName(form, controlName)) {
+                this.showGlobalError(`${fieldName}: ${message}`);
+            }
+            else {
+                this.setFieldError(form, controlName, fieldName, message);
+            }
+        });
+    }
+    hasControlName(form, controlName) {
+        let control = form.get(controlName);
+        return control != null;
+    }
+    setFieldError(form, controlName, fieldName, message) {
+        let control = form.get(controlName);
+        let errors = { [message]: true };
+        let fieldNameArray = fieldName.split('.');
+        if (fieldNameArray.length >= 1) {
+            switch (fieldNameArray[length - 1].toLocaleLowerCase()) {
+                case "english":
+                    let englishControl = control.get("EnglishValue");
+                    englishControl.setErrors(errors);
+                    englishControl.markAsTouched();
+                    englishControl.updateValueAndValidity();
+                    break;
+                case "arabic":
+                    let arabicControl = control.get("ArabicValue");
+                    arabicControl.setErrors(errors);
+                    arabicControl.markAsTouched();
+                    arabicControl.updateValueAndValidity();
+                    break;
+                default:
+                    control.setErrors(errors);
+                    control.markAsTouched();
+                    control.updateValueAndValidity();
+            }
+        }
+        else {
+            this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${fieldName}: ${message}`);
+        }
+    }
+}
+ControlValidationService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ControlValidationService_Factory() { return new ControlValidationService(i0.ɵɵinject(i1.UtilityService)); }, token: ControlValidationService, providedIn: "root" });
+ControlValidationService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+ControlValidationService.ctorParameters = () => [
+    { type: UtilityService }
+];
+__decorate([
+    BlockUI()
+], ControlValidationService.prototype, "blockUI", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controlvalidation.service.js","sourceRoot":"","sources":["../../../../../../projects/bbsf-utilities/src/lib/shared/services/controlvalidation.service.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,UAAU,EAAuC,MAAM,eAAe,CAAC;AAEhF,OAAO,EAAE,OAAO,EAAa,MAAM,aAAa,CAAC;AAKjD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;;;AAOpE,MAAM,OAAO,wBAAwB;IAGjC,YAEY,cAA8B;QAA9B,mBAAc,GAAd,cAAc,CAAgB;QAJlC,mBAAc,GAAwB,IAAI,mBAAmB,EAAE,CAAC;QAUxE,mBAAc,GAAG,KAAK,CAAC;IAFrB,CAAC;IAMH,eAAe,CAAC,YAAoB;QAChC,IAAI,kBAAkB,GAAG,QAAQ,CAAC,sBAAsB,CAAC,4CAA4C,CAAC,CAAA;QACtG,IAAI,kBAAkB,CAAC,MAAM,GAAG,CAAC,EAAE;YAC/B,IAAI,CAAC,qBAAqB,CAAC,4CAA4C,CAAC,CAAC;SAC5E;QAED,IAAI,IAAI,CAAC,cAAc,IAAI,IAAI,EAAE;YAC7B,IAAI,CAAC,qBAAqB,CAAC,4CAA4C,CAAC,CAAC;SAC5E;QACD,yCAAyC;QACzC,IAAI,OAAO,GAAG,QAAQ,CAAC,gBAAgB,CAAC,4BAA4B,CAAC,CAAC;QACtE,MAAM,OAAO,GAAG,KAAK,CAAC;QACtB,yCAAyC;QACzC,IAAI,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,qBAAqB;QAC5E,IAAI,OAAO,GAAG,EAAE,CAAC;QACjB,IAAI,YAAY,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,IAAI;YACxC,OAAO,GAAE,YAAY,CAAA,CAAC,CAAA,YAAY,CAAA,CAAC,CAAC,0CAA0C,CAAC;;YAE/E,OAAO,GAAE,YAAY,CAAA,CAAC,CAAA,YAAY,CAAA,CAAC,CAAC,qDAAqD,CAAA;QAE7F,eAAe,CAAC,SAAS,GAAG,UAAU,GAAG,OAAO,GAAG,YAAY,CAAC;QAChE,eAAe,CAAC,SAAS,IAAI,4CAA4C,CAAC;QAC1E,eAAe,CAAC,EAAE,IAAI,SAAS,CAAC;QAChC,0CAA0C;QAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACrC,0DAA0D;YAC1D,kEAAkE;YAClE,MAAM,cAAc,GAAG,eAAe,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YACvD,IAAI,aAAa,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;YACtE,aAAa,CAAC,UAAU,CAAC,YAAY,CAAC,cAAc,EAAE,aAAa,CAAC,CAAC;YACrE,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;YAC3B,MAAM;SACT;IAEL,CAAC;IAED,iBAAiB;QACb,MAAM,WAAW,GAAG,QAAQ,CAAC,sBAAsB,CAAC,4CAA4C,CAAC,CAAC;QAClG,0CAA0C;QAC1C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,WAAW,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;YACrD,MAAM,OAAO,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC;YACnC,OAAO,CAAC,MAAM,EAAE,CAAC;SACpB;QACD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;IAChC,CAAC;IAED,aAAa,CAAC,MAAW;QAErB,6BAA6B;QAC7B,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,+BAA+B;QAC/B,IAAI,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;QAC3C,0BAA0B;QAC1B,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE;YACtB,IAAI,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE;gBAC5B,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,GAAG,CAAC,EAAE;oBAChC,MAAM,KAAK,GAAG,QAAQ,CAAC,gBAAgB,CAAC,mBAAmB,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC5E,IAAK,KAAK,CAAC,UAAU,CAAC,iBAAiB,CAAC,CAAC,KAAgB,KAAK,GAAG,EAAE;wBAC/D,IAAI,CAAC,qBAAqB,CAAC,YAAY,GAAG,GAAG,CAAC,CAAC;wBAC/C,MAAM,OAAO,GAAG,GAAG,CAAA;wBACnB,MAAM,eAAe,GAAG,QAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,qBAAqB;wBAC9E,eAAe,CAAC,SAAS,GAAG,QAAQ,CAAC;wBACrC,eAAe,CAAC,KAAK,CAAC,KAAK,GAAG,KAAK,CAAA;wBACnC,eAAe,CAAC,SAAS,IAAI,yBAAyB,GAAG,GAAG,CAAC;wBAC7D,MAAM,cAAc,GAAG,eAAe,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;wBACvD,KAAK,CAAC,UAAU,CAAC,YAAY,CAAC,cAAc,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;wBAC/D,MAAM;qBACT;iBACJ;aACJ;SACJ;IACL,CAAC;IAED,qBAAqB,CAAC,SAAS;QAC3B,MAAM,QAAQ,GAAG,QAAQ,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;QAC5D,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YACxB,QAAQ,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;SACnD;IACL,CAAC;IAGA,kBAAkB,CAAC,IAAe,EAAE,GAAsB,EAAC,cAAkC;QAC1F,IAAI,GAAG,CAAC,KAAK,IAAI,IAAI,EAAE;YACrB,OAAO;SACR;QACD,IAAI,CAAC,cAAc,GAAC,cAAc,CAAC;QACnC,GAAG,CAAC,KAAK,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,OAAmB,EAAE,EAAE;YACxD,IAAI,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC;YAC9B,IAAI,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC;YACvC,IAAI,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;YAC9B,IAAI,IAAI,IAAI,IAAI,EAAG;gBACf,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,GAAG,SAAS,KAAK,OAAO,EAAE,CAAC,CAAA;aAC/L;iBACI,IAAG,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,EAAC,WAAW,CAAC,EAC9C;gBACI,IAAI,CAAC,eAAe,CAAC,GAAG,SAAS,KAAK,OAAO,EAAE,CAAC,CAAA;aACnD;iBACI;gBACH,IAAI,CAAC,aAAa,CAAC,IAAI,EAAC,WAAW,EAAC,SAAS,EAAC,OAAO,CAAC,CAAC;aACxD;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,cAAc,CAAC,IAAe,EAAE,WAAmB;QAEzD,IAAI,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QACpC,OAAO,OAAO,IAAI,IAAI,CAAC;IACzB,CAAC;IAEO,aAAa,CAAC,IAAe,EAAE,WAAmB,EAAC,SAAgB,EAAC,OAAe;QACzF,IAAI,OAAO,GAAE,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QACnC,IAAI,MAAM,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,CAAC;QACjC,IAAI,cAAc,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAA;QAE1C,IAAI,cAAc,CAAC,MAAM,IAAE,CAAC,EAC3B;YACE,QAAQ,cAAc,CAAC,MAAM,GAAC,CAAC,CAAC,CAAC,iBAAiB,EAAE,EAAE;gBACpD,KAAK,SAAS;oBACZ,IAAI,cAAc,GAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,CAAA;oBAC9C,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;oBACjC,cAAc,CAAC,aAAa,EAAE,CAAC;oBAC/B,cAAc,CAAC,sBAAsB,EAAE,CAAC;oBACxC,MAAM;gBACR,KAAK,QAAQ;oBACX,IAAI,aAAa,GAAC,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;oBAC5C,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;oBAChC,aAAa,CAAC,aAAa,EAAE,CAAC;oBAC9B,aAAa,CAAC,sBAAsB,EAAE,CAAC;oBACvC,MAAM;gBAER;oBACE,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;oBAC1B,OAAO,CAAC,aAAa,EAAE,CAAC;oBACxB,OAAO,CAAC,sBAAsB,EAAE,CAAC;aACpC;SAEF;aAED;YACE,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,GAAG,SAAS,KAAK,OAAO,EAAE,CAAC,CAAA;SAC7L;IAGH,CAAC;;;;YAjKN,UAAU,SAAC;gBACR,UAAU,EAAE,MAAM;aACnB;;;YAPM,cAAc;;AAqBR;IAAV,OAAO,EAAE;yDAAoB","sourcesContent":["import { Injectable, Optional, Host, SkipSelf, Component } from '@angular/core';\r\nimport { IndividualConfig, ToastrService } from 'ngx-toastr';\r\nimport { BlockUI, NgBlockUI } from 'ng-block-ui';\r\nimport { AbstractControl, ControlContainer, ControlValueAccessor, NG_VALUE_ACCESSOR, FormControl, FormsModule, FormGroup } from '@angular/forms';\r\nimport { TranslateService } from '@ngx-translate/core';\r\nimport { HttpErrorResponse } from '@angular/common/http';\r\nimport { ErrorModel } from '../models/ErrorModel';\r\nimport { UtilityService } from './utility.service';\r\nimport { RequestOptionsModel } from '../models/RequestOptionsModel';\r\n\r\n\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n  })\r\nexport class ControlValidationService {\r\n    private requestOptions: RequestOptionsModel = new RequestOptionsModel();\r\n\r\n    constructor\r\n      (\r\n        private utilityService: UtilityService\r\n      ) \r\n      { \r\n\r\n      }\r\n\r\n    isCreatedBefor = false;\r\n\r\n    @BlockUI() blockUI: NgBlockUI;\r\n\r\n    showGlobalError(errorMessage?:string) {\r\n        let globalErorrElement = document.getElementsByClassName('alert alert-danger alert-InvalidValidation')\r\n        if (globalErorrElement.length > 0) {\r\n            this.removeElementsByClass('alert alert-danger alert-InvalidValidation');\r\n        }\r\n\r\n        if (this.isCreatedBefor == true) {\r\n            this.removeElementsByClass('alert alert-danger alert-InvalidValidation');\r\n        }\r\n        // tslint:disable-next-line: prefer-const\r\n        var objects = document.querySelectorAll('form.ng-invalid.ng-touched');\r\n        const tagName = 'div';\r\n        // tslint:disable-next-line: prefer-const\r\n        var elementToAppend = document.createElement(tagName); // Your tag name here\r\n        let message = \"\";\r\n        if (localStorage.getItem('language') == \"ar\")\r\n            message =errorMessage?errorMessage: \"لديك بعص الأخطاء . من فضلك قم بالمراجعه \";\r\n        else\r\n            message =errorMessage?errorMessage: \"You have some validation errors. Please check below\"\r\n\r\n        elementToAppend.innerHTML = \"<ul><li>\" + message + \"</li></ul>\";\r\n        elementToAppend.className += 'alert alert-danger alert-InvalidValidation';\r\n        elementToAppend.id += 'errorId';\r\n        // tslint:disable-next-line: prefer-for-of\r\n        for (let i = 0; i < objects.length; i++) {\r\n            // const elementToAppen = elementToAppend.cloneNode(true);\r\n            // objects[i].insertBefore(elementToAppen, objects[i].firstChild);\r\n            const elementToAppen = elementToAppend.cloneNode(true);\r\n            let targetElement = objects[i].getElementsByClassName(\"b-control\")[0];\r\n            targetElement.parentNode.insertBefore(elementToAppen, targetElement);\r\n            this.isCreatedBefor = true;\r\n            break;\r\n        }\r\n\r\n    }\r\n\r\n    RemoveGlobalError() {\r\n        const removedList = document.getElementsByClassName('alert alert-danger alert-InvalidValidation');\r\n        // tslint:disable-next-line: prefer-for-of\r\n        for (let index = 0; index < removedList.length; index++) {\r\n            const element = removedList[index];\r\n            element.remove();\r\n        }\r\n        this.isCreatedBefor = false;\r\n    }\r\n\r\n    showInputErro(errors: any) {\r\n\r\n        // show error on top of form \r\n        this.showGlobalError();\r\n        // remove old error from server\r\n        this.removeElementsByClass('errortemplet');\r\n        // Looping in error Object\r\n        for (const key in errors) {\r\n            if (errors.hasOwnProperty(key)) {\r\n                for (const iterator of errors[key]) {\r\n                    const input = document.querySelectorAll('[ng-reflect-name=' + key + ']')[0];\r\n                    if ((input.attributes['ng-reflect-name'].value as string) === key) {\r\n                        this.removeElementsByClass('erroclass-' + key);\r\n                        const tagName = 'p'\r\n                        const elementToAppend = document.createElement(tagName); // Your tag name here\r\n                        elementToAppend.innerHTML = iterator;\r\n                        elementToAppend.style.color = 'red'\r\n                        elementToAppend.className += 'errortemplet erroclass-' + key;\r\n                        const elementToappen = elementToAppend.cloneNode(true);\r\n                        input.parentNode.insertBefore(elementToappen, input.lastChild);\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    removeElementsByClass(className) {\r\n        const elements = document.getElementsByClassName(className);\r\n        while (elements.length > 0) {\r\n            elements[0].parentNode.removeChild(elements[0]);\r\n        }\r\n    }\r\n\r\n\r\n     renderServerErrors(form: FormGroup, err: HttpErrorResponse,requestOptions:RequestOptionsModel) {\r\n        if (err.error == null) {\r\n          return;\r\n        }\r\n        this.requestOptions=requestOptions;\r\n        err.error.validation_errors.forEach((element: ErrorModel) => {\r\n            let fieldName = element.field;\r\n            let controlName = element.control_name;\r\n            let message = element.message;\r\n            if (form == null ) {\r\n                this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${fieldName}: ${message}`)\r\n            }\r\n            else if(!this.hasControlName(form,controlName))\r\n            {\r\n                this.showGlobalError(`${fieldName}: ${message}`)\r\n            }\r\n            else {\r\n              this.setFieldError(form,controlName,fieldName,message);\r\n            }\r\n        });\r\n      }\r\n    \r\n      private hasControlName(form: FormGroup, controlName: string): boolean\r\n     {\r\n        let control = form.get(controlName);\r\n        return control != null;\r\n      }\r\n    \r\n      private setFieldError(form: FormGroup, controlName: string,fieldName:string,message: string) {\r\n        let control =form.get(controlName);\r\n        let errors = { [message]: true };\r\n        let fieldNameArray = fieldName.split('.')\r\n    \r\n       if (fieldNameArray.length>=1)\r\n        {\r\n          switch (fieldNameArray[length-1].toLocaleLowerCase()) {\r\n            case \"english\":\r\n              let englishControl=control.get(\"EnglishValue\")\r\n              englishControl.setErrors(errors);\r\n              englishControl.markAsTouched();\r\n              englishControl.updateValueAndValidity();\r\n              break;\r\n            case \"arabic\":\r\n              let arabicControl=control.get(\"ArabicValue\")\r\n              arabicControl.setErrors(errors);\r\n              arabicControl.markAsTouched();\r\n              arabicControl.updateValueAndValidity();\r\n              break;\r\n            \r\n            default:\r\n              control.setErrors(errors);\r\n              control.markAsTouched();\r\n              control.updateValueAndValidity();\r\n          }\r\n           \r\n        }\r\n        else\r\n        {  \r\n          this.requestOptions.customErrorMessage ? this.utilityService.notifyErrorMessage(this.requestOptions.customErrorMessage) : this.utilityService.notifyErrorMessage(`${fieldName}: ${message}`)\r\n        }\r\n        \r\n    \r\n      }\r\n    \r\n    \r\n}\r\n"]}

package/esm2015/lib/shared/services/environment.service.js

@@ -0,0 +1,31 @@
+import { Injectable } from '@angular/core';
+import { environment } from '../config/environment';
+import * as i0 from "@angular/core";
+export class EnvironmentService {
+    getEnvironmentObject() {
+        return environment;
+    }
+    getBaseUrl() {
+        let Url = environment["BBSF_BaseUrl"];
+        return Url;
+    }
+    getApiUrl() {
+        let Url = environment["BBSF_ApiUrl"];
+        return Url;
+    }
+    getProductionMode() {
+        let Mode = environment["BBSF_IsProduction"];
+        return Mode;
+    }
+    getIdentityServerUrl() {
+        let Url = environment["BBSF_IdentityServerUrl"];
+        return Url;
+    }
+}
+EnvironmentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EnvironmentService_Factory() { return new EnvironmentService(); }, token: EnvironmentService, providedIn: "root" });
+EnvironmentService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW52aXJvbm1lbnQuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Jic2YtdXRpbGl0aWVzL3NyYy9saWIvc2hhcmVkL3NlcnZpY2VzL2Vudmlyb25tZW50LnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sdUJBQXVCLENBQUM7O0FBS3BELE1BQU0sT0FBTyxrQkFBa0I7SUFFN0Isb0JBQW9CO1FBQ2xCLE9BQU8sV0FBVyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxVQUFVO1FBQ1IsSUFBSSxHQUFHLEdBQUcsV0FBVyxDQUFDLGNBQWMsQ0FBQyxDQUFBO1FBQ3JDLE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQztJQUNELFNBQVM7UUFDUCxJQUFJLEdBQUcsR0FBRyxXQUFXLENBQUMsYUFBYSxDQUFDLENBQUE7UUFDcEMsT0FBTyxHQUFHLENBQUM7SUFDYixDQUFDO0lBR0QsaUJBQWlCO1FBQ2YsSUFBSSxJQUFJLEdBQUcsV0FBVyxDQUFDLG1CQUFtQixDQUFZLENBQUE7UUFDdEQsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQsb0JBQW9CO1FBQ2xCLElBQUksR0FBRyxHQUFHLFdBQVcsQ0FBQyx3QkFBd0IsQ0FBQyxDQUFBO1FBQy9DLE9BQU8sR0FBRyxDQUFDO0lBQ2IsQ0FBQzs7OztZQTNCRixVQUFVLFNBQUM7Z0JBQ1YsVUFBVSxFQUFFLE1BQU07YUFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IGVudmlyb25tZW50IH0gZnJvbSAnLi4vY29uZmlnL2Vudmlyb25tZW50JztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIEVudmlyb25tZW50U2VydmljZSB7XHJcblxyXG4gIGdldEVudmlyb25tZW50T2JqZWN0KCkge1xyXG4gICAgcmV0dXJuIGVudmlyb25tZW50O1xyXG4gIH1cclxuXHJcbiAgZ2V0QmFzZVVybCgpIHtcclxuICAgIGxldCBVcmwgPSBlbnZpcm9ubWVudFtcIkJCU0ZfQmFzZVVybFwiXVxyXG4gICAgcmV0dXJuIFVybDtcclxuICB9XHJcbiAgZ2V0QXBpVXJsKCkge1xyXG4gICAgbGV0IFVybCA9IGVudmlyb25tZW50W1wiQkJTRl9BcGlVcmxcIl1cclxuICAgIHJldHVybiBVcmw7XHJcbiAgfVxyXG5cclxuXHJcbiAgZ2V0UHJvZHVjdGlvbk1vZGUoKSB7XHJcbiAgICBsZXQgTW9kZSA9IGVudmlyb25tZW50W1wiQkJTRl9Jc1Byb2R1Y3Rpb25cIl0gYXMgYm9vbGVhblxyXG4gICAgcmV0dXJuIE1vZGU7XHJcbiAgfVxyXG5cclxuICBnZXRJZGVudGl0eVNlcnZlclVybCgpIHtcclxuICAgIGxldCBVcmwgPSBlbnZpcm9ubWVudFtcIkJCU0ZfSWRlbnRpdHlTZXJ2ZXJVcmxcIl1cclxuICAgIHJldHVybiBVcmw7XHJcbiAgfVxyXG59Il19

package/esm2015/lib/shared/services/masterlayout.service.js

@@ -0,0 +1,65 @@
+import { HttpParams } from "@angular/common/http";
+import { Injectable } from "@angular/core";
+import { Router } from "@angular/router";
+import { TranslateService } from "@ngx-translate/core";
+import { AuthService } from "../authentication/auth.service";
+import { RequestHandlerService } from "./requesthandler.service";
+import { StylesBundleService } from "./stylesbundle.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "./requesthandler.service";
+import * as i3 from "../authentication/auth.service";
+import * as i4 from "./stylesbundle.service";
+import * as i5 from "@ngx-translate/core";
+export class MasterLayoutService {
+    constructor(router, http, authService, stylesBundleService, translate) {
+        this.router = router;
+        this.http = http;
+        this.authService = authService;
+        this.stylesBundleService = stylesBundleService;
+        this.translate = translate;
+        this.ApiUrl = "/api/admin/Users/";
+    }
+    switchLang(lang, bundleEnglishName, bundleArabicName) {
+        this.changeLanguage(lang).subscribe((result) => {
+            this.updateUserInfo().subscribe((Value) => {
+                let UserInfoObject = Value;
+                this.authService.getUser();
+                this.authService.user.profile = Object.assign(this.authService.user.profile, UserInfoObject);
+                this.authService.storUser(this.authService.user);
+                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 + 'updateLaguage', null, params);
+    }
+    updateUserInfo() {
+        return this.http.get('/connect/userinfo');
+    }
+}
+MasterLayoutService.ɵprov = i0.ɵɵdefineInjectable({ factory: function MasterLayoutService_Factory() { return new MasterLayoutService(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.RequestHandlerService), i0.ɵɵinject(i3.AuthService), i0.ɵɵinject(i4.StylesBundleService), i0.ɵɵinject(i5.TranslateService)); }, token: MasterLayoutService, providedIn: "root" });
+MasterLayoutService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+MasterLayoutService.ctorParameters = () => [
+    { type: Router },
+    { type: RequestHandlerService },
+    { type: AuthService },
+    { type: StylesBundleService },
+    { type: TranslateService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared/services/requesthandler.service.js

@@ -0,0 +1,85 @@
+import { Injectable } from '@angular/core';
+import { HttpClient, HttpHeaders } from "@angular/common/http";
+import { RequestOptionsModel } from '../models/RequestOptionsModel';
+import { AuthService } from '../authentication/auth.service';
+import { EnvironmentService } from './environment.service';
+import { Subject } from 'rxjs';
+import { UtilityService } from './utility.service';
+import { takeUntil, tap } from 'rxjs/operators';
+import { ControlValidationService } from './controlvalidation.service';
+import { BBSFTranslateService } from './translate.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../authentication/auth.service";
+import * as i3 from "./environment.service";
+import * as i4 from "./utility.service";
+import * as i5 from "./controlvalidation.service";
+import * as i6 from "./translate.service";
+export class RequestHandlerService {
+    constructor(http, authService, environmentService, utilityService, controlValidationService, bbsfTranslateService) {
+        this.http = http;
+        this.authService = authService;
+        this.environmentService = environmentService;
+        this.utilityService = utilityService;
+        this.controlValidationService = controlValidationService;
+        this.bbsfTranslateService = bbsfTranslateService;
+        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.currentLanguage = localStorage.getItem('language');
+        this.bbsfTranslateService.onLangChange.subscribe((event) => {
+            if (this.currentLanguage != event.lang) {
+                this.currentLanguage = event.lang;
+            }
+        });
+    }
+    get(Url, params, requestOptions) {
+        if (requestOptions)
+            this.requestOptions = requestOptions;
+        let headers = new HttpHeaders({
+            'Content-Type': 'application/json',
+            'Authorization': this.authService.authorizationHeaderValue(),
+        });
+        headers = headers.set('Accept-Language', this.currentLanguage.toString());
+        if (!this.requestOptions.disableBlockUI)
+            this.utilityService.startBlockUI();
+        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();
+        }));
+    }
+    post(Url, model, params, requestOptions) {
+        if (requestOptions)
+            this.requestOptions = requestOptions;
+        let headers = new HttpHeaders({
+            'Content-Type': 'application/json',
+            'Authorization': this.authService.authorizationHeaderValue(),
+        });
+        headers = headers.set('Accept-Language', this.currentLanguage.toString());
+        if (!this.requestOptions.disableBlockUI)
+            this.utilityService.startBlockUI();
+        return this.http.post(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: this.requestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+            if (!this.requestOptions.disableBlockUI)
+                this.utilityService.stopBlockUI();
+        }));
+    }
+    destroyHandler() {
+        this.onDestroy$.next();
+    }
+}
+RequestHandlerService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RequestHandlerService_Factory() { return new RequestHandlerService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.AuthService), i0.ɵɵinject(i3.EnvironmentService), i0.ɵɵinject(i4.UtilityService), i0.ɵɵinject(i5.ControlValidationService), i0.ɵɵinject(i6.BBSFTranslateService)); }, token: RequestHandlerService, providedIn: "root" });
+RequestHandlerService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+RequestHandlerService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: AuthService },
+    { type: EnvironmentService },
+    { type: UtilityService },
+    { type: ControlValidationService },
+    { type: BBSFTranslateService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"requesthandler.service.js","sourceRoot":"","sources":["../../../../../../projects/bbsf-utilities/src/lib/shared/services/requesthandler.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { HttpClient, HttpErrorResponse, HttpHeaders, HttpParams } from \"@angular/common/http\";\r\nimport { RequestOptionsModel } from '../models/RequestOptionsModel';\r\nimport { Observable } from 'rxjs/internal/Observable';\r\nimport { AuthService } from '../authentication/auth.service';\r\nimport { EnvironmentService } from './environment.service';\r\nimport { Subject, throwError } from 'rxjs';\r\nimport { UtilityService } from './utility.service';\r\nimport { catchError, takeUntil, tap } from 'rxjs/operators';\r\nimport { FormGroup } from '@angular/forms';\r\nimport { ErrorModel } from '../models/ErrorModel';\r\nimport { ControlValidationService } from './controlvalidation.service';\r\nimport { BBSFTranslateService } from './translate.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class RequestHandlerService {\r\n  private requestOptions: RequestOptionsModel = new RequestOptionsModel();\r\n  private currentLanguage = \"\";\r\n  private onDestroy$: Subject<void> = new Subject<void>();\r\n  constructor\r\n    (\r\n      private http: HttpClient,\r\n      private authService: AuthService,\r\n      private environmentService: EnvironmentService,\r\n      private utilityService: UtilityService,\r\n      private controlValidationService: ControlValidationService,\r\n      private bbsfTranslateService: BBSFTranslateService\r\n    ) {\r\n    //using localStorage  to avoid call getCurrentLanguage() because it is not all to use async in constructor\r\n    this.currentLanguage = localStorage.getItem('language');\r\n\r\n    this.bbsfTranslateService.onLangChange.subscribe((event) => {\r\n      if (this.currentLanguage != event.lang) {\r\n        this.currentLanguage = event.lang;\r\n      }\r\n    })\r\n  }\r\n\r\n  get(Url: string, params?: HttpParams, requestOptions?: RequestOptionsModel) {\r\n    if (requestOptions)\r\n      this.requestOptions = requestOptions;\r\n    let headers = new HttpHeaders({\r\n      'Content-Type': 'application/json',\r\n      'Authorization': this.authService.authorizationHeaderValue(),\r\n    });\r\n    headers = headers.set('Accept-Language', this.currentLanguage.toString());\r\n    if (!this.requestOptions.disableBlockUI)\r\n      this.utilityService.startBlockUI();\r\n    return this.http.get(this.environmentService.getApiUrl() + Url, { headers: headers, params: params }).pipe(\r\n      takeUntil(this.onDestroy$),\r\n      tap((result) => {\r\n        if (!this.requestOptions.disableBlockUI)\r\n          this.utilityService.stopBlockUI();\r\n      })\r\n    );\r\n  }\r\n\r\n  post(Url: string, model?: any, params?: HttpParams, requestOptions?: RequestOptionsModel) {\r\n    if (requestOptions)\r\n      this.requestOptions = requestOptions;\r\n    let headers = new HttpHeaders({\r\n      'Content-Type': 'application/json',\r\n      'Authorization': this.authService.authorizationHeaderValue(),\r\n\r\n    });\r\n    headers = headers.set('Accept-Language', this.currentLanguage.toString());\r\n    if (!this.requestOptions.disableBlockUI)\r\n      this.utilityService.startBlockUI();\r\n    return this.http.post(this.environmentService.getApiUrl() + Url, model, { headers: headers, params: params, responseType: this.requestOptions.responseType }).pipe(\r\n      takeUntil(this.onDestroy$),\r\n      tap((result) => {\r\n        if (!this.requestOptions.disableBlockUI)\r\n           this.utilityService.stopBlockUI();\r\n      })\r\n    );\r\n  }\r\n  \r\n  public destroyHandler(): void {\r\n    this.onDestroy$.next();\r\n  }\r\n}\r\n\r\n"]}

package/esm2015/lib/shared/services/stylesbundle.service.js

@@ -0,0 +1,46 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class StylesBundleService {
+    constructor(document) {
+        this.document = document;
+    }
+    loadThemes(lang, bundleEnglishName, bundleArabicName) {
+        if (lang == "ar") {
+            this.loadStyleBundle(bundleArabicName.toString());
+            document.querySelector('html').setAttribute("lang", "ar");
+            document.querySelector('html').setAttribute("dir", "rtl");
+        }
+        else {
+            this.loadStyleBundle(bundleEnglishName.toString());
+            document.querySelector('html').setAttribute("lang", "en");
+            document.querySelector('html').setAttribute("dir", "ltr");
+        }
+    }
+    loadStyleBundle(styleName) {
+        const head = this.document.getElementsByTagName('head')[0];
+        let themeLink = this.document.getElementById('client-theme');
+        if (themeLink && themeLink.href.includes(styleName)) {
+            return;
+        }
+        else if (themeLink && !themeLink.href.includes(styleName)) {
+            themeLink.remove();
+        }
+        const style = this.document.createElement('link');
+        style.id = 'client-theme';
+        style.rel = 'stylesheet';
+        style.href = `${styleName}`;
+        head.appendChild(style);
+    }
+}
+StylesBundleService.ɵprov = i0.ɵɵdefineInjectable({ factory: function StylesBundleService_Factory() { return new StylesBundleService(i0.ɵɵinject(i1.DOCUMENT)); }, token: StylesBundleService, providedIn: "root" });
+StylesBundleService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+StylesBundleService.ctorParameters = () => [
+    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/shared/services/translate.service.js

@@ -0,0 +1,13 @@
+import { Injectable } from "@angular/core";
+import { TranslateService } from "@ngx-translate/core";
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
+export 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'
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRlLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYnNmLXV0aWxpdGllcy9zcmMvbGliL3NoYXJlZC9zZXJ2aWNlcy90cmFuc2xhdGUuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDOzs7QUFLdkQsTUFBTSxPQUFPLG9CQUFxQixTQUFRLGdCQUFnQjs7OztZQUh6RCxVQUFVLFNBQUM7Z0JBQ1IsVUFBVSxFQUFFLE1BQU07YUFDckIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHsgVHJhbnNsYXRlU2VydmljZSB9IGZyb20gXCJAbmd4LXRyYW5zbGF0ZS9jb3JlXCI7XHJcblxyXG5ASW5qZWN0YWJsZSh7XHJcbiAgICBwcm92aWRlZEluOiAncm9vdCdcclxufSlcclxuZXhwb3J0IGNsYXNzIEJCU0ZUcmFuc2xhdGVTZXJ2aWNlIGV4dGVuZHMgVHJhbnNsYXRlU2VydmljZSB7XHJcbn0iXX0=

package/esm2015/lib/shared/services/utility.service.js

@@ -0,0 +1,96 @@
+import { __awaiter, __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { ToastrService } from 'ngx-toastr';
+import { BlockUI } from 'ng-block-ui';
+import { AppInjector } from '../../bbsf-utilities.module';
+import { AuthService } from '../authentication/auth.service';
+import { BBSFTranslateService } from './translate.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./translate.service";
+import * as i2 from "../authentication/auth.service";
+export class UtilityService {
+    constructor(Translator, authService) {
+        this.Translator = Translator;
+        this.authService = authService;
+        this.isCreatedBefore = false;
+    }
+    getResourceValue(Key) {
+        let ResourceValue = "";
+        this.Translator.get(Key).subscribe(data => { ResourceValue = data; return ResourceValue; });
+        return ResourceValue;
+    }
+    getCurrentLanguage() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let user = yield this.authService.getCurrentUser().then((user) => {
+                return user;
+            });
+            return user.profile.locale;
+        });
+    }
+    isCurrentLanguageEnglish() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield this.getCurrentLanguage()) == "en" ? true : false;
+        });
+    }
+    isCurrentLanguageArabic() {
+        return __awaiter(this, void 0, void 0, function* () {
+            (yield this.getCurrentLanguage()) == "ar" ? true : false;
+        });
+    }
+    notifySuccessMessage(Message, title, time) {
+        let MessageTemplate = this.getResourceValue("SuccessMessage");
+        let titleTemplate = this.getResourceValue("Success");
+        if (Message) {
+            MessageTemplate = Message;
+        }
+        if (title) {
+            titleTemplate = title;
+        }
+        let toaster = AppInjector.get(ToastrService);
+        toaster.success(MessageTemplate, titleTemplate);
+    }
+    notifyErrorMessage(Message, title, time) {
+        let MessageTemplate = this.getResourceValue("ErrorMessage");
+        let titleTemplate = this.getResourceValue("Error");
+        if (Message) {
+            MessageTemplate = Message;
+        }
+        if (title) {
+            titleTemplate = title;
+        }
+        const toaster = AppInjector.get(ToastrService);
+        toaster.error(MessageTemplate, titleTemplate);
+    }
+    notifyWarningMessage(Message, title, time) {
+        let MessageTemplate = this.getResourceValue("WarningMessage");
+        let titleTemplate = this.getResourceValue("Warning");
+        if (Message) {
+            MessageTemplate = Message;
+        }
+        if (title) {
+            titleTemplate = title;
+        }
+        const toaster = AppInjector.get(ToastrService);
+        toaster.warning(MessageTemplate, titleTemplate);
+    }
+    startBlockUI() {
+        this.blockUI.start();
+    }
+    stopBlockUI() {
+        this.blockUI.stop();
+    }
+}
+UtilityService.ɵprov = i0.ɵɵdefineInjectable({ factory: function UtilityService_Factory() { return new UtilityService(i0.ɵɵinject(i1.BBSFTranslateService), i0.ɵɵinject(i2.AuthService)); }, token: UtilityService, providedIn: "root" });
+UtilityService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+UtilityService.ctorParameters = () => [
+    { type: BBSFTranslateService },
+    { type: AuthService }
+];
+__decorate([
+    BlockUI()
+], UtilityService.prototype, "blockUI", void 0);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/public-api.js

@@ -0,0 +1,15 @@
+/*
+ * Public API Surface of bbsf-utilities
+ */
+export * from './lib/bbsf-utilities.module';
+export * from './lib/shared/services/utility.service';
+export * from './lib/shared/services/environment.service';
+export * from './lib/shared/services/requesthandler.service';
+export * from './lib/shared/services/stylesbundle.service';
+export * from './lib/shared/services/translate.service';
+export * from './lib/shared/services/controlvalidation.service';
+export * from './lib/shared/services/masterlayout.service';
+export * from './lib/shared/config/environment';
+export * from './lib/shared/authentication/auth.service';
+export * from './lib/shared/models/RequestOptionsModel';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2Jic2YtdXRpbGl0aWVzL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw2QkFBNkIsQ0FBQztBQUU1QyxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsMkNBQTJDLENBQUM7QUFDMUQsY0FBYyw4Q0FBOEMsQ0FBQTtBQUM1RCxjQUFjLDRDQUE0QyxDQUFBO0FBQzFELGNBQWMseUNBQXlDLENBQUE7QUFDdkQsY0FBYyxpREFBaUQsQ0FBQTtBQUMvRCxjQUFjLDRDQUE0QyxDQUFBO0FBTTFELGNBQWMsaUNBQWlDLENBQUM7QUFHaEQsY0FBYywwQ0FBMEMsQ0FBQztBQUd6RCxjQUFjLHlDQUF5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcclxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGJic2YtdXRpbGl0aWVzXHJcbiAqL1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvYmJzZi11dGlsaXRpZXMubW9kdWxlJztcclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NoYXJlZC9zZXJ2aWNlcy91dGlsaXR5LnNlcnZpY2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zaGFyZWQvc2VydmljZXMvZW52aXJvbm1lbnQuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NoYXJlZC9zZXJ2aWNlcy9yZXF1ZXN0aGFuZGxlci5zZXJ2aWNlJ1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zaGFyZWQvc2VydmljZXMvc3R5bGVzYnVuZGxlLnNlcnZpY2UnXHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NoYXJlZC9zZXJ2aWNlcy90cmFuc2xhdGUuc2VydmljZSdcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvc2hhcmVkL3NlcnZpY2VzL2NvbnRyb2x2YWxpZGF0aW9uLnNlcnZpY2UnXHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NoYXJlZC9zZXJ2aWNlcy9tYXN0ZXJsYXlvdXQuc2VydmljZSdcclxuXHJcblxyXG5cclxuXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zaGFyZWQvY29uZmlnL2Vudmlyb25tZW50JztcclxuXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zaGFyZWQvYXV0aGVudGljYXRpb24vYXV0aC5zZXJ2aWNlJztcclxuXHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zaGFyZWQvbW9kZWxzL1JlcXVlc3RPcHRpb25zTW9kZWwnO1xyXG5cclxuIl19