verben-authentication-ui 1.0.13 → 1.0.15

package/fesm2022/verben-authentication-ui-src-lib-pipes.mjs

@@ -0,0 +1,32 @@
+import * as i0 from '@angular/core';
+import { Pipe } from '@angular/core';
+import { of, from } from 'rxjs';
+import * as i1 from 'verben-authentication-ui/src/lib/services';
+
+class AsyncLabelPipe {
+    labelService;
+    constructor(labelService) {
+        this.labelService = labelService;
+    }
+    transform(code, entity, labelProp, env, key = 'Code') {
+        if (!code)
+            return of('');
+        return from(this.labelService.getAsyncLabelWithRequestTracking(code, entity, labelProp, env, key));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AsyncLabelPipe, deps: [{ token: i1.LabelService }], target: i0.ɵɵFactoryTarget.Pipe });
+    static ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: AsyncLabelPipe, isStandalone: true, name: "asyncLabel" });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AsyncLabelPipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'asyncLabel',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.LabelService }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AsyncLabelPipe };
+//# sourceMappingURL=verben-authentication-ui-src-lib-pipes.mjs.map

package/fesm2022/verben-authentication-ui-src-lib-pipes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verben-authentication-ui-src-lib-pipes.mjs","sources":["../../../projects/verben-authentication-ui/src/lib/pipes/async-label.pipe.ts","../../../projects/verben-authentication-ui/src/lib/pipes/verben-authentication-ui-src-lib-pipes.ts"],"sourcesContent":["import { Pipe, PipeTransform } from '@angular/core';\nimport { from, Observable, of } from 'rxjs';\nimport { LabelService } from 'verben-authentication-ui/src/lib/services';\n\n@Pipe({\n  name: 'asyncLabel',\n  standalone: true,\n})\nexport class AsyncLabelPipe implements PipeTransform {\n  constructor(private labelService: LabelService) {}\n\n  transform(\n    code: any,\n    entity: string,\n    labelProp: string,\n    env: string,\n    key: string = 'Code'\n  ): Observable<string> {\n    if (!code) return of('');\n    return from(\n      this.labelService.getAsyncLabelWithRequestTracking(\n        code,\n        entity,\n        labelProp,\n        env,\n        key\n      )\n    );\n  }\n}\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './index';\n"],"names":[],"mappings":";;;;;MAQa,cAAc,CAAA;AACL,IAAA,YAAA,CAAA;AAApB,IAAA,WAAA,CAAoB,YAA0B,EAAA;QAA1B,IAAY,CAAA,YAAA,GAAZ,YAAY,CAAc;KAAI;IAElD,SAAS,CACP,IAAS,EACT,MAAc,EACd,SAAiB,EACjB,GAAW,EACX,GAAA,GAAc,MAAM,EAAA;AAEpB,QAAA,IAAI,CAAC,IAAI;AAAE,YAAA,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;AACzB,QAAA,OAAO,IAAI,CACT,IAAI,CAAC,YAAY,CAAC,gCAAgC,CAChD,IAAI,EACJ,MAAM,EACN,SAAS,EACT,GAAG,EACH,GAAG,CACJ,CACF,CAAC;KACH;wGApBU,cAAc,EAAA,IAAA,EAAA,CAAA,EAAA,KAAA,EAAA,EAAA,CAAA,YAAA,EAAA,CAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,IAAA,EAAA,CAAA,CAAA;sGAAd,cAAc,EAAA,YAAA,EAAA,IAAA,EAAA,IAAA,EAAA,YAAA,EAAA,CAAA,CAAA;;4FAAd,cAAc,EAAA,UAAA,EAAA,CAAA;kBAJ1B,IAAI;AAAC,YAAA,IAAA,EAAA,CAAA;AACJ,oBAAA,IAAI,EAAE,YAAY;AAClB,oBAAA,UAAU,EAAE,IAAI;AACjB,iBAAA,CAAA;;;ACPD;;AAEG;;;;"}

