@techextensor/tab-core-utility 2.2.140 → 2.2.142

package/esm2022/lib/tab-core-utility/app/helpers/common/app.helpers.mjs

@@ -3,41 +3,31 @@ import { Injectable, inject } from '@angular/core';
 import { ApiService } from '../../../core/http-client/api.service';
 import { getHeaders } from '../../utils/req-res.util';
 import { API } from '../../constants/api-constants';
-import { LocalStorageService } from '../../../auth/local-storage.service';
-import { IdbService } from '../../../auth/idb-storage.service';
-import { Common } from '../../constants/common';
-import { StorageConstants } from '../../constants/storage-constants';
 import * as i0 from "@angular/core";
 export class AppHelper {
     constructor() {
         this.apiService = inject(ApiService);
-        this.localStorageService = inject(LocalStorageService);
-        this.idbService = inject(IdbService);
     }
     /**
      * Rebuilds the application.
-     * @param data Optional data for rebuilding the application
      * @returns Result of the rebuild operation
      */
-    rebuildApp(data) {
+    rebuildApp() {
         const headers = getHeaders();
-        if (headers) {
-            return this.apiService.post(API.buildApp, data ? data : {}, headers);
-        }
-        return null;
-    }
-    /**
-     * Publishes the application.
-     * @param params Optional parameters for publishing the application
-     * @returns Result of the publish operation
-     */
-    publishApp(params) {
-        const headers = getHeaders();
-        if (headers) {
-            return this.apiService.get(API.publishApp, params, headers);
-        }
-        return null;
+        return this.apiService.post(API.buildApp, {}, headers);
     }
+    // /**
+    //  * Publishes the application.
+    //  * @param params Optional parameters for publishing the application
+    //  * @returns Result of the publish operation
+    //  */
+    // publishApp(params?: any) {
+    //   const headers = getHeaders();
+    //   if (headers) {
+    //     return this.apiService.get(API.publishApp, params, headers);
+    //   }
+    //   return null;
+    // }
     /**
      * Retrieves screen data.
      * @param params Optional parameters for retrieving screen data
@@ -52,127 +42,157 @@ export class AppHelper {
     }
     /**
      * Retrieves schema data.
-     * @param params Optional parameters for retrieving schema data
      * @returns Subscription for getting schema data
      */
-    getSchema(params) {
+    getSchema() {
         const headers = getHeaders();
-        if (headers) {
-            return this.apiService.get(API.getSchema, params, headers);
-        }
-        return null;
-    }
-    storeSchemaIntoIDB() {
-        // this.idbService.clearIndexedDB()
-        this.getSchema()?.subscribe({
-            next: (value) => {
-                Common.tabJson = JSON.parse(value.Result);
-                this.idbService.setItem(StorageConstants.tabData, JSON.parse(value.Result));
-            },
-            error: (response) => {
-                console.log(response);
-            }
-        });
+        return this.apiService.get(API.getSchema, undefined, headers);
     }
-    getPermission(params) {
+    // storeSchemaIntoIDB(){
+    //   // this.idbService.clearIndexedDB()
+    //   this.getSchema()?.subscribe({
+    //     next: (value: SchemaResponse) => {
+    //         Common.tabJson = JSON.parse(value.Result);
+    //         this.idbService.setItem(StorageConstants.tabData, JSON.parse(value.Result))
+    //     },
+    //     error: (response: Error) => {
+    //         console.log(response)
+    //     }
+    // })
+    // }
+    /**
+     * Retrieves permission data.
+     * @returns Subscription for getting permission data
+     */
+    getPermission() {
         const headers = getHeaders();
-        if (headers) {
-            return this.apiService.get(API.getPermission, params, headers);
-        }
-        return null;
+        return this.apiService.get(API.getPermission, undefined, headers);
     }
-    registerAppObjects(params) {
+    /**
+     * Registers application objects.
+     * @param payload Parameters for registering application objects
+     * @returns Result of the registration operation
+     */
+    registerAppObjects(payload) {
         const headers = getHeaders();
-        if (headers) {
-            return this.apiService.post(API.registerAppObjects, params, headers);
-        }
-        return null;
+        return this.apiService.post(API.registerAppObjects, payload, headers);
     }
     /**
      * Clones a DataSourceQuery (DSQ) with the given parameters.
-     * @param params parameters for cloning the DSQ
+     * @param payload parameters for cloning the DSQ
      * @returns The result of the cloning operation
      */
-    cloneDsq(params) {
+    cloneDsq(payload) {
         const headers = getHeaders();
-        if (headers) {
-            return this.apiService.post(API.cloneDsq, params, headers);
-        }
-        return null;
+        return this.apiService.post(API.cloneDsq, payload, headers);
     }
     /**
      * Retrieves data in JSON format based on the given JSON type and request tokens.
-     * @param jsonType The type of JSON data to retrieve
-     * @param reqtokens Request tokens for the data retrieval
+     * @param payload Payload containing the JSON type and request tokens
      * @returns The JSON data retrieved
      */
-    getDataJsonByType(jsonType, reqtokens) {
+    getDataJsonByType(payload) {
         const headers = getHeaders();
-        if (headers) {
-            return this.apiService.post(API.GetDataJsonByType, {
-                JsonType: jsonType,
-                Reqtokens: reqtokens
-            }, headers);
-        }
-        return null;
+        return this.apiService.post(API.GetDataJsonByType, payload, headers);
     }
     /**
      * Syncs the fields of the application object with the given parameters.
-     * @param params Optional parameters for the synchronization
+     * @param payload Parameters for syncing the fields
      * @returns The result of the synchronization operation
      */
-    syncAppFields(params) {
+    syncAppFields(payload) {
         const headers = getHeaders();
-        if (headers) {
-            return this.apiService.post(API.SyncAppFields, params, headers);
-        }
-        return null;
+        return this.apiService.post(API.SyncAppFields, payload, headers);
+    }
+    /**
+     * Sets the tab components for the given tenant
+     * @param connectionId The ID of the connection
+     * @returns An observable of the response from the API
+     */
+    setTabComponents(connectionId) {
+        const headers = getHeaders();
+        return this.apiService.post(`${API.setTabComponents}/${connectionId}`, {}, headers);
+    }
+    /**
+     * Gets the result of the validation for the given connection
+     * @param connectionId The ID of the connection
+     * @returns An observable of the response from the API
+     */
+    performValidation(connectionId) {
+        const headers = getHeaders();
+        return this.apiService.get(`${API.performValidation}/${connectionId}`, undefined, headers);
+    }
+    /**
+     * Tests the connection for the given connection ID.
+     * @param connectionId The ID of the connection
+     * @returns An observable of the response from the API
+     */
+    testConnection(connectionId) {
+        const headers = getHeaders();
+        return this.apiService.get(`${API.testConnection}/${connectionId}`, undefined, headers);
+    }
+    /**
+     * Refreshes the global search data using the provided payload.
+     * @param data Payload containing the query object ID for refreshing search data
+     * @returns An observable of the API response
+     */
+    refreshGlobalSearchData(data) {
+        const headers = getHeaders();
+        return this.apiService.post(`${API.RefreshGlobalSearchData}`, data, headers);
     }
     /**
      * Exports a report based on the given parameters.
-     * @param params Optional parameters for exporting the report
+     * @param payload Parameters for exporting the report
      * @returns The result of the export operation
      */
-    exportReport(params) {
+    exportReport(payload) {
         const headers = getHeaders();
-        if (headers) {
-            return this.apiService.post(
-            // The endpoint for exporting a report
-            API.exportReport, 
-            // The parameters for the export operation
-            params, 
-            // The custom headers for the request
-            headers);
-        }
-        return null;
+        return this.apiService.post(API.exportReport, payload, headers);
     }
     /**
      * Downloads a report file based on the given parameters.
-     * @param params Optional parameters for downloading the report file
+     * @param payload Parameters for downloading the report file
      * @returns The result of the download operation
      */
-    downloadReportFile(params) {
+    downloadReport(payload) {
         const headers = getHeaders();
-        if (headers) {
-            return this.apiService.postBlob(API.downloadReportFile, params, headers);
-        }
-        return null;
+        return this.apiService.postBlob(API.downloadReportFile, payload, headers);
     }
     /**
      * Sends a report based on the given parameters.
-     * @param params Optional parameters for sending the report
+     * @param payload Parameters for sending the report
      * @returns The result of the send operation
      */
-    sendReport(params) {
+    sendReport(payload) {
         const headers = getHeaders();
-        if (headers) {
-            return this.apiService.post(
-            // The endpoint for sending a report. The report will be sent to the specified email address.
-            API.sendReport, params, 
-            // The custom headers for the request
-            headers);
-        }
-        return null;
+        return this.apiService.post(API.sendReport, payload, headers);
+    }
+    /**
+     * Retrieves the detailed analytics of a screen's performance.
+     * @param data - Data to be sent to the API
+     * @returns Response from the API
+     */
+    getDetailOfPerformanceAnalytics(data) {
+        const headers = getHeaders();
+        return this.apiService.post(API.GetDetailOfPerformanceAnalytics, data, headers);
+    }
+    /**
+     * Get summary of performance analytics
+     * @param data - Data to be sent to the API
+     * @returns Response from the API
+     */
+    getSummaryOfPerformanceAnalytics(data) {
+        const headers = getHeaders();
+        return this.apiService.post(API.GetSummaryOfPerformanceAnalytics, data, headers);
+    }
+    /**
+     * Insert Screen Performance Statistics
+     * @param data - Data to insert
+     * @returns Response from the API
+     */
+    insertScreenPerformanceStatistics(data) {
+        const headers = getHeaders();
+        return this.apiService.post(API.InsertScreenPerformanceAnalytics, data, headers);
     }
     static { this.ɵfac = function AppHelper_Factory(t) { return new (t || AppHelper)(); }; }
     static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AppHelper, factory: AppHelper.ɵfac, providedIn: 'root' }); }
@@ -181,4 +201,4 @@ export class AppHelper {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/app.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\n\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { ApiService } from '../../../core/http-client/api.service';\r\nimport { getHeaders } from '../../utils/req-res.util';\r\nimport { API } from '../../constants/api-constants';\r\nimport { LocalStorageService } from '../../../auth/local-storage.service';\r\nimport { IdbService } from '../../../auth/idb-storage.service';\r\nimport { SchemaResponse } from '../../interfaces/schema.interface';\r\nimport { Common } from '../../constants/common';\r\nimport { StorageConstants } from '../../constants/storage-constants';\r\n@Injectable({ providedIn: 'root' })\r\nexport class AppHelper {\r\n  private readonly apiService = inject(ApiService);\r\n  private readonly localStorageService = inject(LocalStorageService);\r\n  private readonly idbService = inject(IdbService);\r\n\r\n\r\n  /**\r\n   * Rebuilds the application.\r\n   * @param data Optional data for rebuilding the application\r\n   * @returns Result of the rebuild operation\r\n   */\r\n  rebuildApp(data?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(API.buildApp, data ? data : {}, headers);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Publishes the application.\r\n   * @param params Optional parameters for publishing the application\r\n   * @returns Result of the publish operation\r\n   */\r\n  publishApp(params?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.get(API.publishApp, params, headers);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Retrieves screen data.\r\n   * @param params Optional parameters for retrieving screen data\r\n   * @returns Screen data\r\n   */\r\n  getScreen(params?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.get(API.getScreen, params, headers);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Retrieves schema data.\r\n   * @param params Optional parameters for retrieving schema data\r\n   * @returns Subscription for getting schema data\r\n   */\r\n  getSchema(params?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.get(API.getSchema, params, headers);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  storeSchemaIntoIDB(){\r\n    // this.idbService.clearIndexedDB()\r\n    this.getSchema()?.subscribe({\r\n      next: (value: SchemaResponse) => {\r\n          Common.tabJson = JSON.parse(value.Result);\r\n          this.idbService.setItem(StorageConstants.tabData, JSON.parse(value.Result))\r\n      },\r\n      error: (response: Error) => {\r\n          console.log(response)\r\n      }\r\n  })\r\n  }\r\n\r\n  getPermission(params?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.get(API.getPermission, params, headers);\r\n    }\r\n    return null;\r\n  }\r\n  registerAppObjects(params?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(API.registerAppObjects, params, headers);\r\n    }\r\n    return null;\r\n  }\r\n  /**\r\n   * Clones a DataSourceQuery (DSQ) with the given parameters.\r\n   * @param params parameters for cloning the DSQ\r\n   * @returns The result of the cloning operation\r\n   */\r\n  cloneDsq(params: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(API.cloneDsq, params, headers);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Retrieves data in JSON format based on the given JSON type and request tokens.\r\n   * @param jsonType The type of JSON data to retrieve\r\n   * @param reqtokens Request tokens for the data retrieval\r\n   * @returns The JSON data retrieved\r\n   */\r\n  getDataJsonByType(jsonType: number, reqtokens?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(API.GetDataJsonByType, {\r\n        JsonType : jsonType,\r\n        Reqtokens: reqtokens\r\n      }, headers);\r\n    }\r\n    return null;\r\n  }\r\n  /**\r\n   * Syncs the fields of the application object with the given parameters.\r\n   * @param params Optional parameters for the synchronization\r\n   * @returns The result of the synchronization operation\r\n   */\r\n  syncAppFields(params?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(\r\n        API.SyncAppFields,\r\n        params,\r\n        headers\r\n      );\r\n    }\r\n    return null;\r\n  }\r\n  /**\r\n   * Exports a report based on the given parameters.\r\n   * @param params Optional parameters for exporting the report\r\n   * @returns The result of the export operation\r\n   */\r\n  exportReport(params?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(\r\n        // The endpoint for exporting a report\r\n        API.exportReport,\r\n        // The parameters for the export operation\r\n        params,\r\n        // The custom headers for the request\r\n        headers\r\n      );\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Downloads a report file based on the given parameters.\r\n   * @param params Optional parameters for downloading the report file\r\n   * @returns The result of the download operation\r\n   */\r\n  downloadReportFile(params?: any){\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.postBlob(\r\n        API.downloadReportFile,\r\n        params,\r\n        headers\r\n      );\r\n    }\r\n    return null;\r\n  }\r\n  /**\r\n   * Sends a report based on the given parameters.\r\n   * @param params Optional parameters for sending the report\r\n   * @returns The result of the send operation\r\n   */\r\n  sendReport(params?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(\r\n        // The endpoint for sending a report. The report will be sent to the specified email address.\r\n        API.sendReport,\r\n        params,\r\n        // The custom headers for the request\r\n        headers\r\n      );\r\n    }\r\n    return null;\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/common/app.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\n\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { ApiService } from '../../../core/http-client/api.service';\r\nimport { getHeaders } from '../../utils/req-res.util';\r\nimport { API } from '../../constants/api-constants';\r\nimport { Observable } from 'rxjs';\r\nimport { CloneDsqPayload, CommonApiResponse, GetDataJsonByTypePayload, PerformanceAnalyticsPayload, RefreshGlobalSearchDataPayload, RegisterAppObjectsPayload, ReportPayload, ScreenPerformancePayload, SyncAppFieldsPayload } from '../../interfaces/common-api.interface';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class AppHelper {\r\n  private readonly apiService = inject(ApiService);\r\n\r\n  /**\r\n   * Rebuilds the application.\r\n   * @returns Result of the rebuild operation\r\n   */\r\n  rebuildApp(): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.buildApp, {}, headers);\r\n  }\r\n\r\n  // /**\r\n  //  * Publishes the application.\r\n  //  * @param params Optional parameters for publishing the application\r\n  //  * @returns Result of the publish operation\r\n  //  */\r\n  // publishApp(params?: any) {\r\n  //   const headers = getHeaders();\r\n  //   if (headers) {\r\n  //     return this.apiService.get(API.publishApp, params, headers);\r\n  //   }\r\n  //   return null;\r\n  // }\r\n\r\n  /**\r\n   * Retrieves screen data.\r\n   * @param params Optional parameters for retrieving screen data\r\n   * @returns Screen data\r\n   */\r\n  getScreen(params?: any) {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.get(API.getScreen, params, headers);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Retrieves schema data.\r\n   * @returns Subscription for getting schema data\r\n   */\r\n  getSchema(): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.get(API.getSchema, undefined, headers);\r\n  }\r\n\r\n  // storeSchemaIntoIDB(){\r\n  //   // this.idbService.clearIndexedDB()\r\n  //   this.getSchema()?.subscribe({\r\n  //     next: (value: SchemaResponse) => {\r\n  //         Common.tabJson = JSON.parse(value.Result);\r\n  //         this.idbService.setItem(StorageConstants.tabData, JSON.parse(value.Result))\r\n  //     },\r\n  //     error: (response: Error) => {\r\n  //         console.log(response)\r\n  //     }\r\n  // })\r\n  // }\r\n\r\n  /**\r\n   * Retrieves permission data.\r\n   * @returns Subscription for getting permission data\r\n   */\r\n  getPermission(): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.get(API.getPermission, undefined, headers);\r\n  }\r\n\r\n  /**\r\n   * Registers application objects.\r\n   * @param payload Parameters for registering application objects\r\n   * @returns Result of the registration operation\r\n   */\r\n  registerAppObjects(payload: RegisterAppObjectsPayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.registerAppObjects, payload, headers);\r\n  }\r\n\r\n  /**\r\n   * Clones a DataSourceQuery (DSQ) with the given parameters.\r\n   * @param payload parameters for cloning the DSQ\r\n   * @returns The result of the cloning operation\r\n   */\r\n  cloneDsq(payload: CloneDsqPayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.cloneDsq, payload, headers);\r\n  }\r\n\r\n  /**\r\n   * Retrieves data in JSON format based on the given JSON type and request tokens.\r\n   * @param payload Payload containing the JSON type and request tokens\r\n   * @returns The JSON data retrieved\r\n   */\r\n  getDataJsonByType(payload: GetDataJsonByTypePayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.GetDataJsonByType, payload, headers);\r\n  }\r\n\r\n  /**\r\n   * Syncs the fields of the application object with the given parameters.\r\n   * @param payload Parameters for syncing the fields\r\n   * @returns The result of the synchronization operation\r\n   */\r\n  syncAppFields(payload: SyncAppFieldsPayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.SyncAppFields, payload, headers);\r\n  }\r\n\r\n  /**\r\n   * Sets the tab components for the given tenant\r\n   * @param connectionId The ID of the connection\r\n   * @returns An observable of the response from the API\r\n   */\r\n  setTabComponents(connectionId: string): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(`${API.setTabComponents}/${connectionId}`, {}, headers);\r\n  }\r\n\r\n  /**\r\n   * Gets the result of the validation for the given connection\r\n   * @param connectionId The ID of the connection\r\n   * @returns An observable of the response from the API\r\n   */\r\n  performValidation(connectionId: string): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.get(`${API.performValidation}/${connectionId}`, undefined, headers);\r\n  }\r\n\r\n  /**\r\n   * Tests the connection for the given connection ID.\r\n   * @param connectionId The ID of the connection\r\n   * @returns An observable of the response from the API\r\n   */\r\n  testConnection(connectionId: string): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.get(`${API.testConnection}/${connectionId}`, undefined, headers);\r\n  }\r\n\r\n  /**\r\n   * Refreshes the global search data using the provided payload.\r\n   * @param data Payload containing the query object ID for refreshing search data\r\n   * @returns An observable of the API response\r\n   */\r\n  refreshGlobalSearchData(data: RefreshGlobalSearchDataPayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(`${API.RefreshGlobalSearchData}`, data, headers);\r\n  }\r\n\r\n  /**\r\n   * Exports a report based on the given parameters.\r\n   * @param payload Parameters for exporting the report\r\n   * @returns The result of the export operation\r\n   */\r\n  exportReport(payload: ReportPayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.exportReport, payload, headers);\r\n  }\r\n\r\n  /**\r\n   * Downloads a report file based on the given parameters.\r\n   * @param payload Parameters for downloading the report file\r\n   * @returns The result of the download operation\r\n   */\r\n  downloadReport(payload: ReportPayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.postBlob(API.downloadReportFile, payload, headers);\r\n  }\r\n\r\n  /**\r\n   * Sends a report based on the given parameters.\r\n   * @param payload Parameters for sending the report\r\n   * @returns The result of the send operation\r\n   */\r\n  sendReport(payload: ReportPayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.sendReport, payload, headers);\r\n  }\r\n\r\n  /**\r\n   * Retrieves the detailed analytics of a screen's performance.\r\n   * @param data - Data to be sent to the API\r\n   * @returns Response from the API\r\n   */\r\n  getDetailOfPerformanceAnalytics(data: PerformanceAnalyticsPayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.GetDetailOfPerformanceAnalytics, data, headers);\r\n  }\r\n\r\n  /**\r\n   * Get summary of performance analytics\r\n   * @param data - Data to be sent to the API\r\n   * @returns Response from the API\r\n   */\r\n  getSummaryOfPerformanceAnalytics(data: PerformanceAnalyticsPayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.GetSummaryOfPerformanceAnalytics, data, headers);\r\n  }\r\n\r\n  /**\r\n   * Insert Screen Performance Statistics\r\n   * @param data - Data to insert\r\n   * @returns Response from the API\r\n   */\r\n  insertScreenPerformanceStatistics(data: ScreenPerformancePayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(API.InsertScreenPerformanceAnalytics, data, headers);\r\n  }\r\n}"]}

package/esm2022/lib/tab-core-utility/app/helpers/screen/media-upload.helpers.mjs

@@ -2,106 +2,95 @@
 import { Injectable, inject } from '@angular/core';
 import { ApiService } from '../../../core/http-client/api.service';
 import { getFormDataHeaders, getHeaders } from '../../utils/req-res.util';
-import { of } from 'rxjs';
 import { API } from '../../constants/api-constants';
 import * as i0 from "@angular/core";
 export class MediaUploadHelper {
     constructor() {
         this.apiService = inject(ApiService);
     }
-    /**
-     * Uploads media object to the server.
-     * @param mediaObject The media object to upload.
-     * @returns An Observable that emits the response from the server.
-     */
-    uploadMediaFile(mediaObject) {
-        const headers = getFormDataHeaders();
-        if (headers) {
-            return this.apiService.post(`${API.fileUpload}`, mediaObject, headers);
-        }
-        return of(null);
-    }
+    // /**
+    //  * Uploads media object to the server.
+    //  * @param mediaObject The media object to upload.
+    //  * @returns An Observable that emits the response from the server.
+    //  */
+    // uploadMediaFile(mediaObject: any): Observable<any> {
+    //   const headers = getFormDataHeaders();
+    //   if (headers) {
+    //     return this.apiService.post(`${API.fileUpload}`, mediaObject, headers);
+    //   }
+    //   return of(null);
+    // }
     /**
      * Uploads multiple media objects to the server.
-     * @param mediaObjects An array of media objects to upload.
+     * @param payload An array of media objects to upload.
      * @returns An Observable that emits the response from the server.
      */
-    uploadMultipleMediaFile(mediaObjects, headers) {
+    uploadMediaFiles(payload, headers) {
         if (!headers) {
             // Get the headers for FormData
             headers = getFormDataHeaders();
         }
         // If headers are available, make a POST request to upload the media objects
-        if (headers) {
-            return this.apiService.post(`${API.multipleFileUpload}`, mediaObjects, headers);
-        }
-        // If headers are not available, return an Observable that emits null
-        return of(null);
-    }
-    /**
-     * Retrieves a file from the server by its media ID.
-     * @param mediaId The ID of the media file to retrieve.
-     * @returns An Observable that emits the file as a Blob.
-     */
-    getFileByMediaId(mediaId, params) {
-        const headers = getHeaders();
-        if (headers) {
-            return this.apiService.getBlob(`${API.getMediaFile}?mediaId=${mediaId}`, params, headers);
-        }
-        return of();
-    }
-    /**
-     * Downloads all files from the given URL.
-     * @param endPointName The URL to download files from.
-     * @returns An Observable that emits the downloaded files as a Blob.
-     */
-    downloadAllFiles(endPointName) {
-        return this.apiService.getBlob(endPointName);
-    }
-    /**
-     * Downloads PDF files from the given URL.
-     * @param endPointName The URL to download PDF files from.
-     * @param data The data to send along with the request.
-     * @returns An Observable that emits the downloaded PDF files as a Blob.
-     */
-    downloadPdfFiles(endPointName, data) {
-        const headers = getHeaders();
-        if (headers) {
-            return this.apiService.postBlob(endPointName, data, headers);
-        }
-        return of();
-    }
-    /**
-     * Retrieves an image from the server by its media ID.
-     * @param mediaId The ID of the media file to retrieve.
-     * @returns An Observable that emits the image as a Blob.
-     */
-    getImageByMediaId(mediaId, params) {
-        const headers = getHeaders();
-        if (headers) {
-            const endPointName = `${API.getImage}?mediaId=${mediaId}`;
-            return this.apiService.get(endPointName, params, headers);
-        }
-        return of();
+        return this.apiService.post(`${API.multipleFileUpload}`, payload, headers);
     }
+    // /**
+    //  * Retrieves a file from the server by its media ID.
+    //  * @param mediaId The ID of the media file to retrieve.
+    //  * @returns An Observable that emits the file as a Blob.
+    //  */
+    // getFileByMediaId(mediaId: number, params?: any): Observable<Blob> {
+    //   const headers = getHeaders();
+    //   if (headers) {
+    //     return this.apiService.getBlob(`${API.getMediaFile}?mediaId=${mediaId}`, params, headers);
+    //   }
+    //   return of();
+    // }
+    // /**
+    //  * Downloads all files from the given URL.
+    //  * @param endPointName The URL to download files from.
+    //  * @returns An Observable that emits the downloaded files as a Blob.
+    //  */
+    // downloadAllFiles(endPointName: any): Observable<Blob> {
+    //   return this.apiService.getBlob(endPointName);
+    // }
+    // /**
+    //  * Downloads PDF files from the given URL.
+    //  * @param endPointName The URL to download PDF files from.
+    //  * @param data The data to send along with the request.
+    //  * @returns An Observable that emits the downloaded PDF files as a Blob.
+    //  */
+    // downloadPdfFiles(endPointName: any, data: any): Observable<Blob> {
+    //   const headers = getHeaders();
+    //   if (headers) {
+    //     return this.apiService.postBlob(endPointName, data, headers);
+    //   }
+    //   return of();
+    // }
+    // /**
+    //  * Retrieves an image from the server by its media ID.
+    //  * @param mediaId The ID of the media file to retrieve.
+    //  * @returns An Observable that emits the image as a Blob.
+    //  */
+    // getImageByMediaId(mediaId: any, params?: any): Observable<Blob> {
+    //   const headers = getHeaders();
+    //   if (headers) {
+    //     const endPointName = `${API.getImage}?mediaId=${mediaId}`;
+    //     return this.apiService.get<Blob>(endPointName, params, headers);
+    //   }
+    //   return of();
+    // }
     /**
      * Removes a file from the server by its media ID.
      * @param mediaId The ID of the media file to remove.
-     * @param params Optional parameters to send with the request.
      * @returns An Observable that emits the deleted file as a Blob.
      */
-    removeFileByMediaId(mediaId, body) {
+    removeMediaFile(mediaId) {
         // Get the headers for the request
         const headers = getHeaders();
-        // If headers are available, make a GET request to delete the file
-        if (headers) {
-            // Construct the endpoint URL with the media ID
-            const endPointName = `${API.deleteFile}?MediaId=${mediaId}`;
-            // Make the GET request to delete the file and return the response as a Blob
-            return this.apiService.post(endPointName, body, headers);
-        }
-        // If headers are not available, return an Observable that emits null
-        return of(null);
+        // Construct the endpoint URL with the media ID
+        const endPointName = `${API.deleteFile}?MediaId=${mediaId}`;
+        // Make the GET request to delete the file and return the response as a Blob
+        return this.apiService.post(endPointName, undefined, headers);
     }
     static { this.ɵfac = function MediaUploadHelper_Factory(t) { return new (t || MediaUploadHelper)(); }; }
     static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: MediaUploadHelper, factory: MediaUploadHelper.ɵfac, providedIn: 'root' }); }
@@ -110,4 +99,4 @@ export class MediaUploadHelper {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"media-upload.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/screen/media-upload.helpers.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { ApiService } from '../../../core/http-client/api.service';\r\nimport { getFormDataHeaders, getHeaders } from '../../utils/req-res.util';\r\nimport { Observable, of } from 'rxjs';\r\nimport { API } from '../../constants/api-constants';\r\n@Injectable({ providedIn: 'root' })\r\nexport class MediaUploadHelper {\r\n  private readonly apiService = inject(ApiService);\r\n\r\n  /**\r\n   * Uploads media object to the server.\r\n   * @param mediaObject The media object to upload.\r\n   * @returns An Observable that emits the response from the server.\r\n   */\r\n  uploadMediaFile(mediaObject: any): Observable<any> {\r\n    const headers = getFormDataHeaders();\r\n    if (headers) {\r\n      return this.apiService.post(`${API.fileUpload}`, mediaObject, headers);\r\n    }\r\n    return of(null);\r\n  }\r\n\r\n  /**\r\n   * Uploads multiple media objects to the server.\r\n   * @param mediaObjects An array of media objects to upload.\r\n   * @returns An Observable that emits the response from the server.\r\n   */\r\n  uploadMultipleMediaFile(mediaObjects: any, headers?: any): Observable<any> {\r\n    if(!headers){\r\n      // Get the headers for FormData\r\n      headers = getFormDataHeaders();\r\n    }\r\n    \r\n    // If headers are available, make a POST request to upload the media objects\r\n    if (headers) {\r\n      return this.apiService.post(`${API.multipleFileUpload}`, mediaObjects, headers);\r\n    }\r\n    \r\n    // If headers are not available, return an Observable that emits null\r\n    return of(null);\r\n  }\r\n\r\n  /**\r\n   * Retrieves a file from the server by its media ID.\r\n   * @param mediaId The ID of the media file to retrieve.\r\n   * @returns An Observable that emits the file as a Blob.\r\n   */\r\n  getFileByMediaId(mediaId: number, params?: any): Observable<Blob> {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.getBlob(`${API.getMediaFile}?mediaId=${mediaId}`, params, headers);\r\n    }\r\n    return of();\r\n  }\r\n\r\n  /**\r\n   * Downloads all files from the given URL.\r\n   * @param endPointName The URL to download files from.\r\n   * @returns An Observable that emits the downloaded files as a Blob.\r\n   */\r\n  downloadAllFiles(endPointName: any): Observable<Blob> {\r\n    return this.apiService.getBlob(endPointName);\r\n  }\r\n\r\n  /**\r\n   * Downloads PDF files from the given URL.\r\n   * @param endPointName The URL to download PDF files from.\r\n   * @param data The data to send along with the request.\r\n   * @returns An Observable that emits the downloaded PDF files as a Blob.\r\n   */\r\n  downloadPdfFiles(endPointName: any, data: any): Observable<Blob> {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.postBlob(endPointName, data, headers);\r\n    }\r\n    return of();\r\n  }\r\n\r\n  /**\r\n   * Retrieves an image from the server by its media ID.\r\n   * @param mediaId The ID of the media file to retrieve.\r\n   * @returns An Observable that emits the image as a Blob.\r\n   */\r\n  getImageByMediaId(mediaId: any, params?: any): Observable<Blob> {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      const endPointName = `${API.getImage}?mediaId=${mediaId}`;\r\n      return this.apiService.get<Blob>(endPointName, params, headers);\r\n    }\r\n    return of();\r\n  }\r\n\r\n  /**\r\n   * Removes a file from the server by its media ID.\r\n   * @param mediaId The ID of the media file to remove.\r\n   * @param params Optional parameters to send with the request.\r\n   * @returns An Observable that emits the deleted file as a Blob.\r\n   */\r\n  removeFileByMediaId(mediaId: any, body?: any): Observable<Blob|null> {\r\n    // Get the headers for the request\r\n    const headers = getHeaders();\r\n\r\n    // If headers are available, make a GET request to delete the file\r\n    if (headers) {\r\n      // Construct the endpoint URL with the media ID\r\n      const endPointName = `${API.deleteFile}?MediaId=${mediaId}`;\r\n      \r\n      // Make the GET request to delete the file and return the response as a Blob\r\n      return this.apiService.post(endPointName, body, headers);\r\n    }\r\n    \r\n    // If headers are not available, return an Observable that emits null\r\n    return of(null);\r\n  }\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"media-upload.helpers.js","sourceRoot":"","sources":["../../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/helpers/screen/media-upload.helpers.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,uCAAuC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE1E,OAAO,EAAE,GAAG,EAAE,MAAM,+BAA+B,CAAC;;AAGpD,MAAM,OAAO,iBAAiB;IAD9B;QAEmB,eAAU,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;KA+FlD;IA7FC,MAAM;IACN,yCAAyC;IACzC,oDAAoD;IACpD,qEAAqE;IACrE,MAAM;IACN,uDAAuD;IACvD,0CAA0C;IAC1C,mBAAmB;IACnB,8EAA8E;IAC9E,MAAM;IACN,qBAAqB;IACrB,IAAI;IAEJ;;;;OAIG;IACH,gBAAgB,CAAC,OAAgC,EAAE,OAAa;QAC9D,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,+BAA+B;YAC/B,OAAO,GAAG,kBAAkB,EAAE,CAAC;QACjC,CAAC;QAED,4EAA4E;QAC5E,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,kBAAkB,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAC7E,CAAC;IAED,MAAM;IACN,uDAAuD;IACvD,0DAA0D;IAC1D,2DAA2D;IAC3D,MAAM;IACN,sEAAsE;IACtE,kCAAkC;IAClC,mBAAmB;IACnB,iGAAiG;IACjG,MAAM;IACN,iBAAiB;IACjB,IAAI;IAEJ,MAAM;IACN,6CAA6C;IAC7C,yDAAyD;IACzD,uEAAuE;IACvE,MAAM;IACN,0DAA0D;IAC1D,kDAAkD;IAClD,IAAI;IAEJ,MAAM;IACN,6CAA6C;IAC7C,6DAA6D;IAC7D,0DAA0D;IAC1D,2EAA2E;IAC3E,MAAM;IACN,qEAAqE;IACrE,kCAAkC;IAClC,mBAAmB;IACnB,oEAAoE;IACpE,MAAM;IACN,iBAAiB;IACjB,IAAI;IAEJ,MAAM;IACN,yDAAyD;IACzD,0DAA0D;IAC1D,4DAA4D;IAC5D,MAAM;IACN,oEAAoE;IACpE,kCAAkC;IAClC,mBAAmB;IACnB,iEAAiE;IACjE,uEAAuE;IACvE,MAAM;IACN,iBAAiB;IACjB,IAAI;IAEJ;;;;OAIG;IACH,eAAe,CAAC,OAAe;QAC7B,kCAAkC;QAClC,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;QAE7B,+CAA+C;QAC/C,MAAM,YAAY,GAAG,GAAG,GAAG,CAAC,UAAU,YAAY,OAAO,EAAE,CAAC;QAE5D,4EAA4E;QAC5E,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IAChE,CAAC;kFA/FU,iBAAiB;uEAAjB,iBAAiB,WAAjB,iBAAiB,mBADJ,MAAM;;iFACnB,iBAAiB;cAD7B,UAAU;eAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { ApiService } from '../../../core/http-client/api.service';\r\nimport { getFormDataHeaders, getHeaders } from '../../utils/req-res.util';\r\nimport { Observable } from 'rxjs';\r\nimport { API } from '../../constants/api-constants';\r\nimport { CommonApiResponse, UploadMediaFilesPayload } from '../../interfaces/common-api.interface';\r\n@Injectable({ providedIn: 'root' })\r\nexport class MediaUploadHelper {\r\n  private readonly apiService = inject(ApiService);\r\n\r\n  // /**\r\n  //  * Uploads media object to the server.\r\n  //  * @param mediaObject The media object to upload.\r\n  //  * @returns An Observable that emits the response from the server.\r\n  //  */\r\n  // uploadMediaFile(mediaObject: any): Observable<any> {\r\n  //   const headers = getFormDataHeaders();\r\n  //   if (headers) {\r\n  //     return this.apiService.post(`${API.fileUpload}`, mediaObject, headers);\r\n  //   }\r\n  //   return of(null);\r\n  // }\r\n\r\n  /**\r\n   * Uploads multiple media objects to the server.\r\n   * @param payload An array of media objects to upload.\r\n   * @returns An Observable that emits the response from the server.\r\n   */\r\n  uploadMediaFiles(payload: UploadMediaFilesPayload, headers?: any): Observable<CommonApiResponse> {\r\n    if (!headers) {\r\n      // Get the headers for FormData\r\n      headers = getFormDataHeaders();\r\n    }\r\n\r\n    // If headers are available, make a POST request to upload the media objects\r\n    return this.apiService.post(`${API.multipleFileUpload}`, payload, headers);\r\n  }\r\n\r\n  // /**\r\n  //  * Retrieves a file from the server by its media ID.\r\n  //  * @param mediaId The ID of the media file to retrieve.\r\n  //  * @returns An Observable that emits the file as a Blob.\r\n  //  */\r\n  // getFileByMediaId(mediaId: number, params?: any): Observable<Blob> {\r\n  //   const headers = getHeaders();\r\n  //   if (headers) {\r\n  //     return this.apiService.getBlob(`${API.getMediaFile}?mediaId=${mediaId}`, params, headers);\r\n  //   }\r\n  //   return of();\r\n  // }\r\n\r\n  // /**\r\n  //  * Downloads all files from the given URL.\r\n  //  * @param endPointName The URL to download files from.\r\n  //  * @returns An Observable that emits the downloaded files as a Blob.\r\n  //  */\r\n  // downloadAllFiles(endPointName: any): Observable<Blob> {\r\n  //   return this.apiService.getBlob(endPointName);\r\n  // }\r\n\r\n  // /**\r\n  //  * Downloads PDF files from the given URL.\r\n  //  * @param endPointName The URL to download PDF files from.\r\n  //  * @param data The data to send along with the request.\r\n  //  * @returns An Observable that emits the downloaded PDF files as a Blob.\r\n  //  */\r\n  // downloadPdfFiles(endPointName: any, data: any): Observable<Blob> {\r\n  //   const headers = getHeaders();\r\n  //   if (headers) {\r\n  //     return this.apiService.postBlob(endPointName, data, headers);\r\n  //   }\r\n  //   return of();\r\n  // }\r\n\r\n  // /**\r\n  //  * Retrieves an image from the server by its media ID.\r\n  //  * @param mediaId The ID of the media file to retrieve.\r\n  //  * @returns An Observable that emits the image as a Blob.\r\n  //  */\r\n  // getImageByMediaId(mediaId: any, params?: any): Observable<Blob> {\r\n  //   const headers = getHeaders();\r\n  //   if (headers) {\r\n  //     const endPointName = `${API.getImage}?mediaId=${mediaId}`;\r\n  //     return this.apiService.get<Blob>(endPointName, params, headers);\r\n  //   }\r\n  //   return of();\r\n  // }\r\n\r\n  /**\r\n   * Removes a file from the server by its media ID.\r\n   * @param mediaId The ID of the media file to remove.\r\n   * @returns An Observable that emits the deleted file as a Blob.\r\n   */\r\n  removeMediaFile(mediaId: string): Observable<CommonApiResponse> {\r\n    // Get the headers for the request\r\n    const headers = getHeaders();\r\n\r\n    // Construct the endpoint URL with the media ID\r\n    const endPointName = `${API.deleteFile}?MediaId=${mediaId}`;\r\n\r\n    // Make the GET request to delete the file and return the response as a Blob\r\n    return this.apiService.post(endPointName, undefined, headers);\r\n  }\r\n}"]}

package/esm2022/lib/tab-core-utility/app/interfaces/common-api.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLWFwaS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RhdGEtYWNjZXNzL3NyYy9saWIvdGFiLWNvcmUtdXRpbGl0eS9hcHAvaW50ZXJmYWNlcy9jb21tb24tYXBpLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWV4cGxpY2l0LWFueSAqL1xuZXhwb3J0IGludGVyZmFjZSBBcGlSZXNwb25zZSB7XG4gIHJlcXVlc3RJZDogc3RyaW5nO1xuICBpc1N1Y2Nlc3M6IGJvb2xlYW47XG4gIHJlc3VsdDogYW55O1xuICBlcnJvcnM6IHN0cmluZ1tdO1xufVxuZXhwb3J0IGludGVyZmFjZSBSZWNvcmRJbmZvIHtcbiAgaXNTeXN0ZW1SZWNvcmQ6IGJvb2xlYW4gfCBudWxsO1xuICBibHVlcHJpbnRJZDogc3RyaW5nIHwgbnVsbDtcbiAgYmx1ZXByaW50U3RhdHVzSWQ6IHN0cmluZyB8IG51bGw7XG4gIHJlY29yZElkOiBzdHJpbmc7XG4gIHByaW1hcnlLZXk6IHN0cmluZztcbn1cblxuXG5leHBvcnQgaW50ZXJmYWNlIENvbW1vbkFwaVJlc3BvbnNlIHtcbiAgUmVxdWVzdElkOiBzdHJpbmdcbiAgSXNTdWNjZXNzOiBib29sZWFuXG4gIFJlc3VsdDogc3RyaW5nIHwgYW55W11cbiAgU3RhdHVzQ29kZTogc3RyaW5nXG4gIFJlY29yZEFmZmVjdHRlZDogbnVtYmVyXG4gIFRvdGFsUmVjb3JkczogbnVtYmVyXG4gIFRvdGFsRXhlY3V0aW9uVGltZTogbnVtYmVyXG4gIExvZzogYW55W11cbiAgRXJyb3JzOiBhbnlbXVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIEdldFNjcmVlbkNvbmZpZyB7IFxuICBsYXlvdXRJZD86IHN0cmluZzsgXG4gIHZlcnNpb24/OiBzdHJpbmcgXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUHJvY2Vzc1JlcXVlc3RQYXlsb2FkIHtcbiAgU2NyZWVuSWQ6IHN0cmluZyxcbiAgRGF0YTogYW55XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVGVtcGxhdGVQYXJzZVBheWxvYWQge1xuICBEYXRhU291cmNlTW9kZTogbnVtYmVyLFxuICBWYWx1ZTogc3RyaW5nLFxuICBUZW1wbGF0ZXZhcmlhYmxlczogc3RyaW5nXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgTmV4dFN0YXR1c1BheWxvYWQge1xuICByZWNvcmRJZDogc3RyaW5nLCBcbiAgYXBwT2JqZWN0SWQ6IHN0cmluZ1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFVwZGF0ZVN0YXR1c1BheWxvYWQgZXh0ZW5kcyBOZXh0U3RhdHVzUGF5bG9hZCB7XG4gIG5leHRQb3NzaWJsZVN0YXR1c0lkOiBzdHJpbmdcbn0iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLWFwaS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2RhdGEtYWNjZXNzL3NyYy9saWIvdGFiLWNvcmUtdXRpbGl0eS9hcHAvaW50ZXJmYWNlcy9jb21tb24tYXBpLmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSnNvblR5cGUgfSBmcm9tIFwiLi4vZW51bXMvY29tbW9uLmVudW1cIjtcblxuLyogZXNsaW50LWRpc2FibGUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWV4cGxpY2l0LWFueSAqL1xuZXhwb3J0IGludGVyZmFjZSBBcGlSZXNwb25zZSB7XG4gIHJlcXVlc3RJZDogc3RyaW5nO1xuICBpc1N1Y2Nlc3M6IGJvb2xlYW47XG4gIHJlc3VsdDogYW55O1xuICBlcnJvcnM6IHN0cmluZ1tdO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFJlY29yZEluZm8ge1xuICBpc1N5c3RlbVJlY29yZDogYm9vbGVhbiB8IG51bGw7XG4gIGJsdWVwcmludElkOiBzdHJpbmcgfCBudWxsO1xuICBibHVlcHJpbnRTdGF0dXNJZDogc3RyaW5nIHwgbnVsbDtcbiAgcmVjb3JkSWQ6IHN0cmluZztcbiAgcHJpbWFyeUtleTogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIENvbW1vbkFwaVJlc3BvbnNlIHtcbiAgUmVxdWVzdElkOiBzdHJpbmdcbiAgSXNTdWNjZXNzOiBib29sZWFuXG4gIFJlc3VsdDogYW55XG4gIFN0YXR1c0NvZGU6IHN0cmluZ1xuICBSZWNvcmRBZmZlY3R0ZWQ6IG51bWJlclxuICBUb3RhbFJlY29yZHM6IG51bWJlclxuICBUb3RhbEV4ZWN1dGlvblRpbWU6IG51bWJlclxuICBMb2c6IGFueVtdXG4gIEVycm9yczogYW55W11cbn1cblxuZXhwb3J0IGludGVyZmFjZSBHZXRTY3JlZW5Db25maWcge1xuICBsYXlvdXRJZD86IHN0cmluZztcbiAgdmVyc2lvbj86IHN0cmluZ1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFByb2Nlc3NSZXF1ZXN0UGF5bG9hZCB7XG4gIFNjcmVlbklkOiBzdHJpbmcsXG4gIERhdGE6IGFueVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIFRlbXBsYXRlUGFyc2VQYXlsb2FkIHtcbiAgRGF0YVNvdXJjZU1vZGU6IG51bWJlcixcbiAgVmFsdWU6IHN0cmluZyxcbiAgVGVtcGxhdGV2YXJpYWJsZXM6IHN0cmluZ1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIE5leHRTdGF0dXNQYXlsb2FkIHtcbiAgcmVjb3JkSWQ6IHN0cmluZyxcbiAgYXBwT2JqZWN0SWQ/OiBzdHJpbmdcbn1cblxuZXhwb3J0IGludGVyZmFjZSBVcGRhdGVTdGF0dXNQYXlsb2FkIGV4dGVuZHMgTmV4dFN0YXR1c1BheWxvYWQge1xuICBuZXh0UG9zc2libGVTdGF0dXNJZDogc3RyaW5nXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmVnaXN0ZXJBcHBPYmplY3RzUGF5bG9hZCB7XG4gIENvbm5lY3Rpb25JZDogc3RyaW5nLFxuICBUYWJsZXM6IHN0cmluZ1tdLFxuICBWaWV3czogc3RyaW5nW11cbn1cblxuZXhwb3J0IGludGVyZmFjZSBDbG9uZURzcVBheWxvYWQge1xuICBEU1FJZDogc3RyaW5nLFxuICBRdWVyeU5hbWU6IHN0cmluZyxcbn1cblxuZXhwb3J0IGludGVyZmFjZSBHZXREYXRhSnNvbkJ5VHlwZVBheWxvYWQge1xuICBKc29uVHlwZTogSnNvblR5cGUsXG4gIFJlcXRva2Vucz86IGFueVxufVxuXG5leHBvcnQgaW50ZXJmYWNlIFN5bmNBcHBGaWVsZHNQYXlsb2FkIHtcbiAgQ29ubmVjdGlvbklkOiBzdHJpbmc7XG4gIEFwcE9iamVjdElkOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUmVmcmVzaEdsb2JhbFNlYXJjaERhdGFQYXlsb2FkIHtcbiAgUXVlcnlPYmplY3RJRDogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFVwbG9hZE1lZGlhRmlsZVBheWxvYWQge1xuICBCYXNlNjRTdHJpbmc6IHN0cmluZztcbiAgRmlsZU5hbWU6IHN0cmluZztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBVcGxvYWRNZWRpYUZpbGVzUGF5bG9hZCB7XG4gIFVwbG9hZEZpbGVzOiBVcGxvYWRNZWRpYUZpbGVQYXlsb2FkW11cbn1cblxuZXhwb3J0IGludGVyZmFjZSBSZXBvcnRQYXlsb2FkIHtcbiAgRGF0YVJlcG9ydElkOiBzdHJpbmcsXG4gIFJlcXRva2VuczogYW55XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgUGVyZm9ybWFuY2VBbmFseXRpY3NQYXlsb2FkIHtcbiAgdHlwZTogc3RyaW5nLFxuICB2YWx1ZTogc3RyaW5nLFxuICBmcm9tRGF0ZTogc3RyaW5nLFxuICB0b0RhdGU6IHN0cmluZyxcbiAgbGltaXQ/OiBudW1iZXJcbn1cblxuZXhwb3J0IGludGVyZmFjZSBTY3JlZW5QZXJmb3JtYW5jZVBheWxvYWQge1xuICB2YWx1ZTogc3RyaW5nLFxuICBsb2FkVGltZTogbnVtYmVyLFxuICB0YWdzOiB7XG4gICAgZHNxSWRzOiBzdHJpbmdbXSxcbiAgICBhcHBPYmplY3RJZHM6IHN0cmluZ1tdXG4gIH1cbn0iXX0=

package/lib/tab-core-utility/app/crud/tab-get.service.d.ts

@@ -51,14 +51,6 @@ export declare class TabGetService {
      */
     executeSelectQueryById(selectQueryId: string, parameters?: any): any;
     removeWhereClauseForEmptyParams(filters: any[], parameters: Record<string, any>): any[];
-    getTestConnection(connectionId: any, params?: any): any;
-    getPerformValidation(connectionId: any, params?: any): any;
-    /**
-     * Sets the tab components for the given tenant
-     * @param connectionId The ID of the connection
-     * @returns An observable of the response from the API
-     */
-    setTabComponentsForTenant(connectionId: string, data?: any): any;
     /**
      * Get Search Data
      * @param searchQuery - Search Query string
@@ -66,12 +58,6 @@ export declare class TabGetService {
      * @returns Response from the API
      */
     getSearchData(searchQuery: string, limit: number, params?: any): any;
-    /**
-     * Insert Screen Performance Statistics
-     * @param data - Data to insert
-     * @returns Response from the API
-     */
-    insertScreenPerformanceStatistics(data: any): any;
     /**
      * Executes an HTTP request with the specified method, URL, headers, and body.
      *
@@ -88,24 +74,6 @@ export declare class TabGetService {
      * @returns The result of the generated HTTP request
      */
     generateHttpRequest(QueryName: string): any;
-    /**
-     * Retrieves the detailed analytics of a screen's performance.
-     * @param data - Data to be sent to the API
-     * @returns Response from the API
-     */
-    getDetailOfPerformanceAnalytics(data: any): any;
-    /**
-     * Get summary of performance analytics
-     * @param data - Data to be sent to the API
-     * @returns Response from the API
-     */
-    getSummaryOfPerformanceAnalytics(data: any): any;
-    /**
-     * Refreshes the global search data.
-     * @param data - Data to be sent to the API
-     * @returns Response from the API
-     */
-    RefreshGlobalSearchData(data: any): any;
     static ɵfac: i0.ɵɵFactoryDeclaration<TabGetService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<TabGetService>;
 }