verben-ticketing-ui 0.6.0

package/esm2022/src/lib/services/label.service.mjs

@@ -0,0 +1,261 @@
+import { Injectable } from '@angular/core';
+import { SearchOperator, SearchPropertySign, ErrorResponse } from 'verben-ticketing-ui/src/lib/models';
+import * as i0 from "@angular/core";
+import * as i1 from "./util.service";
+import * as i2 from "./http-web-request.service";
+export 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: i1.UtilService }, { token: i2.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: i1.UtilService }, { type: i2.HttpWebRequestService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"label.service.js","sourceRoot":"","sources":["../../../../../../projects/verben-ticketing-ui/src/lib/services/label.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { UtilService as AppUtilService } from './util.service';\nimport { HttpWebRequestService } from './http-web-request.service';\nimport { SearchOperator , SearchDynamicWrapper, SearchPropertySign, ErrorResponse, PagedResult,KeyValueParam, CacheDataRequest} from 'verben-ticketing-ui/src/lib/models';\nimport { Observable, of } from 'rxjs';\n\ntype BatchedRequest = {\n  codes: Set<string>;\n  resolvers: Map<string, Array<(label: string) => void>>;\n  rejectors: Map<string, Array<(error: any) => void>>;\n  timer: any;\n};\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class LabelService {\n  private cache = new Map<string, string>();\n  private inFlightRequests = new Map<string, Promise<string>>();\n  private batchedRequests = new Map<string, BatchedRequest>();\n  private tempStore = new Map<string, KeyValueParam[]>();\n  private batchingDelay = 50; // Sliding debounce delay in ms\n  private cacheInProgress = new Map<string, Promise<void>>();\n  constructor(\n    private utilService: AppUtilService,\n    private server: HttpWebRequestService\n  ) {}\n\n  async getAsyncLabel(\n    value: any,\n    entity: string,\n    labelProp: string,\n    env: string,\n    key: string = 'Code'\n  ): Promise<string> {\n    const cacheKey = `${entity}_${labelProp}_${value}_${env}_${key}`;\n\n    if (this.cache.has(cacheKey)) {\n      const value = this.cache.get(cacheKey)!;\n      return value;\n    }\n\n    var payload: SearchDynamicWrapper = {\n      Fields: [labelProp],\n      SearchKeyValues: [\n        {\n          PropertyName: key,\n          EntityValue: value,\n          Operator: SearchOperator.And,\n          Sign: SearchPropertySign.EQ,\n        },\n      ],\n    };\n\n    this.utilService.sendBI(true);\n    const res = await this.server.postNoError(\n      `SearchDynamic${entity}/0/1`,\n      payload,\n      env\n    );\n    this.utilService.sendBI(false);\n    if (res instanceof ErrorResponse) {\n      return value;\n    } else {\n      const result = (res as PagedResult<string>).Result;\n      const label = result.length > 0 ? result[0] : value;\n      this.cache.set(cacheKey, label);\n      return label;\n    }\n  }\n\n  async getAsyncLabelWithRequestTracking(\n    value: any,\n    entity: string,\n    labelProp: string,\n    env: string,\n    key: string = 'Code'\n  ): Promise<string> {\n    const cacheKey = `${entity}_${labelProp}_${value}_${env}_${key}`;\n\n    if (this.cache.has(cacheKey)) {\n      return this.cache.get(cacheKey)!;\n    }\n\n    if (this.inFlightRequests.has(cacheKey)) {\n      return this.inFlightRequests.get(cacheKey)!;\n    }\n\n    const requestPromise = (async () => {\n      const payload: SearchDynamicWrapper = {\n        Fields: [labelProp],\n        SearchKeyValues: [\n          {\n            PropertyName: key,\n            EntityValue: value,\n            Operator: SearchOperator.And,\n            Sign: SearchPropertySign.EQ,\n          },\n        ],\n      };\n\n      this.utilService.sendBI(true);\n      const res = await this.server.post(\n        `SearchDynamic${entity}/0/1`,\n        payload,\n        env\n      );\n      this.utilService.sendBI(false);\n\n      let label: string;\n      if (res instanceof ErrorResponse) {\n        label = '';\n      } else {\n        const result = (res as PagedResult<string>).Result;\n        label = result.length > 0 ? result[0] : value;\n      }\n\n      this.cache.set(cacheKey, label);\n      this.inFlightRequests.delete(cacheKey);\n\n      return label;\n    })();\n\n    // Save the in-flight request\n    this.inFlightRequests.set(cacheKey, requestPromise);\n\n    return requestPromise;\n  }\n\n  async getAsyncLabelWithRequestTrackingNoGateway(\n    value: any,\n    entity: string,\n    labelProp: string,\n    env: string,\n    controller: string,\n    key: string = 'Code'\n  ): Promise<string> {\n    const cacheKey = `${entity}_${labelProp}_${value}_${env}_${key}_${controller}`;\n\n    if (this.cache.has(cacheKey)) {\n      return this.cache.get(cacheKey)!;\n    }\n\n    if (this.inFlightRequests.has(cacheKey)) {\n      return this.inFlightRequests.get(cacheKey)!;\n    }\n\n    const requestPromise = (async () => {\n      const payload: SearchDynamicWrapper = {\n        Fields: [labelProp],\n        SearchKeyValues: [\n          {\n            PropertyName: key,\n            EntityValue: value,\n            Operator: SearchOperator.And,\n            Sign: SearchPropertySign.EQ,\n          },\n        ],\n      };\n\n      this.utilService.sendBI(true);\n      const res = await this.server.post(\n        `${controller}/SearchDynamic${entity}s/0/1`,\n        payload,\n        env\n      );\n      this.utilService.sendBI(false);\n\n      let label: string;\n      if (res instanceof ErrorResponse) {\n        label = '';\n      } else {\n        const result = (res as PagedResult<string>).Result;\n        label = result.length > 0 ? result[0] : value;\n      }\n\n      this.cache.set(cacheKey, label);\n      this.inFlightRequests.delete(cacheKey);\n\n      return label;\n    })();\n\n    // Save the in-flight request\n    this.inFlightRequests.set(cacheKey, requestPromise);\n\n    return requestPromise;\n  }\n\n  async getAsyncLabelWithBatching(\n    value: any,\n    entity: string,\n    labelProp: string,\n    env: string,\n    key: string = 'Code'\n  ): Promise<string> {\n    const batchKey = `${entity}_${labelProp}_${env}_${key}`;\n    const cacheKey = `${batchKey}_${value}`;\n\n    if (this.cacheInProgress.has(batchKey)) {\n      await this.cacheInProgress.get(batchKey);\n    }\n    // Return from cache if available\n    if (this.cache.has(cacheKey)) {\n      return this.cache.get(cacheKey)!;\n    }\n\n    const store = this.tempStore.get(batchKey);\n    if (store) {\n      const item = store.find((x) => x.Key == value);\n      if (item) {\n        return item.Value;\n      } else {\n        return value;\n      }\n    }\n\n    return new Promise((resolve, reject) => {\n      let batch = this.batchedRequests.get(batchKey);\n\n      if (!batch) {\n        batch = {\n          codes: new Set(),\n          resolvers: new Map(),\n          rejectors: new Map(),\n          timer: null,\n        };\n        this.batchedRequests.set(batchKey, batch);\n      }\n\n      // Add current request to batch\n      batch.codes.add(value);\n      if (!batch.resolvers.has(value)) {\n        batch.resolvers.set(value, []);\n        batch.rejectors.set(value, []);\n      }\n      batch.resolvers.get(value)!.push(resolve);\n      batch.rejectors.get(value)!.push(reject);\n\n      // Reset debounce timer\n      if (batch.timer) clearTimeout(batch.timer);\n      batch.timer = setTimeout(\n        async () => await this.flushBatch(batchKey),\n        this.batchingDelay\n      );\n    });\n  }\n\n  private async flushBatch(batchKey: string) {\n    const batch = this.batchedRequests.get(batchKey);\n    if (!batch) return;\n\n    this.batchedRequests.delete(batchKey);\n\n    const [entity, labelProp, env, key] = batchKey.split('_');\n    const values = Array.from(batch.codes);\n\n    const payload: SearchDynamicWrapper = {\n      Fields: [key, labelProp],\n      SearchKeyValues: values.map((val) => ({\n        PropertyName: key,\n        EntityValue: val,\n        Operator: SearchOperator.Or,\n        Sign: SearchPropertySign.EQ,\n      })),\n    };\n\n    payload.SearchKeyValues.push({\n      PropertyName: 'TenantId',\n      EntityValue: '',\n      Operator: SearchOperator.And,\n      Sign: SearchPropertySign.NEQ,\n    });\n\n    this.utilService.sendBI(true);\n    const res = await this.server.post(\n      `SearchDynamic${entity}/0/0`,\n      payload,\n      env\n    );\n    this.utilService.sendBI(false);\n\n    if (res instanceof ErrorResponse) {\n      for (const val of values) {\n        const resolvers = batch.resolvers.get(val) || [];\n        resolvers.forEach((r) => r(val));\n      }\n      return;\n    }\n\n    const resultArray = (res as PagedResult<any>).Result;\n\n    const labelMap = new Map<string, string>();\n    resultArray.forEach((item: any) => {\n      labelMap.set(item[key], item[labelProp]);\n    });\n\n    for (const val of values) {\n      const label = labelMap.get(val) ?? val;\n      const cacheKey = `${batchKey}_${val}`;\n      this.cache.set(cacheKey, label);\n\n      const resolvers = batch.resolvers.get(val) || [];\n      resolvers.forEach((r) => r(label));\n    }\n  }\n\n  async cacheData(items: CacheDataRequest[]) {\n    for (let item of items) {\n      const batchKey = `${item.Entity}_${item.LabelProp}_${item.Environment}_${item.Key}`;\n\n      // Signal this batchKey is in progress\n      const inProgress = this._cacheSingleBatch(item, batchKey);\n      this.cacheInProgress.set(batchKey, inProgress);\n\n      await inProgress;\n      this.cacheInProgress.delete(batchKey);\n    }\n  }\n\n  private async _cacheSingleBatch(\n    item: CacheDataRequest,\n    batchKey: string\n  ): Promise<void> {\n    if (item.Values.length == 0) {\n      return;\n    }\n    const payload: SearchDynamicWrapper = {\n      Fields: [item.Key, item.LabelProp],\n      SearchKeyValues: item.Values.map((val) => ({\n        PropertyName: item.Key,\n        EntityValue: val,\n        Operator: SearchOperator.Or,\n        Sign: SearchPropertySign.EQ,\n      })),\n    };\n\n    this.utilService.sendBI(true);\n    const res = await this.server.post(\n      `SearchDynamic${item.Entity}/0/0`,\n      payload,\n      item.Environment\n    );\n    this.utilService.sendBI(false);\n\n    if (!(res instanceof ErrorResponse)) {\n      const resultArray = (res as PagedResult<any>).Result;\n      const keyValues: KeyValueParam[] = resultArray.map((x: any) => ({\n        Key: x[item.Key],\n        Value: x[item.LabelProp],\n      }));\n      this.tempStore.set(batchKey, keyValues);\n    }\n  }\n\n  // async cacheData(items: CacheDataRequest[]) {\n  //   for(let item of items) {\n  //     const batchKey = `${item.Entity}_${item.LabelProp}_${item.Environment}_${item.Key}`;\n  //     const payload: SearchDynamicWrapper = {\n  //     Fields: [item.Key, item.LabelProp],\n  //     SearchKeyValues: item.Values.map((val) => ({\n  //         PropertyName: item.Key,\n  //         EntityValue: val,\n  //         Operator: SearchOperator.Or,\n  //         Sign: SearchPropertySign.EQ,\n  //       })),\n  //     };\n\n  //     this.utilService.sendBI(true);\n  //     const res = await this.server.post(\n  //       `SearchDynamic${item.Entity}/0/0`,\n  //       payload,\n  //       item.Environment\n  //     );\n  //     this.utilService.sendBI(false);\n\n  //     if (res instanceof ErrorResponse) {\n\n  //     } else {\n  //       const resultArray = (res as PagedResult<any>).Result;\n  //       const keyValues: KeyValueParam[] = [];\n  //       resultArray.forEach((x: any) => {\n  //         var keyValue: KeyValueParam = {\n  //           Key: x[item.Key],\n  //           Value: x[item.LabelProp]\n  //         }\n  //         keyValues.push(keyValue);\n  //       })\n  //       this.tempStore.set(batchKey, keyValues);\n  //     }\n  //   }\n  // }\n}\n"]}