package/fesm2022/verben-authentication-ui-src-lib-services.mjs

@@ -0,0 +1,610 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Optional, Inject } from '@angular/core';
+import CryptoJS from 'crypto-js';
+import { ErrorResponse, ObjectState, SearchOperator, SearchPropertySign } from 'verben-authentication-ui/src/lib/models';
+import * as i1 from '@angular/common/http';
+import * as i3 from 'verben-ng-ui';
+import { UTIL_SERVICE } from 'verben-ng-ui';
+
+const AUTHORIZATION_CONFIG = new InjectionToken('authorization_config');
+class AuthorizationService {
+    auth;
+    constructor(auth) {
+        this.auth = auth;
+    }
+    get authorizationConfig() {
+        return this.auth ? this.auth : [];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthorizationService, deps: [{ token: AUTHORIZATION_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthorizationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AuthorizationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [AUTHORIZATION_CONFIG]
+                }] }] });
+
+// In your library's services/environment.service.ts
+// import { ENVIRONMENT } from '../models/ENVIRONMENT_TOKEN';
+const ENVIRONMENT = new InjectionToken('environment');
+class EnvironmentService {
+    env;
+    constructor(env) {
+        this.env = env;
+    }
+    get environment() {
+        return this.env;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EnvironmentService, deps: [{ token: ENVIRONMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EnvironmentService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EnvironmentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }] });
+
+class EncryptionService {
+    envSvc;
+    isProd;
+    ivString;
+    keyString;
+    constructor(envSvc) {
+        this.envSvc = envSvc;
+        this.ivString = this.envSvc.environment.IvString;
+        this.keyString = this.envSvc.environment.keyString;
+        this.isProd = this.envSvc.environment.production;
+    }
+    encryptData(data) {
+        try {
+            const encrypted = CryptoJS.AES.encrypt(data, CryptoJS.enc.Utf8.parse(this.keyString), {
+                iv: CryptoJS.enc.Utf8.parse(this.ivString),
+            });
+            // Return the encrypted data as a string
+            return encrypted.toString();
+        }
+        catch (error) {
+            console.error('Encryption error:', error);
+            return data; // Return original data if encryption fails
+        }
+    }
+    decryptData(data) {
+        try {
+            // Decrypt the data
+            const decrypted = CryptoJS.AES.decrypt(data, CryptoJS.enc.Utf8.parse(this.keyString), {
+                iv: CryptoJS.enc.Utf8.parse(this.ivString),
+            });
+            // Convert the decrypted data to a UTF-8 string
+            return decrypted.toString(CryptoJS.enc.Utf8);
+        }
+        catch (error) {
+            console.error('Decryption error:', error);
+            return data; // Return original data if decryption fails
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EncryptionService, deps: [{ token: EnvironmentService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EncryptionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EncryptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: EnvironmentService }] });
+
+class HttpWebRequestService {
+    http;
+    envSvc;
+    notificationService;
+    isProd;
+    constructor(http, envSvc, notificationService) {
+        this.http = http;
+        this.envSvc = envSvc;
+        this.notificationService = notificationService;
+        this.isProd = this.envSvc.environment.production;
+    }
+    buildHeaders() {
+        return {
+            'Content-Type': 'application/json',
+            Authorization: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJNYWlsQWRkcmVzcyI6InZlcmJlbmFAZ21haWwuY29tIiwiQXBwbGljYXRpb24iOiIiLCJOYW1lIjoiVmVyYmVuYSBMb2dpYyBMaW1pdGVkIiwiUm9sZUlEIjoiUk9MLVpYQVhYVCIsIlRlbmFudElkIjoiUERMVEM2IiwiU2VydmljZU5hbWUiOiJXaGl0ZTM2MCIsIkNvbXBhbnkiOiJDT00tNkxJNjNIIiwibmJmIjoxNzQ3MTMxNTk1LCJleHAiOjE3NDczNDc1OTUsImlhdCI6MTc0NzEzMTU5NX0.X-5xj31h2ON268n1sTq6eFhphsiZ1k9JhkJ91R2-PKI',
+        };
+    }
+    buildUrl(url, baseUrl) {
+        return `${baseUrl}/${url}`;
+    }
+    handleError(err) {
+        const msg = err?.ErrorMsg ||
+            err?.errors?.values?.toString() ||
+            `Error occurred`;
+        this.notificationService.error(msg, { timeout: 10000 });
+        return new ErrorResponse(msg);
+    }
+    request(method, url, body, baseUrl = this.envSvc.environment.AuthenticationAPI) {
+        const options = {
+            headers: this.buildHeaders(),
+        };
+        const requestUrl = this.buildUrl(url, baseUrl);
+        switch (method) {
+            case 'GET':
+                return new Promise((resolve) => this.http.get(requestUrl, options).subscribe({
+                    next: resolve,
+                    error: (err) => resolve(this.handleError(err)),
+                }));
+            case 'POST':
+                return new Promise((resolve) => this.http.post(requestUrl, body, options).subscribe({
+                    next: resolve,
+                    error: (err) => resolve(this.handleError(err)),
+                }));
+            case 'PUT':
+                return this.http.put(requestUrl, body, options);
+            case 'DELETE':
+                return this.http.delete(requestUrl, options);
+        }
+    }
+    get(url, baseUrl) {
+        return this.request('GET', url, undefined, baseUrl);
+    }
+    post(url, body, baseUrl) {
+        return this.request('POST', url, JSON.stringify(body), baseUrl);
+    }
+    postFile(url, formData, baseUrl) {
+        return new Promise((resolve) => this.http
+            .post(this.buildUrl(url, baseUrl || this.envSvc.environment.AuthenticationAPI), formData)
+            .subscribe({
+            next: resolve,
+            error: (err) => resolve(this.handleError(err)),
+        }));
+    }
+    put(url, body, baseUrl) {
+        return this.request('PUT', url, body, baseUrl);
+    }
+    delete(url, baseUrl) {
+        return this.request('DELETE', url, undefined, baseUrl);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HttpWebRequestService, deps: [{ token: i1.HttpClient }, { token: EnvironmentService }, { token: i3.NotificationService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HttpWebRequestService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HttpWebRequestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: EnvironmentService }, { type: i3.NotificationService }] });
+
+class UtilService {
+    parentUtilService;
+    constructor(parentUtilService) {
+        this.parentUtilService = parentUtilService;
+    }
+    sendBI(state) {
+        if (this.parentUtilService && this.parentUtilService.sendBI) {
+            this.parentUtilService.sendBI(state);
+        }
+        else {
+            console.warn('Util Service is not provided');
+        }
+    }
+    showInfo(message) {
+        if (this.parentUtilService && this.parentUtilService.showInfo) {
+            this.parentUtilService.showInfo(message);
+        }
+        else {
+            console.warn('Util Service is not provided');
+        }
+    }
+    showSuccess(message) {
+        if (this.parentUtilService && this.parentUtilService.showSuccess) {
+            this.parentUtilService.showSuccess(message);
+        }
+        else {
+            console.warn('Util Service is not provided');
+        }
+    }
+    showError(message) {
+        if (this.parentUtilService && this.parentUtilService.showError) {
+            this.parentUtilService.showError(message);
+        }
+        else {
+            console.warn('Util Service is not provided');
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UtilService, deps: [{ token: UTIL_SERVICE, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UtilService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: UtilService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [UTIL_SERVICE]
+                }] }] });
+
+class ImportService {
+    utilService;
+    server;
+    constructor(utilService, server //private cdr: ChangeDetectorRef
+    ) {
+        this.utilService = utilService;
+        this.server = server;
+    }
+    // onComplete(
+    //   event: any[],
+    //   defaults: T,
+    //   endpoint: string | null,
+    //   baseUrl: string,
+    //   dataRef: T[],
+    //   cardDataRef: CardData[],
+    //   pagedState: PagedResult<T> | null = null,
+    //   stringProps: (keyof T)[] = []
+    // ) {
+    //   const normalized = event.map((raw) => {
+    //     const def = defaults;
+    //     let merged: T = {
+    //       ...def,
+    //       ...raw,
+    //       Code: raw.Code ? String(raw.Code) : '',
+    //     };
+    //     stringProps.forEach((key) => {
+    //       const value = raw[key];
+    //       merged[key] = value != null ? String(value) : ('' as any);
+    //     });
+    //     const dateProps: (keyof T)[] = ['CreatedAt', 'UpdatedAt'];
+    //     dateProps.forEach((key) => {
+    //       const val = merged[key];
+    //       let dateObj: Date;
+    //       if (val instanceof Date) {
+    //         dateObj = val;
+    //       } else if (typeof val === 'number') {
+    //         dateObj = this.excelSerialToDate(val);
+    //       } else if (typeof val === 'string') {
+    //         dateObj = new Date(val);
+    //       } else {
+    //         dateObj = new Date();
+    //       }
+    //       if (isNaN(dateObj.getTime())) {
+    //         dateObj = new Date();
+    //       }
+    //       merged[key] = dateObj.toISOString() as any;
+    //     });
+    //     return merged;
+    //   });
+    //   if (normalized && normalized.length > 0) {
+    //     this.saveImportedDataBatch(
+    //       normalized,
+    //       endpoint,
+    //       baseUrl,
+    //       dataRef,
+    //       cardDataRef,
+    //       pagedState
+    //     );
+    //   }
+    // }
+    // async saveImportedDataBatch(
+    //   items: T[],
+    //   endpoint: string | null,
+    //   baseUrl: string,
+    //   dataRef: T[],
+    //   cardDataRef: CardData[],
+    //   pagedState: PagedResult<T> | null = null
+    // ) {
+    //   if (!items?.length) return;
+    //   const preparedItems = items.map((item) => ({
+    //     ...item,
+    //     DataState: ObjectState.New,
+    //     Id: '',
+    //   }));
+    //   if (!endpoint) {
+    //     preparedItems.forEach((srv, idx) => {
+    //       const newItem = {
+    //         ...srv,
+    //         Id: dataRef.length.toString(),
+    //         id: dataRef.length.toString(),
+    //       };
+    //       const cardData: CardData = {
+    //         selected: false,
+    //         title: newItem.Id.toString(),
+    //         data: newItem,
+    //         body: [],
+    //         children: [],
+    //       };
+    //       dataRef.push(newItem);
+    //       cardDataRef.push(cardData);
+    //       if (pagedState) {
+    //         pagedState.Skip += 1;
+    //       }
+    //     });
+    //     return;
+    //   }
+    //   this.utilService.sendBI(true);
+    //   const res = await this.server.post(endpoint, preparedItems, baseUrl);
+    //   this.utilService.sendBI(false);
+    //   if (res instanceof ErrorResponse) {
+    //     return;
+    //   } else {
+    //     this.utilService.showSuccess('Operation Account saved successfully');
+    //     const result = res as T[];
+    //     result.forEach((srv, idx) => {
+    //       const newItem = {
+    //         ...srv,
+    //         Id: srv.Code,
+    //         id: srv.Code,
+    //       };
+    //       const cardData: CardData = {
+    //         selected: false,
+    //         title: newItem.Id.toString(),
+    //         data: newItem,
+    //         body: [],
+    //         children: [],
+    //       };
+    //       dataRef.push(newItem);
+    //       // this.cdr.detectChanges();
+    //       cardDataRef.push(cardData);
+    //       if (pagedState) {
+    //         pagedState.Skip += 1;
+    //       }
+    //     });
+    //   }
+    // }
+    onComplete(event, defaults, endpoint, baseUrl, entity, updateCallback, pagedState = null, stringProps = [], numberProps = [], datePropsExtras = []) {
+        const normalized = event.map((raw) => {
+            const def = defaults;
+            let merged = {
+                ...def,
+                ...raw,
+                Code: raw.Code ? String(raw.Code) : '',
+            };
+            stringProps.forEach((key) => {
+                const value = raw[key];
+                merged[key] = value != null ? String(value) : '';
+            });
+            numberProps.forEach((key) => {
+                const value = raw[key];
+                if (typeof value === 'string') {
+                    // Only parse if it's a valid number
+                    const num = value === '' || isNaN(Number(value)) ? 0 : Number(value);
+                    merged[key] = num;
+                }
+                else {
+                    merged[key] = value;
+                }
+            });
+            const dateProps = ['CreatedAt', 'UpdatedAt'].concat(datePropsExtras);
+            dateProps.forEach((key) => {
+                const val = merged[key];
+                let dateObj;
+                if (val instanceof Date) {
+                    dateObj = val;
+                }
+                else if (typeof val === 'number') {
+                    dateObj = this.excelSerialToDate(val);
+                }
+                else if (typeof val === 'string') {
+                    dateObj = new Date(val);
+                }
+                else {
+                    dateObj = new Date();
+                }
+                if (isNaN(dateObj.getTime())) {
+                    dateObj = new Date();
+                }
+                merged[key] = dateObj.toISOString();
+            });
+            return merged;
+        });
+        if (normalized && normalized.length > 0) {
+            this.saveImportedDataBatch(normalized, endpoint, baseUrl, entity, updateCallback, pagedState);
+        }
+    }
+    async saveImportedDataBatch(items, endpoint, baseUrl, entity, updateCallback, pagedState = null) {
+        if (!items?.length)
+            return;
+        const preparedItems = items.map((item) => ({
+            ...item,
+            DataState: ObjectState.New,
+            Id: '',
+        }));
+        if (!endpoint) {
+            preparedItems.forEach((srv, idx) => {
+                srv.Id = `UPLOAD ${idx}`;
+                srv.id = `UPLOAD ${idx}`;
+            });
+            updateCallback(preparedItems);
+            if (pagedState) {
+                pagedState.Skip += preparedItems.length;
+            }
+            return;
+        }
+        this.utilService.sendBI(true);
+        const res = await this.server.post(endpoint, preparedItems, baseUrl);
+        this.utilService.sendBI(false);
+        if (res instanceof ErrorResponse) {
+            return;
+        }
+        else {
+            this.utilService.showSuccess(`${entity} upload successful`);
+            const result = res;
+            result.forEach((srv, idx) => {
+                srv.Id = srv.Code;
+                srv.id = srv.Code;
+                // const newItem = {
+                //   ...srv,
+                //   Id: srv.Code,
+                //   id: srv.Code,
+                // };
+                // const cardData: CardData = {
+                //   selected: false,
+                //   title: newItem.Id.toString(),
+                //   data: newItem,
+                //   body: [],
+                //   children: [],
+                // };
+            });
+            updateCallback(result);
+            if (pagedState) {
+                pagedState.Skip += result.length;
+            }
+        }
+    }
+    excelSerialToDate(serial) {
+        1;
+        const excelEpoch = new Date(Date.UTC(1899, 11, 30));
+        const millisPerDay = 24 * 60 * 60 * 1000;
+        return new Date(excelEpoch.getTime() + serial * millisPerDay);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ImportService, deps: [{ token: UtilService }, { token: HttpWebRequestService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ImportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ImportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: UtilService }, { type: HttpWebRequestService }] });
+
+class LabelService {
+    utilService;
+    server;
+    cache = new Map();
+    inFlightRequests = new Map();
+    constructor(utilService, server) {
+        this.utilService = utilService;
+        this.server = server;
+    }
+    async getAsyncLabel(value, entity, labelProp, env, key = 'Code') {
+        const cacheKey = `${entity}_${labelProp}_${value}_${env}_${key}`;
+        if (this.cache.has(cacheKey)) {
+            const value = this.cache.get(cacheKey);
+            return value;
+        }
+        var payload = {
+            Fields: [labelProp],
+            SearchKeyValues: [
+                {
+                    PropertyName: key,
+                    EntityValue: value,
+                    Operator: SearchOperator.And,
+                    Sign: SearchPropertySign.EQ,
+                },
+            ],
+        };
+        this.utilService.sendBI(true);
+        const res = await this.server.post(`SearchDynamic${entity}/0/1`, payload, env);
+        this.utilService.sendBI(false);
+        if (res instanceof ErrorResponse) {
+            return '';
+        }
+        else {
+            const result = res.Result;
+            const label = result.length > 0 ? result[0] : value;
+            this.cache.set(cacheKey, label);
+            return label;
+        }
+    }
+    async getAsyncLabelWithRequestTracking(value, entity, labelProp, env, key = 'Code') {
+        const cacheKey = `${entity}_${labelProp}_${value}_${env}_${key}`;
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        if (this.inFlightRequests.has(cacheKey)) {
+            return this.inFlightRequests.get(cacheKey);
+        }
+        const requestPromise = (async () => {
+            const payload = {
+                Fields: [labelProp],
+                SearchKeyValues: [
+                    {
+                        PropertyName: key,
+                        EntityValue: value,
+                        Operator: SearchOperator.And,
+                        Sign: SearchPropertySign.EQ,
+                    },
+                ],
+            };
+            this.utilService.sendBI(true);
+            const res = await this.server.post(`SearchDynamic${entity}/0/1`, payload, env);
+            this.utilService.sendBI(false);
+            let label;
+            if (res instanceof ErrorResponse) {
+                label = '';
+            }
+            else {
+                const result = res.Result;
+                label = result.length > 0 ? result[0] : value;
+            }
+            this.cache.set(cacheKey, label);
+            this.inFlightRequests.delete(cacheKey);
+            return label;
+        })();
+        // Save the in-flight request
+        this.inFlightRequests.set(cacheKey, requestPromise);
+        return requestPromise;
+    }
+    async getAsyncLabelWithRequestTrackingNoGateway(value, entity, labelProp, env, controller, key = 'Code') {
+        const cacheKey = `${entity}_${labelProp}_${value}_${env}_${key}_${controller}`;
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        if (this.inFlightRequests.has(cacheKey)) {
+            return this.inFlightRequests.get(cacheKey);
+        }
+        const requestPromise = (async () => {
+            const payload = {
+                Fields: [labelProp],
+                SearchKeyValues: [
+                    {
+                        PropertyName: key,
+                        EntityValue: value,
+                        Operator: SearchOperator.And,
+                        Sign: SearchPropertySign.EQ,
+                    },
+                ],
+            };
+            this.utilService.sendBI(true);
+            const res = await this.server.post(`${controller}/SearchDynamic${entity}s/0/1`, payload, env);
+            this.utilService.sendBI(false);
+            let label;
+            if (res instanceof ErrorResponse) {
+                label = '';
+            }
+            else {
+                const result = res.Result;
+                label = result.length > 0 ? result[0] : value;
+            }
+            this.cache.set(cacheKey, label);
+            this.inFlightRequests.delete(cacheKey);
+            return label;
+        })();
+        // Save the in-flight request
+        this.inFlightRequests.set(cacheKey, requestPromise);
+        return requestPromise;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LabelService, deps: [{ token: UtilService }, { token: HttpWebRequestService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LabelService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: LabelService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: UtilService }, { type: HttpWebRequestService }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AUTHORIZATION_CONFIG, AuthorizationService, ENVIRONMENT, EncryptionService, EnvironmentService, HttpWebRequestService, ImportService, LabelService, UtilService };
+//# sourceMappingURL=verben-authentication-ui-src-lib-services.mjs.map