@bnsights/bbsf-utilities 1.0.39 → 1.0.41

package/esm2020/lib/shared/services/request-handler.service.mjs

@@ -0,0 +1,199 @@
+import { HttpHeaders } from "@angular/common/http";
+import { Injectable } from '@angular/core';
+import { plainToClass } from 'class-transformer';
+import { Observable, Subject, throwError } from 'rxjs';
+import { map, takeUntil, tap } from 'rxjs/operators';
+import { RequestOptionsModel } from '../models';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../authentication/auth.service";
+import * as i3 from ".";
+import * as i4 from "@angular/router";
+export class RequestHandlerService {
+    constructor(http, authService, environmentService, utilityService, bbsfTranslateService, router) {
+        this.http = http;
+        this.authService = authService;
+        this.environmentService = environmentService;
+        this.utilityService = utilityService;
+        this.bbsfTranslateService = bbsfTranslateService;
+        this.router = router;
+        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;
+            }
+        });
+    }
+    getLuckyNumber() {
+        return Observable.create((subject) => {
+            setInterval(() => {
+                const number = Math.floor(Math.random() * 10);
+                console.log(number);
+                subject.next(number);
+            }, 1000);
+        }).pipe(takeUntil(this.onDestroy$));
+    }
+    get(Url, params, responseType, requestOptions) {
+        if (requestOptions)
+            this.requestOptions = requestOptions;
+        let headers = this.getHeaders();
+        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();
+        }, error => {
+            if (!this.requestOptions.disableErrorHandler)
+                this.handleError(error);
+        }), map((data) => {
+            if (this.requestOptions.castResponsetoClass)
+                return plainToClass(responseType, data, { excludeExtraneousValues: true });
+            else
+                return data;
+        }));
+    }
+    post(Url, model, responseType, params, requestOptions) {
+        if (requestOptions)
+            this.requestOptions = requestOptions;
+        let headers = this.getHeaders();
+        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();
+        }, error => {
+            if (!this.requestOptions.disableErrorHandler)
+                this.handleError(error);
+        }), map((data) => {
+            if (this.requestOptions.castResponsetoClass)
+                return plainToClass(responseType, data, { excludeExtraneousValues: true });
+            else
+                return data;
+        }));
+    }
+    delete(Url, deletedId, requestOptions, responseType, params) {
+        if (requestOptions)
+            this.requestOptions = requestOptions;
+        let headers = this.getHeaders();
+        if (!this.requestOptions.disableBlockUI)
+            this.utilityService.startBlockUI();
+        return this.http.delete(this.environmentService.getApiUrl() + Url + `/${deletedId}`, { headers: headers, params: params }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+            if (!this.requestOptions.disableBlockUI)
+                this.utilityService.stopBlockUI();
+        }, error => {
+            if (!this.requestOptions.disableErrorHandler)
+                this.handleError(error);
+        }), map((data) => {
+            if (this.requestOptions.castResponsetoClass)
+                return plainToClass(responseType, data, { excludeExtraneousValues: true });
+            else
+                return data;
+        }));
+    }
+    put(Url, model, params, responseType, requestOptions) {
+        if (requestOptions)
+            this.requestOptions = requestOptions;
+        let headers = this.getHeaders();
+        if (!this.requestOptions.disableBlockUI)
+            this.utilityService.startBlockUI();
+        return this.http.put(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();
+        }, error => {
+            if (!this.requestOptions.disableErrorHandler)
+                this.handleError(error);
+        }), map((data) => {
+            if (this.requestOptions.castResponsetoClass)
+                return plainToClass(responseType, data, { excludeExtraneousValues: true });
+            else
+                return data;
+        }));
+    }
+    patch(Url, model, responseType, params, requestOptions) {
+        if (requestOptions)
+            this.requestOptions = requestOptions;
+        let headers = new HttpHeaders({
+            'Content-Type': 'application/json',
+            'Authorization': this.authService.authorizationHeaderValue(),
+        });
+        this.currentLanguage = localStorage.getItem('language');
+        headers = headers.set('Accept-Language', this.currentLanguage.toString());
+        headers = headers.set('ignore-cookies', 'true');
+        if (!this.requestOptions.disableBlockUI)
+            this.utilityService.startBlockUI();
+        return this.http.patch(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();
+        }, error => {
+            if (!this.requestOptions.disableErrorHandler)
+                this.handleError(error);
+        }), map((data) => {
+            if (this.requestOptions.castResponsetoClass)
+                return plainToClass(responseType, data, { excludeExtraneousValues: true });
+            else
+                return data;
+        }));
+    }
+    download(Url, params, requestOptions) {
+        if (requestOptions)
+            this.requestOptions = requestOptions;
+        let headers = this.getHeaders();
+        if (!this.requestOptions.disableBlockUI)
+            this.utilityService.startBlockUI();
+        return this.http.get(this.environmentService.getApiUrl() + Url, { headers: headers, params: params, responseType: this.requestOptions.responseType }).pipe(takeUntil(this.onDestroy$), tap((result) => {
+            if (!this.requestOptions.disableBlockUI)
+                this.utilityService.stopBlockUI();
+        }, error => {
+            if (!this.requestOptions.disableErrorHandler)
+                this.handleError(error);
+        }));
+    }
+    destroyHandler() {
+        this.onDestroy$.next();
+    }
+    ngOnDestroy() {
+        console.log("clearInterval");
+        this.destroyHandler();
+    }
+    handleError(err) {
+        var isEnglish = this.utilityService.getCurrentLanguage() == "en";
+        if (err.error instanceof ErrorEvent) {
+            this.utilityService.notifyErrorMessage();
+        }
+        else {
+            if (err.status == 400)
+                throwError(err); //error 400 is thrown to be catch by the Form component to handle Fluent validation errors
+            else if (err.status == 401)
+                this.router.navigate(["/Admin/account/login"]);
+            else if (err.status == 403)
+                this.utilityService.notifyErrorMessage(isEnglish ? "Sorry, You're not authorized to access this action" : "عذرا ليس لديك الصلاحيه لهذا الطلب");
+            else if (err.status == 510)
+                this.utilityService.notifyErrorMessage(isEnglish ? "Can not delete this item as it is related to others" : "لا يمكن حذف هذا العنصر لأنه مرتبط بعناصر أخرى");
+            else if (err.status == 515)
+                this.utilityService.notifyErrorMessage((err.error ? err.error.Message : err.message));
+            else {
+                console.log(`error message is: ${err.error ? err.error.Message : err.message}`);
+                this.utilityService.notifyErrorMessage(this.utilityService.getResourceValue("ErrorMassage"));
+            }
+        }
+        this.utilityService.stopBlockUI();
+    }
+    getHeaders() {
+        return new HttpHeaders({
+            'Content-Type': 'application/json',
+            'Authorization': this.authService.authorizationHeaderValue(),
+            'Client-Local-Time-Zone': Intl.DateTimeFormat().resolvedOptions().timeZone,
+            'Accept-Language': localStorage.getItem('language'),
+            'ignore-cookies': 'true'
+        });
+    }
+}
+RequestHandlerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: RequestHandlerService, deps: [{ token: i1.HttpClient }, { token: i2.AuthService }, { token: i3.EnvironmentService }, { token: i3.UtilityService }, { token: i3.BBSFTranslateService }, { token: i4.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: i2.AuthService }, { type: i3.EnvironmentService }, { type: i3.UtilityService }, { type: i3.BBSFTranslateService }, { type: i4.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"request-handler.service.js","sourceRoot":"","sources":["../../../../../../projects/bbsf-utilities/src/lib/shared/services/request-handler.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpErrorResponse, HttpHeaders, HttpParams } from \"@angular/common/http\";\r\nimport { Injectable, OnDestroy } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\nimport { plainToClass } from 'class-transformer';\r\nimport { Observable, Subject, throwError } from 'rxjs';\r\nimport { map, takeUntil, tap } from 'rxjs/operators';\r\nimport { BBSFTranslateService, EnvironmentService, UtilityService } from \".\";\r\nimport { AuthService } from '../authentication/auth.service';\r\nimport { RequestOptionsModel } from '../models';\r\n\r\n@Injectable()\r\nexport class RequestHandlerService implements OnDestroy {\r\n\r\n  private requestOptions: RequestOptionsModel = new RequestOptionsModel();\r\n  private currentLanguage = \"\";\r\n  public onDestroy$: Subject<void> = new Subject<void>();\r\n\r\n  constructor(\r\n    private http: HttpClient,\r\n    private authService: AuthService,\r\n    private environmentService: EnvironmentService,\r\n    private utilityService: UtilityService,\r\n    private bbsfTranslateService: BBSFTranslateService,\r\n    private router: Router\r\n  ) {\r\n    //using localStorage  to avoid call getCurrentLanguage() because it is not all to use async in constructor\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  public getLuckyNumber(): Observable<number> {\r\n    return Observable.create((subject: Subject<number>) => {\r\n      setInterval(() => {\r\n        const number = Math.floor(Math.random() * 10);\r\n        console.log(number)\r\n        subject.next(number);\r\n      }, 1000);\r\n    }).pipe(takeUntil(this.onDestroy$));\r\n  }\r\n\r\n  get<T>(Url: string, params?: HttpParams, responseType?: new () => T, requestOptions?: RequestOptionsModel): Observable<T> {\r\n    if (requestOptions)\r\n      this.requestOptions = requestOptions;\r\n\r\n    let headers = this.getHeaders();\r\n    if (!this.requestOptions.disableBlockUI)\r\n      this.utilityService.startBlockUI();\r\n    return this.http.get<T>(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      }, error => {\r\n        if (!this.requestOptions.disableErrorHandler)\r\n          this.handleError(error);\r\n      }), map((data: T) => {\r\n        if (this.requestOptions.castResponsetoClass)\r\n          return plainToClass(responseType, data, { excludeExtraneousValues: true });\r\n        else\r\n          return data;\r\n      })\r\n    ) as Observable<T>;\r\n  }\r\n\r\n  post<T>(Url: string, model?: any, responseType?: new () => T, params?: HttpParams, requestOptions?: RequestOptionsModel): Observable<T> {\r\n    if (requestOptions)\r\n      this.requestOptions = requestOptions;\r\n    let headers = this.getHeaders();\r\n    if (!this.requestOptions.disableBlockUI)\r\n      this.utilityService.startBlockUI();\r\n    return this.http.post<T>(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      }, error => {\r\n        if (!this.requestOptions.disableErrorHandler)\r\n          this.handleError(error);\r\n      }), map((data: T) => {\r\n        if (this.requestOptions.castResponsetoClass)\r\n          return plainToClass(responseType, data, { excludeExtraneousValues: true });\r\n        else\r\n          return data;\r\n      })\r\n    );\r\n  }\r\n\r\n  delete<T>(Url: string, deletedId: string, requestOptions?: RequestOptionsModel, responseType?: new () => T, params?: HttpParams): Observable<T> {\r\n    if (requestOptions)\r\n      this.requestOptions = requestOptions;\r\n\r\n    let headers = this.getHeaders();\r\n    if (!this.requestOptions.disableBlockUI)\r\n      this.utilityService.startBlockUI();\r\n    return this.http.delete<T>(this.environmentService.getApiUrl() + Url + `/${deletedId}`, { 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      }, error => {\r\n        if (!this.requestOptions.disableErrorHandler)\r\n          this.handleError(error);\r\n      }), map((data: T) => {\r\n        if (this.requestOptions.castResponsetoClass)\r\n          return plainToClass(responseType, data, { excludeExtraneousValues: true });\r\n        else\r\n          return data;\r\n      })\r\n    );\r\n  }\r\n\r\n  put<T>(Url: string, model?: any, params?: HttpParams, responseType?: new () => T, requestOptions?: RequestOptionsModel): Observable<T> {\r\n    if (requestOptions)\r\n      this.requestOptions = requestOptions;\r\n\r\n    let headers = this.getHeaders();\r\n    if (!this.requestOptions.disableBlockUI)\r\n      this.utilityService.startBlockUI();\r\n    return this.http.put<T>(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      }, error => {\r\n        if (!this.requestOptions.disableErrorHandler)\r\n          this.handleError(error);\r\n      }), map((data: T) => {\r\n        if (this.requestOptions.castResponsetoClass)\r\n          return plainToClass(responseType, data, { excludeExtraneousValues: true });\r\n        else\r\n          return data;\r\n      })\r\n    );\r\n  }\r\n\r\n  patch<T>(Url: string, model?: any, responseType?: new () => T, params?: HttpParams, requestOptions?: RequestOptionsModel): Observable<T> {\r\n    if (requestOptions)\r\n      this.requestOptions = requestOptions;\r\n\r\n    let headers = new HttpHeaders({\r\n      'Content-Type': 'application/json',\r\n      'Authorization': this.authService.authorizationHeaderValue(),\r\n\r\n    });\r\n    this.currentLanguage = localStorage.getItem('language');\r\n    headers = headers.set('Accept-Language', this.currentLanguage.toString());\r\n    headers = headers.set('ignore-cookies', 'true');\r\n    if (!this.requestOptions.disableBlockUI)\r\n      this.utilityService.startBlockUI();\r\n\r\n    return this.http.patch<T>(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      }, error => {\r\n        if (!this.requestOptions.disableErrorHandler)\r\n          this.handleError(error);\r\n      }), map((data: T) => {\r\n        if (this.requestOptions.castResponsetoClass)\r\n          return plainToClass(responseType, data, { excludeExtraneousValues: true })\r\n        else\r\n          return data;\r\n      })\r\n    );\r\n  }\r\n\r\n  download<T>(Url: string, params?: HttpParams, requestOptions?: RequestOptionsModel): Observable<T> {\r\n    if (requestOptions)\r\n      this.requestOptions = requestOptions;\r\n\r\n    let headers = this.getHeaders();\r\n    if (!this.requestOptions.disableBlockUI)\r\n      this.utilityService.startBlockUI();\r\n    return this.http.get<T>(this.environmentService.getApiUrl() + Url, { 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      }, error => {\r\n        if (!this.requestOptions.disableErrorHandler)\r\n          this.handleError(error);\r\n      })\r\n    );\r\n  }\r\n\r\n  public destroyHandler(): void {\r\n    this.onDestroy$.next();\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    console.log(\"clearInterval\")\r\n    this.destroyHandler()\r\n  }\r\n\r\n  private handleError(err: HttpErrorResponse) {\r\n    var isEnglish = this.utilityService.getCurrentLanguage() == \"en\";\r\n    if (err.error instanceof ErrorEvent) {\r\n      this.utilityService.notifyErrorMessage()\r\n    }\r\n    else {\r\n      if (err.status == 400)\r\n        throwError(err);//error 400 is thrown to be catch by the Form component to handle Fluent validation errors\r\n      else if (err.status == 401)\r\n        this.router.navigate([\"/Admin/account/login\"])\r\n      else if (err.status == 403)\r\n        this.utilityService.notifyErrorMessage(isEnglish ? \"Sorry, You're not authorized to access this action\" : \"عذرا ليس لديك الصلاحيه لهذا الطلب\")\r\n      else if (err.status == 510)\r\n        this.utilityService.notifyErrorMessage(isEnglish ? \"Can not delete this item as it is related to others\" : \"لا يمكن حذف هذا العنصر لأنه مرتبط بعناصر أخرى\")\r\n      else if (err.status == 515)\r\n        this.utilityService.notifyErrorMessage((err.error ? err.error.Message : err.message))\r\n      else {\r\n        console.log(`error message is: ${err.error ? err.error.Message : err.message}`)\r\n        this.utilityService.notifyErrorMessage(this.utilityService.getResourceValue(\"ErrorMassage\"))\r\n      }\r\n    }\r\n    this.utilityService.stopBlockUI();\r\n  }\r\n\r\n  private getHeaders() {\r\n    return new HttpHeaders({\r\n      'Content-Type': 'application/json',\r\n      'Authorization': this.authService.authorizationHeaderValue(),\r\n      'Client-Local-Time-Zone': Intl.DateTimeFormat().resolvedOptions().timeZone,\r\n      'Accept-Language': localStorage.getItem('language'),\r\n      'ignore-cookies': 'true'\r\n    });\r\n  }\r\n\r\n}\r\n"]}

package/esm2020/lib/shared/services/styles-bundle.service.mjs

@@ -0,0 +1,55 @@
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from ".";
+export class StylesBundleService {
+    constructor(document, translateService) {
+        this.document = document;
+        this.translateService = translateService;
+    }
+    loadThemes(lang, bundleEnglishName, bundleArabicName) {
+        if (lang == "ar") {
+            this.loadStyleBundle(bundleArabicName.toString());
+            document.querySelector('html').setAttribute("b-lang", "ar"); //use b-lang instead of lang to fix firefox number inputs in Arabic locale
+            document.querySelector('html').setAttribute("dir", "rtl");
+        }
+        else {
+            this.loadStyleBundle(bundleEnglishName.toString());
+            document.querySelector('html').setAttribute("b-lang", "en");
+            document.querySelector('html').setAttribute("dir", "ltr");
+        }
+    }
+    loadThemesColor(theme, bundleDarkName, bundleLightName) {
+        if (theme == "Light")
+            this.loadStyleBundle(bundleLightName.toString());
+        else
+            this.loadStyleBundle(bundleDarkName.toString());
+    }
+    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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: StylesBundleService, deps: [{ token: DOCUMENT }, { token: i1.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: i1.BBSFTranslateService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/services/translate.service.mjs

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

package/esm2020/lib/shared/services/translation-resolver.service.mjs

@@ -0,0 +1,7 @@
+import { inject } from "@angular/core";
+import { BBSFTranslateService } from ".";
+export const TranslationResolverService = () => {
+    let translateService = inject(BBSFTranslateService);
+    return translateService.getTranslation(translateService.currentLang);
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNsYXRpb24tcmVzb2x2ZXIuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Jic2YtdXRpbGl0aWVzL3NyYy9saWIvc2hhcmVkL3NlcnZpY2VzL3RyYW5zbGF0aW9uLXJlc29sdmVyLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV2QyxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxHQUFHLENBQUM7QUFFekMsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQW1CLEdBQUcsRUFBRTtJQUM3RCxJQUFJLGdCQUFnQixHQUFHLE1BQU0sQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO0lBQ3BELE9BQU8sZ0JBQWdCLENBQUMsY0FBYyxDQUFDLGdCQUFnQixDQUFDLFdBQVcsQ0FBQyxDQUFDO0FBQ3ZFLENBQUMsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluamVjdCB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IFJlc29sdmVGbiB9IGZyb20gXCJAYW5ndWxhci9yb3V0ZXJcIjtcclxuaW1wb3J0IHsgQkJTRlRyYW5zbGF0ZVNlcnZpY2UgfSBmcm9tIFwiLlwiO1xyXG5cclxuZXhwb3J0IGNvbnN0IFRyYW5zbGF0aW9uUmVzb2x2ZXJTZXJ2aWNlOiBSZXNvbHZlRm48YW55PiA9ICgpID0+IHtcclxuICBsZXQgdHJhbnNsYXRlU2VydmljZSA9IGluamVjdChCQlNGVHJhbnNsYXRlU2VydmljZSk7XHJcbiAgcmV0dXJuIHRyYW5zbGF0ZVNlcnZpY2UuZ2V0VHJhbnNsYXRpb24odHJhbnNsYXRlU2VydmljZS5jdXJyZW50TGFuZyk7XHJcbn0iXX0=

package/esm2020/lib/shared/services/utility.service.mjs

@@ -0,0 +1,87 @@
+import { __decorate } from "tslib";
+import { Injectable } from '@angular/core';
+import { BlockUI } from 'ng-block-ui';
+import { ToastrService } from 'ngx-toastr';
+import * as i0 from "@angular/core";
+import * as i1 from ".";
+export class UtilityService {
+    constructor(translator, environmentService, injector) {
+        this.translator = translator;
+        this.environmentService = environmentService;
+        this.injector = injector;
+        this.isCreatedBefore = false;
+    }
+    getResourceValue(Key) {
+        let ResourceValue = this.translator.instant(Key);
+        return ResourceValue;
+    }
+    getCurrentLanguage() {
+        let currentLanguage = this.environmentService.getDefaultLanguage();
+        let lang = localStorage.getItem('language');
+        if (lang)
+            currentLanguage = lang;
+        else
+            localStorage.setItem('language', currentLanguage);
+        return currentLanguage;
+    }
+    isCurrentLanguageEnglish() {
+        return this.getCurrentLanguage() == "en";
+    }
+    isCurrentLanguageArabic() {
+        return this.getCurrentLanguage() == "ar";
+    }
+    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);
+    }
+    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);
+    }
+    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);
+    }
+    startBlockUI() {
+        this.blockUI.start();
+    }
+    stopBlockUI() {
+        this.blockUI.stop();
+    }
+}
+UtilityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: UtilityService, deps: [{ token: i1.BBSFTranslateService }, { token: i1.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: i1.BBSFTranslateService }, { type: i1.EnvironmentService }, { type: i0.Injector }]; }, propDecorators: { blockUI: [] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/shared/services/word-document.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { generateContainer as GenerateDOCX } from '../config/word/index';
+import * as i0 from "@angular/core";
+export class WordDocumentService {
+    async generateWordByteFile(model) {
+        let documentOptions = {};
+        if (model.options.isLandscape)
+            documentOptions.orientation = 'landscape';
+        documentOptions.pageSize = {
+            width: model.options.pageWidth * 15,
+            height: model.options.pageHeight * 15,
+        };
+        documentOptions.margins = {
+            top: model.options.top * 15,
+            right: model.options.right * 15,
+            bottom: model.options.bottom * 15,
+            left: model.options.left * 15,
+            header: model.options.top * 15 * 2,
+            footer: model.options.bottom * 15 * 2,
+            gutter: 0,
+        };
+        documentOptions.footer = true;
+        documentOptions.header = true;
+        documentOptions.pageNumber = model.options.showPaging;
+        documentOptions.table = { row: { cantSplit: true } };
+        var fileBuffer = await GenerateDOCX(model.body, model.header, documentOptions, model.footer);
+        return fileBuffer;
+    }
+}
+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',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/public-api.mjs

@@ -0,0 +1,30 @@
+/*
+ * Public API Surface of @bnsights/bbsf-utilities
+ */
+//Module
+export * from './lib/bbsf-utilities.module';
+//#region services
+export * from './lib/shared/services/utility.service';
+export * from './lib/shared/services/environment.service';
+export * from './lib/shared/services/request-handler.service';
+export * from './lib/shared/services/styles-bundle.service';
+export * from './lib/shared/services/translate.service';
+export * from './lib/shared/services/control-validation.service';
+export * from './lib/shared/services/master-layout.service';
+export * from './lib/shared/services/translation-resolver.service';
+export * from './lib/shared/services/appearance-configuration.service';
+export * from './lib/shared/services/configuration.service';
+export * from './lib/shared/services/word-document.service';
+export * from './lib/shared/authentication/auth.service';
+//#endregion
+//#region config
+export * from './lib/shared/config/environment';
+//#endregion
+//#region models 
+export * from './lib/shared/models/request-options-model';
+export * from './lib/shared/models/word-document-model';
+//#endregion
+//#region export enums
+export * from './lib/shared/enums/authentication-modes-enums';
+//#endregion
+//# sourceMappingURL=data:application/json;base64,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