package/esm2022/src/lib/services/public-api.mjs

@@ -0,0 +1,8 @@
+export * from './environment.service';
+export * from './http-web-request.service';
+export * from './import.service';
+export * from './label.service';
+export * from './util.service';
+export * from './shared.service';
+export * from './company-settings.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZlcmJlbi10aWNrZXRpbmctdWkvc3JjL2xpYi9zZXJ2aWNlcy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsNEJBQTRCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Vudmlyb25tZW50LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9odHRwLXdlYi1yZXF1ZXN0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9pbXBvcnQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xhYmVsLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlsLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zaGFyZWQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbXBhbnktc2V0dGluZ3Muc2VydmljZSc7XG4iXX0=

package/esm2022/src/lib/services/shared.service.mjs

@@ -0,0 +1,58 @@
+import { Injectable } from '@angular/core';
+import { DEFAULT_PAGE_SIZE } from 'verben-ticketing-ui/src/lib/constants';
+import { ErrorResponse, SearchOperator, SearchPropertySign, } from 'verben-ticketing-ui/src/lib/models';
+import { ObjectState } from 'verben-ticketing-ui/src/lib/models';
+import * as i0 from "@angular/core";
+import * as i1 from "./util.service";
+import * as i2 from "./http-web-request.service";
+import * as i3 from "./environment.service";
+export 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: i1.UtilService }, { token: i2.HttpWebRequestService }, { token: i3.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: i1.UtilService }, { type: i2.HttpWebRequestService }, { type: i3.EnvironmentService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/src/lib/services/util.service.mjs

@@ -0,0 +1,72 @@
+import { Inject, Injectable, Optional, } from '@angular/core';
+import { UTIL_SERVICE } from 'verben-ng-ui';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export 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.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.Router }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyYmVuLXRpY2tldGluZy11aS1zcmMtbGliLXNlcnZpY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdmVyYmVuLXRpY2tldGluZy11aS9zcmMvbGliL3NlcnZpY2VzL3ZlcmJlbi10aWNrZXRpbmctdWktc3JjLWxpYi1zZXJ2aWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/src/utils/components/base-data-view.component.mjs

