verben-ticketing-ui 0.6.0

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

@@ -0,0 +1,770 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, Optional } from '@angular/core';
+import { ErrorResponse, ObjectState, SearchOperator, SearchPropertySign } from 'verben-ticketing-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';
+import * as i1$1 from '@angular/router';
+import { DEFAULT_PAGE_SIZE } from 'verben-ticketing-ui/src/lib/constants';
+
+// 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.14", ngImport: i0, type: EnvironmentService, deps: [{ token: ENVIRONMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EnvironmentService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EnvironmentService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ENVIRONMENT]
+                }] }] });
+
+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() {
+        const customToken = this.envSvc.environment.Token;
+        console.log({ CustomerToken: customToken });
+        return customToken
+            ? {
+                'Content-Type': 'application/json',
+                'X-Custom-Auth': customToken,
+                Authorization: customToken,
+            }
+            : {
+                'Content-Type': 'application/json',
+                Authorization: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJNYWlsQWRkcmVzcyI6InZlcmJlbmFAZ21haWwuY29tIiwiQXBwbGljYXRpb24iOiIiLCJOYW1lIjoiVmVyYmVuYSBMb2dpYyBMaW1pdGVkIiwiUm9sZXMiOiIiLCJUZW5hbnRJZCI6IlBETFRDNiIsIlNlcnZpY2VOYW1lIjoiV2hpdGUzNjAiLCJuYmYiOjE3MzYxNjM1OTYsImV4cCI6MTczNjM3OTU5NiwiaWF0IjoxNzM2MTYzNTk2fQ.q5ErmDIP0NwKKRlVeb9_EfmrEfd8gsFzkNNszkTeTg4',
+            };
+    }
+    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 'POST_NO_ERROR':
+                return new Promise((resolve) => this.http.post(requestUrl, body, options).subscribe({
+                    next: resolve,
+                }));
+            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);
+    }
+    postNoError(url, body, baseUrl) {
+        return this.request('POST_NO_ERROR', 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.14", 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.14", ngImport: i0, type: HttpWebRequestService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: HttpWebRequestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: EnvironmentService }, { type: i3.NotificationService }] });
+
+class UtilService {
+    parentUtilService;
+    route;
+    constructor(parentUtilService, route) {
+        this.parentUtilService = parentUtilService;
+        this.route = route;
+    }
+    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');
+        }
+    }
+    goToPage(page, extra) {
+        if (extra && typeof extra === 'object') {
+            this.route.navigate([`/${page}`], { queryParams: extra });
+            return;
+        }
+        if (extra) {
+            this.route.navigate([`/${page}`, extra]);
+            return;
+        }
+        this.route.navigate([`/${page}`]);
+    }
+    openFullRouteInNewWindow(url) {
+        window.open(url, '_blank');
+    }
+    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.14", ngImport: i0, type: UtilService, deps: [{ token: UTIL_SERVICE, optional: true }, { token: i1$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UtilService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: UtilService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [UTIL_SERVICE]
+                }] }, { type: i1$1.Router }] });
+
+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;
+            });
+            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.14", ngImport: i0, type: ImportService, deps: [{ token: UtilService }, { token: HttpWebRequestService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: ImportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", 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();
+    batchedRequests = new Map();
+    tempStore = new Map();
+    batchingDelay = 50; // Sliding debounce delay in ms
+    cacheInProgress = 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.postNoError(`SearchDynamic${entity}/0/1`, payload, env);
+        this.utilService.sendBI(false);
+        if (res instanceof ErrorResponse) {
+            return value;
+        }
+        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;
+    }
+    async getAsyncLabelWithBatching(value, entity, labelProp, env, key = 'Code') {
+        const batchKey = `${entity}_${labelProp}_${env}_${key}`;
+        const cacheKey = `${batchKey}_${value}`;
+        if (this.cacheInProgress.has(batchKey)) {
+            await this.cacheInProgress.get(batchKey);
+        }
+        // Return from cache if available
+        if (this.cache.has(cacheKey)) {
+            return this.cache.get(cacheKey);
+        }
+        const store = this.tempStore.get(batchKey);
+        if (store) {
+            const item = store.find((x) => x.Key == value);
+            if (item) {
+                return item.Value;
+            }
+            else {
+                return value;
+            }
+        }
+        return new Promise((resolve, reject) => {
+            let batch = this.batchedRequests.get(batchKey);
+            if (!batch) {
+                batch = {
+                    codes: new Set(),
+                    resolvers: new Map(),
+                    rejectors: new Map(),
+                    timer: null,
+                };
+                this.batchedRequests.set(batchKey, batch);
+            }
+            // Add current request to batch
+            batch.codes.add(value);
+            if (!batch.resolvers.has(value)) {
+                batch.resolvers.set(value, []);
+                batch.rejectors.set(value, []);
+            }
+            batch.resolvers.get(value).push(resolve);
+            batch.rejectors.get(value).push(reject);
+            // Reset debounce timer
+            if (batch.timer)
+                clearTimeout(batch.timer);
+            batch.timer = setTimeout(async () => await this.flushBatch(batchKey), this.batchingDelay);
+        });
+    }
+    async flushBatch(batchKey) {
+        const batch = this.batchedRequests.get(batchKey);
+        if (!batch)
+            return;
+        this.batchedRequests.delete(batchKey);
+        const [entity, labelProp, env, key] = batchKey.split('_');
+        const values = Array.from(batch.codes);
+        const payload = {
+            Fields: [key, labelProp],
+            SearchKeyValues: values.map((val) => ({
+                PropertyName: key,
+                EntityValue: val,
+                Operator: SearchOperator.Or,
+                Sign: SearchPropertySign.EQ,
+            })),
+        };
+        payload.SearchKeyValues.push({
+            PropertyName: 'TenantId',
+            EntityValue: '',
+            Operator: SearchOperator.And,
+            Sign: SearchPropertySign.NEQ,
+        });
+        this.utilService.sendBI(true);
+        const res = await this.server.post(`SearchDynamic${entity}/0/0`, payload, env);
+        this.utilService.sendBI(false);
+        if (res instanceof ErrorResponse) {
+            for (const val of values) {
+                const resolvers = batch.resolvers.get(val) || [];
+                resolvers.forEach((r) => r(val));
+            }
+            return;
+        }
+        const resultArray = res.Result;
+        const labelMap = new Map();
+        resultArray.forEach((item) => {
+            labelMap.set(item[key], item[labelProp]);
+        });
+        for (const val of values) {
+            const label = labelMap.get(val) ?? val;
+            const cacheKey = `${batchKey}_${val}`;
+            this.cache.set(cacheKey, label);
+            const resolvers = batch.resolvers.get(val) || [];
+            resolvers.forEach((r) => r(label));
+        }
+    }
+    async cacheData(items) {
+        for (let item of items) {
+            const batchKey = `${item.Entity}_${item.LabelProp}_${item.Environment}_${item.Key}`;
+            // Signal this batchKey is in progress
+            const inProgress = this._cacheSingleBatch(item, batchKey);
+            this.cacheInProgress.set(batchKey, inProgress);
+            await inProgress;
+            this.cacheInProgress.delete(batchKey);
+        }
+    }
+    async _cacheSingleBatch(item, batchKey) {
+        if (item.Values.length == 0) {
+            return;
+        }
+        const payload = {
+            Fields: [item.Key, item.LabelProp],
+            SearchKeyValues: item.Values.map((val) => ({
+                PropertyName: item.Key,
+                EntityValue: val,
+                Operator: SearchOperator.Or,
+                Sign: SearchPropertySign.EQ,
+            })),
+        };
+        this.utilService.sendBI(true);
+        const res = await this.server.post(`SearchDynamic${item.Entity}/0/0`, payload, item.Environment);
+        this.utilService.sendBI(false);
+        if (!(res instanceof ErrorResponse)) {
+            const resultArray = res.Result;
+            const keyValues = resultArray.map((x) => ({
+                Key: x[item.Key],
+                Value: x[item.LabelProp],
+            }));
+            this.tempStore.set(batchKey, keyValues);
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LabelService, deps: [{ token: UtilService }, { token: HttpWebRequestService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LabelService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: LabelService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: UtilService }, { type: HttpWebRequestService }] });
+
+class SharedService {
+    utilService;
+    server;
+    envSvc;
+    pageSize = DEFAULT_PAGE_SIZE;
+    constructor(utilService, server, envSvc) {
+        this.utilService = utilService;
+        this.server = server;
+        this.envSvc = envSvc;
+    }
+    createCustomFile(base64data, index, file) {
+        const extension = file.name.split('.').pop();
+        const customFile = {
+            Extension: extension,
+            Name: file.name,
+            Data: base64data,
+            DataState: ObjectState.New,
+        };
+        return customFile;
+    }
+    async getAllPrioritiesForTenant(tenant) {
+        const payload = [
+            {
+                PropertyName: 'TenantId',
+                EntityValue: tenant,
+                Operator: SearchOperator.And,
+                Sign: SearchPropertySign.EQ,
+            },
+        ];
+        this.utilService.sendBI(true);
+        const res = await this.server.post(`Ticket/SearchTenantPriority/0/0`, payload, this.envSvc.environment.TicketingAPI);
+        this.utilService.sendBI(false);
+        if (res instanceof ErrorResponse) {
+            return;
+        }
+        else {
+            var result = res;
+            return result;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SharedService, deps: [{ token: UtilService }, { token: HttpWebRequestService }, { token: EnvironmentService }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SharedService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SharedService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: UtilService }, { type: HttpWebRequestService }, { type: EnvironmentService }] });
+
+class CompanySettingsService {
+    locale = 'en-US';
+    numberDP = 2;
+    dateFormat = 'M/d/yyyy';
+    baseCurrency = 'NGN';
+    setSettings(data) {
+        this.locale = data.LocaleCode || 'en-US';
+        this.numberDP = data.NumberDP ?? 2;
+        this.dateFormat = data.DateFormat || 'M/d/yyyy';
+        this.baseCurrency = data.BaseCurrency;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CompanySettingsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CompanySettingsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CompanySettingsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CompanySettingsService, ENVIRONMENT, EnvironmentService, HttpWebRequestService, ImportService, LabelService, SharedService, UtilService };
+//# sourceMappingURL=verben-ticketing-ui-src-lib-services.mjs.map