@@ -0,0 +1,111 @@
+import { Component, computed, signal, ViewChild } from '@angular/core';
+import { DataFilterType, } from 'verben-ng-ui';
+import * as i0 from "@angular/core";
+export class BaseDataViewComponent {
+    cardDataView;
+    dataView;
+    // Signals for reactive data management
+    data = signal([]);
+    cardData = computed(() => this.data().map(this.config.cardDataMapper));
+    // View state management
+    currentData = null;
+    isGridView = true;
+    selected = null;
+    // Filtering and sorting state
+    visibleColumns = [];
+    filterArray = [];
+    sortOptions = [];
+    selectedColumnCount = 0;
+    selectedFilterTableCount = 0;
+    selectedSortCount = 0;
+    constructor() {
+        this.initializeConfig();
+    }
+    ngOnInit() {
+        this.loadInitialData();
+    }
+    // To be implemented by child classes if needed
+    loadInitialData() {
+        // Default implementation can be overridden
+        this.data.set(this.config.dataSource);
+    }
+    initializeConfig() {
+        // Initialize filter and column configurations
+        this.visibleColumns = this.config.columns.map((col) => ({
+            checked: true,
+            name: typeof col.header === 'string' ? col.header : col.id,
+            type: DataFilterType.Bool,
+        }));
+        this.filterArray = this.config.filterOptions || [];
+        this.sortOptions = this.config.sortOptions || [];
+    }
+    // Generic view and interaction methods
+    openDetailView(identifier) {
+        const cardItem = this.getCardDataByIdentifier(identifier);
+        if (cardItem && this.cardDataView) {
+            this.resetSelections();
+            cardItem.selected = true;
+            this.currentData = this.cardDataView.onItemClick(cardItem);
+            this.dataView.toggleView();
+        }
+    }
+    resetSelections() {
+        this.cardData().forEach((item) => {
+            item.selected = false;
+            item.children?.forEach((child) => (child.selected = false));
+        });
+    }
+    // Common utility methods
+    downloadCSV(data) {
+        const headers = Object.keys(data[0]);
+        const csvContent = [
+            headers.join(','),
+            ...data.map((row) => headers.map((header) => row[header]).join(',')),
+        ].join('\n');
+        const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+        const link = document.createElement('a');
+        if (link.download !== undefined) {
+            const url = URL.createObjectURL(blob);
+            link.setAttribute('href', url);
+            link.setAttribute('download', 'export.csv');
+            link.style.visibility = 'hidden';
+            document.body.appendChild(link);
+            link.click();
+            document.body.removeChild(link);
+        }
+    }
+    // Event handlers
+    onViewChange(isGridView) {
+        this.isGridView = isGridView;
+        if (this.currentData) {
+            this.cardDataView?.clearData();
+            this.currentData = null;
+        }
+    }
+    onColumnsUpdated(updatedColumns) {
+        // Update visible columns logic
+        this.selectedColumnCount = updatedColumns.length;
+        // Additional column update logic can be added here
+    }
+    onSortUpdated(updatedSorts) {
+        this.selectedSortCount = updatedSorts.length;
+    }
+    onSelectionChange(selectedRows) {
+        //console.log('Selection changed:', selectedRows);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BaseDataViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.14", type: BaseDataViewComponent, selector: "ng-component", viewQueries: [{ propertyName: "cardDataView", first: true, predicate: ["vdcv"], descendants: true }, { propertyName: "dataView", first: true, predicate: ["vdv"], descendants: true }], ngImport: i0, template: '', isInline: true });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: BaseDataViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: '',
+                }]
+        }], ctorParameters: () => [], propDecorators: { cardDataView: [{
+                type: ViewChild,
+                args: ['vdcv']
+            }], dataView: [{
+                type: ViewChild,
+                args: ['vdv']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-data-view.component.js","sourceRoot":"","sources":["../../../../../../projects/verben-ticketing-ui/src/utils/components/base-data-view.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, computed, OnInit, signal, ViewChild } from '@angular/core';\nimport {\n  CardData,\n  CardDataViewComponent,\n  DataFilterType,\n  DataViewComponent,\n  IDataFilter,\n} from 'verben-ng-ui';\nimport { DataViewConfig } from '../models/DataViewConfig';\n\n@Component({\n  template: '',\n})\nexport abstract class BaseDataViewComponent<T> implements OnInit {\n  @ViewChild('vdcv') cardDataView!: CardDataViewComponent;\n  @ViewChild('vdv') dataView!: DataViewComponent;\n\n  // Configurable properties\n  abstract config: DataViewConfig<T>;\n\n  // Signals for reactive data management\n  data = signal<T[]>([]);\n  cardData = computed(() => this.data().map(this.config.cardDataMapper));\n\n  // View state management\n  currentData: CardData | null = null;\n  isGridView = true;\n  selected: CardData | null = null;\n\n  // Filtering and sorting state\n  visibleColumns: IDataFilter[] = [];\n  filterArray: IDataFilter[] = [];\n  sortOptions: IDataFilter[] = [];\n\n  selectedColumnCount = 0;\n  selectedFilterTableCount = 0;\n  selectedSortCount = 0;\n\n  constructor() {\n    this.initializeConfig();\n  }\n\n  ngOnInit() {\n    this.loadInitialData();\n  }\n\n  // To be implemented by child classes if needed\n  protected loadInitialData() {\n    // Default implementation can be overridden\n    this.data.set(this.config.dataSource);\n  }\n\n  private initializeConfig() {\n    // Initialize filter and column configurations\n    this.visibleColumns = this.config.columns.map((col) => ({\n      checked: true,\n      name: typeof col.header === 'string' ? col.header : col.id,\n      type: DataFilterType.Bool,\n    }));\n\n    this.filterArray = this.config.filterOptions || [];\n    this.sortOptions = this.config.sortOptions || [];\n  }\n\n  // Generic view and interaction methods\n  openDetailView(identifier: any) {\n    const cardItem = this.getCardDataByIdentifier(identifier);\n    if (cardItem && this.cardDataView) {\n      this.resetSelections();\n      cardItem.selected = true;\n      this.currentData = this.cardDataView.onItemClick(cardItem);\n      this.dataView.toggleView();\n    }\n  }\n\n  private resetSelections() {\n    this.cardData().forEach((item) => {\n      item.selected = false;\n      item.children?.forEach((child) => (child.selected = false));\n    });\n  }\n\n  // Abstract method to find card data - to be implemented by child\n  protected abstract getCardDataByIdentifier(\n    identifier: any\n  ): CardData | undefined;\n\n  // Common utility methods\n  downloadCSV(data: Partial<any>[]) {\n    const headers = Object.keys(data[0]);\n    const csvContent = [\n      headers.join(','),\n      ...data.map((row) => headers.map((header) => row[header]).join(',')),\n    ].join('\\n');\n\n    const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });\n    const link = document.createElement('a');\n    if (link.download !== undefined) {\n      const url = URL.createObjectURL(blob);\n      link.setAttribute('href', url);\n      link.setAttribute('download', 'export.csv');\n      link.style.visibility = 'hidden';\n      document.body.appendChild(link);\n      link.click();\n      document.body.removeChild(link);\n    }\n  }\n\n  // Event handlers\n  onViewChange(isGridView: boolean): void {\n    this.isGridView = isGridView;\n    if (this.currentData) {\n      this.cardDataView?.clearData();\n      this.currentData = null;\n    }\n  }\n\n  onColumnsUpdated(updatedColumns: IDataFilter[]) {\n    // Update visible columns logic\n    this.selectedColumnCount = updatedColumns.length;\n    // Additional column update logic can be added here\n  }\n\n  onSortUpdated(updatedSorts: IDataFilter[]) {\n    this.selectedSortCount = updatedSorts.length;\n  }\n\n  onSelectionChange(selectedRows: T[]) {\n    //console.log('Selection changed:', selectedRows);\n  }\n}\n"]}

package/esm2022/src/utils/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92ZXJiZW4tdGlja2V0aW5nLXVpL3NyYy91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2022/src/utils/models/DataViewConfig.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGF0YVZpZXdDb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92ZXJiZW4tdGlja2V0aW5nLXVpL3NyYy91dGlscy9tb2RlbHMvRGF0YVZpZXdDb25maWcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENhcmREYXRhLCBDb2x1bW5EZWZpbml0aW9uLCBJRGF0YUZpbHRlciB9IGZyb20gJ3ZlcmJlbi1uZy11aSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YVZpZXdDb25maWc8VD4ge1xuICAvLyBDb3JlIGRhdGEgY29uZmlndXJhdGlvblxuICBkYXRhU291cmNlOiBUW107XG4gIGNvbHVtbnM6IENvbHVtbkRlZmluaXRpb248VD5bXTtcblxuICAvLyBDYXJkIHZpZXcgbWFwcGluZyBmdW5jdGlvblxuICBjYXJkRGF0YU1hcHBlcjogKGl0ZW06IFQpID0+IENhcmREYXRhO1xuXG4gIC8vIE9wdGlvbmFsIGNvbmZpZ3VyYXRpb25zXG4gIGZpbHRlck9wdGlvbnM/OiBJRGF0YUZpbHRlcltdO1xuICBzb3J0T3B0aW9ucz86IElEYXRhRmlsdGVyW107XG5cbiAgLy8gQWN0aW9uIGhhbmRsZXJzXG4gIG9uRGV0YWlsVmlldz86IChpdGVtOiBUKSA9PiB2b2lkO1xuICBvbkFwcHJvdmU/OiAoaXRlbTogVCkgPT4gdm9pZDtcbiAgb25EZWxldGU/OiAoaXRlbTogVCkgPT4gdm9pZDtcbn1cbiJdfQ==

package/esm2022/src/utils/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './components/base-data-view.component';
+export * from './models/DataViewConfig';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZlcmJlbi10aWNrZXRpbmctdWkvc3JjL3V0aWxzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL2Jhc2UtZGF0YS12aWV3LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9EYXRhVmlld0NvbmZpZyc7XG4iXX0=

package/esm2022/src/utils/verben-ticketing-ui-src-utils.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyYmVuLXRpY2tldGluZy11aS1zcmMtdXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92ZXJiZW4tdGlja2V0aW5nLXVpL3NyYy91dGlscy92ZXJiZW4tdGlja2V0aW5nLXVpLXNyYy11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2022/verben-ticketing-ui.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyYmVuLXRpY2tldGluZy11aS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3ZlcmJlbi10aWNrZXRpbmctdWkvc3JjL3ZlcmJlbi10aWNrZXRpbmctdWkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==