@techextensor/tab-core-utility 2.2.180 → 2.2.184

package/esm2022/lib/tab-core-utility/app/crud/tab-get.service.mjs

@@ -2,11 +2,11 @@
 import { Injectable, inject } from '@angular/core';
 import { ApiService } from '../../core/http-client/api.service';
 import { DSQHelper } from '../helpers/common/dsq.helpers';
+import { MetadataHelper } from '../helpers/common/meta-data.helpers';
 import { getHeaders } from '../utils/req-res.util';
-import { API } from '../constants/api-constants';
-import { getAppObject } from '../utils/tab-app.util';
+import { API, APIServices } from '../constants/api-constants';
+import { CRUDFilter, CRUDPager, CRUDSelectPayload, CRUDSort, CRUDWhereClause } from '../models/api-query.class';
 import { FilterValueType } from '../enums/dsq.enum';
-import { QueryType } from '../enums/query.enum';
 import { AppObjectsConstants, DataSourceQueriesConstants, } from '../constants/app-object-constants';
 import { switchMap } from 'rxjs';
 import * as i0 from "@angular/core";
@@ -14,15 +14,18 @@ export class TabGetService {
     constructor() {
         this.apiService = inject(ApiService);
         this.dsqHelper = inject(DSQHelper);
+        this.metadataHelper = inject(MetadataHelper);
     }
     /**
      * Execute RAW DSQ with Name
+     * NEW: Uses new backend endpoint and CRUD microservice
      * @param data - Object containing AppObjectName and DSQName
      * @returns Response from the API
      */
     executeRAWDSQWithName(data, headers) {
         const header = getHeaders(headers);
-        return this.apiService.post(`${API.getDSQ}/${data.AppObjectName}/${data.DSQName}`, data, header);
+        // NEW API: POST /Queries/execute/{objectName}/{dsqName} via CRUD service
+        return this.apiService.postToService(APIServices.crudService, `${API.QueriesExecute}/${data.AppObjectName}/${data.DSQName}`, data, header);
     }
     /**
      * Get Record
@@ -49,17 +52,17 @@ export class TabGetService {
     //   return null;
     // }
     /**
-     * Get History
+     * Get History from Kibana microservice
      * @param appObjectId - ID of the application object
      * @param recordIds - Array of record IDs
      * @returns Response from the API
      */
     getHistory(payload) {
-        const appObjectName = getAppObject(payload.appObjectId)?.ObjectName;
+        const appObjectName = this.metadataHelper.getAppObjectByIdOrName(payload.appObjectId)?.ObjectName;
         const headers = getHeaders();
-        return this.apiService.post(`${API.getHistory}`, {
-            ObjectName: appObjectName,
+        return this.apiService.postToService(APIServices.kibanaService, API.auditGetHistory, {
             RecordIds: payload.recordIds,
+            entityName: appObjectName
         }, headers);
     }
     /**
@@ -73,25 +76,44 @@ export class TabGetService {
     }
     /**
      * Executes a select query with optional parameters
-     * @param data - The select query data
+     * NEW: Uses new CRUD microservice endpoint with transformed payload
+     * @param data - The select query data (old format)
      * @param parameters - Optional parameters to be applied to the query
+     * @param additionalConfig - Optional additional configuration
      * @returns Result of the select query execution
      */
     selectExecutor(data, parameters, additionalConfig) {
+        // Prepare query data with parameters and config
+        const preparedData = this.prepareSelectQueryData(data, parameters, additionalConfig);
+        // Transform to new CRUD API payload format
+        const crudPayload = this.transformToCRUDPayload(preparedData);
+        // Call new CRUD microservice endpoint
+        const headers = getHeaders();
+        return this.apiService.postToService(APIServices.crudService, API.QueriesSelect, crudPayload, headers);
+    }
+    /**
+     * Prepares select query data by applying parameters and additional configuration
+     * @param data - The select query data
+     * @param parameters - Optional parameters to replace in filters
+     * @param additionalConfig - Optional additional configuration to merge
+     * @returns Prepared APISelectQuery with parameters applied
+     */
+    prepareSelectQueryData(data, parameters, additionalConfig) {
+        // Initialize WhereClause if parameters provided
         if (parameters && Object.keys(parameters).length) {
-            data.WhereClause.FilterLogic = data.WhereClause.FilterLogic || '[]';
-            data.WhereClause.Filters = data.WhereClause.Filters || [];
+            data.WhereClause.filterLogic = data.WhereClause.filterLogic || '[]';
+            data.WhereClause.filters = data.WhereClause.filters || [];
             data.WhereClause.SQLQuery = data.WhereClause.SQLQuery || '';
             /**
              * Replaces values from parameters if matched and in format of {{key}}.
-             * Example: if filter.Value is "{{userId}}" and
-             * this._value.parameters.userId is 123, then filter.Value will be replaced with
+             * Example: if filter.value is "{{userId}}" and
+             * this._value.parameters.userId is 123, then filter.value will be replaced with
              * "123".
              */
-            data.WhereClause.Filters.forEach((filter) => {
-                // filter.ValueType is 1 (literal)
-                if (filter.Value && filter.ValueType == FilterValueType.Literal) {
-                    // filter.Value = filter.Value.replace(
+            data.WhereClause.filters.forEach((filter) => {
+                // filter.valueType is 1 (literal)
+                if (filter.value && filter.valueType == FilterValueType.Literal) {
+                    // filter.value = filter.value.replace(
                     //   /{{([^}]+)}}/g,
                     //   (match: string, key: string) => {
                     //     const value = parameters[key];
@@ -101,25 +123,104 @@ export class TabGetService {
                 }
                 // if valueType = 2 (Parameters)
                 // then we need to replace the value with parameters and change the valueType to 1 (Literal)
-                else if (filter.ValueType == FilterValueType.Parameter) {
-                    filter.Value = filter.Value.replace(/([^}]+)/g, (match, key) => {
+                else if (filter.valueType == FilterValueType.Parameter) {
+                    filter.value = filter.value.replace(/([^}]+)/g, (match, key) => {
                         const value = parameters[key];
                         return value !== undefined ? value : null;
                     });
-                    filter.ValueType = FilterValueType.Literal;
+                    filter.valueType = FilterValueType.Literal;
                 }
             });
-            (data?.WhereClause?.Filters || []).forEach((element) => {
-                if (element.ValueType === FilterValueType.Parameter &&
-                    parameters[element.FieldID]) {
-                    element.Value = parameters[element.FieldID];
+            (data?.WhereClause?.filters || []).forEach((element) => {
+                if (element.valueType === FilterValueType.Parameter &&
+                    parameters[element.fieldName]) {
+                    element.value = parameters[element.fieldName];
                 }
             });
         }
-        if (additionalConfig && typeof additionalConfig === 'object') {
-            data = { ...data, ...additionalConfig };
-        }
-        return this.dsqHelper.executeQuery(data, QueryType.Select);
+        return data;
+    }
+    /**
+     * Transforms old APISelectQuery format to new CRUD API format
+     * @param apiSelectQuery - The old format select query
+     * @returns CRUDSelectPayload - The new format payload
+     */
+    transformToCRUDPayload(apiSelectQuery) {
+        const payload = new CRUDSelectPayload();
+        // Basic properties transformation
+        payload.EntityName = this.getEntityName(apiSelectQuery.QueryObjectID);
+        payload.SelectedFields = apiSelectQuery.ResultField_AppfieldIds || [];
+        payload.Distinct = apiSelectQuery.Distinct || false;
+        // Transform complex properties
+        payload.includes = this.transformJoinsToIncludes(apiSelectQuery.Joins);
+        payload.Pager = this.transformPager(apiSelectQuery.TopCount);
+        payload.whereClause = this.transformWhereClause(apiSelectQuery.WhereClause);
+        payload.Sort = this.transformSort(apiSelectQuery.Sort);
+        return payload;
+    }
+    /**
+     * Gets entity name from QueryObjectID
+     */
+    getEntityName(queryObjectId) {
+        const appObject = this.metadataHelper.getAppObjectByIdOrName(queryObjectId);
+        return appObject?.ObjectName || queryObjectId;
+    }
+    /**
+     * Transforms Joins to includes array
+     */
+    transformJoinsToIncludes(joins) {
+        if (!joins || joins.length === 0)
+            return undefined;
+        return joins.map((join) => join.Relationship?.childDetails?.LookupObject || join);
+    }
+    /**
+     * Transforms TopCount to Pager object
+     */
+    transformPager(topCount) {
+        if (!topCount)
+            return undefined;
+        const pager = new CRUDPager();
+        pager.pageNumber = 1;
+        pager.pageSize = topCount;
+        pager.returnTotalCount = true;
+        return pager;
+    }
+    /**
+     * Transforms WhereClause to new format
+     */
+    transformWhereClause(whereClause) {
+        if (!whereClause?.Filters || whereClause.Filters.length === 0)
+            return undefined;
+        const crudWhereClause = new CRUDWhereClause();
+        crudWhereClause.filters = whereClause.Filters.map((filter) => this.transformFilter(filter));
+        return crudWhereClause;
+    }
+    /**
+     * Transforms a single filter to new format
+     */
+    transformFilter(filter) {
+        const crudFilter = new CRUDFilter();
+        crudFilter.fieldName = filter.FieldID;
+        crudFilter.operator = filter.RelationalOperator;
+        crudFilter.value = filter.Value || filter.value;
+        crudFilter.valueType = filter.ValueType;
+        crudFilter.conjunction = filter.ConjuctionClause;
+        crudFilter.groupId = filter.GroupID;
+        crudFilter.sequence = filter.Sequence;
+        return crudFilter;
+    }
+    /**
+     * Transforms Sort array to new format
+     */
+    transformSort(sorts) {
+        if (!sorts || sorts.length === 0)
+            return undefined;
+        return sorts.map((sort) => {
+            const crudSort = new CRUDSort();
+            crudSort.FieldName = sort.FieldID;
+            crudSort.Direction = sort.SortSequence;
+            return crudSort;
+        });
     }
     /**
      * Executes a select query by its ID, using the provided parameters.
@@ -137,15 +238,15 @@ export class TabGetService {
                 ID: selectQueryId,
             },
         }).pipe(switchMap((res) => {
-            if (res.StatusCode === '200') {
+            if (res.IsSuccess && res.Result.length) {
                 const Configuration = JSON.parse(res.Result[0].Configuration || '{}');
-                if (Configuration.WhereClause?.Filters) {
-                    Configuration.WhereClause.Filters = this.removeWhereClauseForEmptyParams(Configuration.WhereClause.Filters, parameters || {});
+                if (Configuration.WhereClause?.filters) {
+                    Configuration.WhereClause.filters = this.removeWhereClauseForEmptyParams(Configuration.WhereClause.filters, parameters || {});
                 }
                 return this.selectExecutor(Configuration, parameters, additionalConfig);
             }
             else {
-                throw new Error(res.Message);
+                throw new Error(res.Message || 'Failed to fetch select query configuration.');
             }
         }));
     }
@@ -180,14 +281,14 @@ export class TabGetService {
     //   return null;
     // }
     /**
-     * Get Search Data
+     * Get Search Data from Kibana microservice
      * @param searchQuery - Search Query string
      * @param limit - Limit of search results
      * @returns Response from the API
      */
     getSearchData(payload, params) {
         const headers = getHeaders();
-        return this.apiService.get(`${API.search}?searchQuery=${payload.searchQuery}&limit=${payload.limit}${payload?.appObjectId ? `&appObjectId=${payload.appObjectId}` : ''}`, params, headers);
+        return this.apiService.getFromService(APIServices.kibanaService, `${API.globalSearch}?searchQuery=${payload.searchQuery}&limit=${payload.limit}${payload?.appObjectId ? `&appObjectId=${payload.appObjectId}` : ''}`, params, headers);
     }
     /**
      * Executes an HTTP request with the specified method, URL, headers, and body.
@@ -234,4 +335,4 @@ export class TabGetService {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-get.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/crud/tab-get.service.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 { DSQHelper } from '../helpers/common/dsq.helpers';\r\nimport { getHeaders } from '../utils/req-res.util';\r\nimport { API } from '../constants/api-constants';\r\nimport { getAppObject } from '../utils/tab-app.util';\r\nimport { APISelectQuery } from '../models/api-query.class';\r\nimport { FilterValueType } from '../enums/dsq.enum';\r\nimport { QueryType } from '../enums/query.enum';\r\nimport {\r\n  AppObjectsConstants,\r\n  DataSourceQueriesConstants,\r\n} from '../constants/app-object-constants';\r\nimport { Observable, switchMap } from 'rxjs';\r\nimport { CommonApiResponse, HttpExecuteRequestPayload, ImprotDataPayload, RcordHistoryPayload, SearchDataPayload } from '../interfaces/common.interface';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class TabGetService {\r\n  private readonly apiService = inject(ApiService);\r\n  private readonly dsqHelper = inject(DSQHelper);\r\n\r\n  /**\r\n   * Execute RAW DSQ with Name\r\n   * @param data - Object containing AppObjectName and DSQName\r\n   * @returns Response from the API\r\n   */\r\n  executeRAWDSQWithName(data: any,headers?:any): any {\r\n    const header = getHeaders(headers);\r\n      return this.apiService.post(\r\n        `${API.getDSQ}/${data.AppObjectName}/${data.DSQName}`,\r\n        data,\r\n        header\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Get Record\r\n   * @param params - Parameters for the request\r\n   * @returns Response from the API\r\n   */\r\n  getRecord(params: any): any {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.get(`${API.getrecord}`, params, headers);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  // /**\r\n  //  * Execute Raw SQL\r\n  //  * @param data - Data for the request\r\n  //  * @returns Response from the API\r\n  //  */\r\n  // executeRawSql(data: any): any {\r\n  //   const headers = getHeaders();\r\n  //   if (headers) {\r\n  //     return this.apiService.post(`${API.rawSQL}?query=${data}`, '', headers);\r\n  //   }\r\n  //   return null;\r\n  // }\r\n\r\n  /**\r\n   * Get History\r\n   * @param appObjectId - ID of the application object\r\n   * @param recordIds - Array of record IDs\r\n   * @returns Response from the API\r\n   */\r\n  getHistory(payload: RcordHistoryPayload): Observable<CommonApiResponse> {\r\n    const appObjectName = getAppObject(payload.appObjectId)?.ObjectName;\r\n    const headers = getHeaders();\r\n    return this.apiService.post(`${API.getHistory}`, {\r\n      ObjectName: appObjectName,\r\n      RecordIds: payload.recordIds,\r\n    }, headers);\r\n  }\r\n\r\n  /**\r\n   * PMJAY Import\r\n   * @param data - Data for PMJAY import\r\n   * @returns Response from the API\r\n   */\r\n  pmjayImport(data: ImprotDataPayload): any {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(`${API.pmjayImport}`, data, headers);\r\n  }\r\n\r\n  /**\r\n   * Executes a select query with optional parameters\r\n   * @param data - The select query data\r\n   * @param parameters - Optional parameters to be applied to the query\r\n   * @returns Result of the select query execution\r\n   */\r\n  selectExecutor(data: APISelectQuery, parameters?: any, additionalConfig?: any): Observable<CommonApiResponse> {\r\n    if (parameters && Object.keys(parameters).length) {\r\n      data.WhereClause.FilterLogic = data.WhereClause.FilterLogic || '[]';\r\n      data.WhereClause.Filters = data.WhereClause.Filters || [];\r\n      data.WhereClause.SQLQuery = data.WhereClause.SQLQuery || '';\r\n      /**\r\n       * Replaces values from parameters if matched and in format of {{key}}.\r\n       * Example: if filter.Value is \"{{userId}}\" and\r\n       * this._value.parameters.userId is 123, then filter.Value will be replaced with\r\n       * \"123\".\r\n       */\r\n      data.WhereClause.Filters.forEach((filter: any) => {\r\n        // filter.ValueType is 1 (literal)\r\n        if (filter.Value && filter.ValueType == FilterValueType.Literal) {\r\n          // filter.Value = filter.Value.replace(\r\n          //   /{{([^}]+)}}/g,\r\n          //   (match: string, key: string) => {\r\n          //     const value = parameters[key];\r\n          //     return value !== undefined ? value : null;\r\n          //   }\r\n          // );\r\n        }\r\n        // if valueType = 2 (Parameters)\r\n        // then we need to replace the value with parameters and change the valueType to 1 (Literal)\r\n        else if (filter.ValueType == FilterValueType.Parameter) {\r\n          filter.Value = filter.Value.replace(\r\n            /([^}]+)/g,\r\n            (match: string, key: string) => {\r\n              const value = parameters[key];\r\n              return value !== undefined ? value : null;\r\n            }\r\n          );\r\n          filter.ValueType = FilterValueType.Literal;\r\n        }\r\n      });\r\n      (data?.WhereClause?.Filters || []).forEach((element: any) => {\r\n        if (\r\n          element.ValueType === FilterValueType.Parameter &&\r\n          parameters[element.FieldID]\r\n        ) {\r\n          element.Value = parameters[element.FieldID];\r\n        }\r\n      });\r\n    }\r\n\r\n    if(additionalConfig && typeof additionalConfig === 'object') {\r\n      data = { ...data, ...additionalConfig };  \r\n    }\r\n\r\n    return this.dsqHelper.executeQuery(data, QueryType.Select) as Observable<CommonApiResponse>;\r\n  }\r\n\r\n  /**\r\n   * Executes a select query by its ID, using the provided parameters.\r\n   *\r\n   * @param selectQueryId - The ID of the select query to be executed.\r\n   * @param parameters - Optional parameters to be applied to the query.\r\n   * @returns The result of the select query execution.\r\n   * @throws An error if the API response status code is not '200'.\r\n   */\r\n  executeSelectQueryById(selectQueryId: string, parameters?: any, additionalConfig?: any): Observable<CommonApiResponse> {\r\n    return this.executeRAWDSQWithName({\r\n      AppObjectName: AppObjectsConstants.TABD_Queries,\r\n      DSQName: DataSourceQueriesConstants.Detail_TABD_Queries,\r\n      Reqtokens: {\r\n        ID: selectQueryId,\r\n      },\r\n    }).pipe(\r\n      switchMap((res: any) => {\r\n        if (res.StatusCode === '200') {\r\n          const Configuration = JSON.parse(res.Result[0].Configuration || '{}');\r\n          if (Configuration.WhereClause?.Filters) {\r\n            Configuration.WhereClause.Filters = this.removeWhereClauseForEmptyParams(Configuration.WhereClause.Filters, parameters || {});\r\n          }\r\n          return this.selectExecutor(Configuration, parameters, additionalConfig);\r\n        } else {\r\n          throw new Error(res.Message);\r\n        }\r\n      })\r\n    );\r\n  }\r\n  removeWhereClauseForEmptyParams(filters: any[], parameters: Record<string, any>): any[] {\r\n    return filters.filter((filter: any) => {\r\n        if (filter.ValueType === FilterValueType.Parameter) {\r\n            const parameterName = filter.Value;\r\n            if (parameterName in parameters && parameters[parameterName] === '') {\r\n                return false; // Remove filter\r\n            }\r\n        }\r\n        if (Object.keys(parameters || {}).length === 0 && filter.ValueType === FilterValueType.Parameter) {\r\n            return false; // Remove filter\r\n        }\r\n        return true; // Keep filter\r\n    });\r\n  }\r\n  \r\n  // /**\r\n  //  * Get Resource Language By Language Code\r\n  //  * @param languageCode - Language Code\r\n  //  * @returns Response from the API\r\n  //  */\r\n  // getResourceLanguageByLanguageCode(languageCode: number): any {\r\n  //   const headers = getHeaders();\r\n  //   if (headers) {\r\n  //     return this.apiService.post(\r\n  //       `${API.languageResource}`,\r\n  //       { LanguageCode: languageCode },\r\n  //       headers\r\n  //     );\r\n  //   }\r\n  //   return null;\r\n  // }\r\n\r\n  /**\r\n   * Get Search Data\r\n   * @param searchQuery - Search Query string\r\n   * @param limit - Limit of search results\r\n   * @returns Response from the API\r\n   */\r\n  getSearchData(payload: SearchDataPayload, params?: any): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.get(\r\n      `${API.search}?searchQuery=${payload.searchQuery}&limit=${payload.limit}${payload?.appObjectId ? `&appObjectId=${payload.appObjectId}` : ''}`,\r\n      params,\r\n      headers\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Executes an HTTP request with the specified method, URL, headers, and body.\r\n   *\r\n   * @param fullUrl -The full URL of the request containing the query parameters.\r\n   * @param method - The HTTP method to be used ('GET', 'POST', 'PUT', 'DELETE').\r\n   * @param headers - The headers to include in the request.\r\n   * @param body - The body content for methods like POST and PUT.\r\n   * @returns The API response corresponding to the request.\r\n   */\r\n  executeHttpRequest(payload: HttpExecuteRequestPayload): any {\r\n    const headers = {\r\n      ...(payload?.headers || {}),\r\n      'X-Skip-Interceptor': 'true',\r\n      'X-Skip-Auth': 'true',\r\n      'X-Track-API-Details': 'true',\r\n    };\r\n    if (payload.method == 'GET') {\r\n      return this.apiService.getByUrl(payload.fullUrl, { headers });\r\n    } else if (payload.method == 'POST') {\r\n      return this.apiService.postByUrl(payload.fullUrl, payload.body, { headers });\r\n    } else if (payload.method == 'PUT') {\r\n      return this.apiService.putByUrl(payload.fullUrl, payload.body, { headers });\r\n    } else if (payload.method == 'DELETE') {\r\n      return this.apiService.deleteByUrl(payload.fullUrl, { headers });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Generates an HTTP Request based on the provided DataSourceQuery name\r\n   * @param QueryName - The name of the DataSourceQuery\r\n   * @returns The result of the generated HTTP request\r\n   */\r\n  generateHttpRequest(dataSourceQueryName: string): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.get(\r\n      `${API.GenerateHttpRequest}?dsqName=${dataSourceQueryName}`,\r\n      undefined,\r\n      headers\r\n    );\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-get.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/crud/tab-get.service.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 { DSQHelper } from '../helpers/common/dsq.helpers';\r\nimport { MetadataHelper } from '../helpers/common/meta-data.helpers';\r\nimport { getHeaders } from '../utils/req-res.util';\r\nimport { API, APIServices } from '../constants/api-constants';\r\nimport { APISelectQuery, CRUDFilter, CRUDPager, CRUDSelectPayload, CRUDSort, CRUDWhereClause } from '../models/api-query.class';\r\nimport { FilterValueType } from '../enums/dsq.enum';\r\nimport {\r\n  AppObjectsConstants,\r\n  DataSourceQueriesConstants,\r\n} from '../constants/app-object-constants';\r\nimport { Observable, switchMap } from 'rxjs';\r\nimport { CommonApiResponse, HttpExecuteRequestPayload, ImprotDataPayload, RcordHistoryPayload, SearchDataPayload } from '../interfaces/common.interface';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class TabGetService {\r\n  private readonly apiService = inject(ApiService);\r\n  private readonly dsqHelper = inject(DSQHelper);\r\n  private readonly metadataHelper = inject(MetadataHelper);\r\n\r\n  /**\r\n   * Execute RAW DSQ with Name\r\n   * NEW: Uses new backend endpoint and CRUD microservice\r\n   * @param data - Object containing AppObjectName and DSQName\r\n   * @returns Response from the API\r\n   */\r\n  executeRAWDSQWithName(data: any, headers?: any): any {\r\n    const header = getHeaders(headers);\r\n    // NEW API: POST /Queries/execute/{objectName}/{dsqName} via CRUD service\r\n    return this.apiService.postToService(\r\n      APIServices.crudService,\r\n      `${API.QueriesExecute}/${data.AppObjectName}/${data.DSQName}`,\r\n      data,\r\n      header\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Get Record\r\n   * @param params - Parameters for the request\r\n   * @returns Response from the API\r\n   */\r\n  getRecord(params: any): any {\r\n    const headers = getHeaders();\r\n    if (headers) {\r\n      return this.apiService.get(`${API.getrecord}`, params, headers);\r\n    }\r\n    return null;\r\n  }\r\n\r\n  // /**\r\n  //  * Execute Raw SQL\r\n  //  * @param data - Data for the request\r\n  //  * @returns Response from the API\r\n  //  */\r\n  // executeRawSql(data: any): any {\r\n  //   const headers = getHeaders();\r\n  //   if (headers) {\r\n  //     return this.apiService.post(`${API.rawSQL}?query=${data}`, '', headers);\r\n  //   }\r\n  //   return null;\r\n  // }\r\n\r\n  /**\r\n   * Get History from Kibana microservice\r\n   * @param appObjectId - ID of the application object\r\n   * @param recordIds - Array of record IDs\r\n   * @returns Response from the API\r\n   */\r\n  getHistory(payload: RcordHistoryPayload): Observable<CommonApiResponse> {\r\n    const appObjectName = this.metadataHelper.getAppObjectByIdOrName(payload.appObjectId)?.ObjectName;\r\n    const headers = getHeaders();\r\n    return this.apiService.postToService(\r\n      APIServices.kibanaService,\r\n      API.auditGetHistory,\r\n      {\r\n        RecordIds: payload.recordIds,\r\n        entityName: appObjectName\r\n      },\r\n      headers\r\n    );\r\n  }\r\n\r\n  /**\r\n   * PMJAY Import\r\n   * @param data - Data for PMJAY import\r\n   * @returns Response from the API\r\n   */\r\n  pmjayImport(data: ImprotDataPayload): any {\r\n    const headers = getHeaders();\r\n    return this.apiService.post(`${API.pmjayImport}`, data, headers);\r\n  }\r\n\r\n  /**\r\n   * Executes a select query with optional parameters\r\n   * NEW: Uses new CRUD microservice endpoint with transformed payload\r\n   * @param data - The select query data (old format)\r\n   * @param parameters - Optional parameters to be applied to the query\r\n   * @param additionalConfig - Optional additional configuration\r\n   * @returns Result of the select query execution\r\n   */\r\n  selectExecutor(data: APISelectQuery, parameters?: any, additionalConfig?: any): Observable<CommonApiResponse> {\r\n    // Prepare query data with parameters and config\r\n    const preparedData: any = this.prepareSelectQueryData(data, parameters, additionalConfig);\r\n\r\n    // Transform to new CRUD API payload format\r\n    const crudPayload = this.transformToCRUDPayload(preparedData);\r\n\r\n    // Call new CRUD microservice endpoint\r\n    const headers = getHeaders();\r\n    return this.apiService.postToService(\r\n      APIServices.crudService,\r\n      API.QueriesSelect,\r\n      crudPayload,\r\n      headers\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Prepares select query data by applying parameters and additional configuration\r\n   * @param data - The select query data\r\n   * @param parameters - Optional parameters to replace in filters\r\n   * @param additionalConfig - Optional additional configuration to merge\r\n   * @returns Prepared APISelectQuery with parameters applied\r\n   */\r\n  private prepareSelectQueryData(data: APISelectQuery, parameters?: any, additionalConfig?: any) {\r\n    // Initialize WhereClause if parameters provided\r\n    if (parameters && Object.keys(parameters).length) {\r\n      data.WhereClause.filterLogic = data.WhereClause.filterLogic || '[]';\r\n      data.WhereClause.filters = data.WhereClause.filters || [];\r\n      data.WhereClause.SQLQuery = data.WhereClause.SQLQuery || '';\r\n      /**\r\n       * Replaces values from parameters if matched and in format of {{key}}.\r\n       * Example: if filter.value is \"{{userId}}\" and\r\n       * this._value.parameters.userId is 123, then filter.value will be replaced with\r\n       * \"123\".\r\n       */\r\n      data.WhereClause.filters.forEach((filter: any) => {\r\n        // filter.valueType is 1 (literal)\r\n        if (filter.value && filter.valueType == FilterValueType.Literal) {\r\n          // filter.value = filter.value.replace(\r\n          //   /{{([^}]+)}}/g,\r\n          //   (match: string, key: string) => {\r\n          //     const value = parameters[key];\r\n          //     return value !== undefined ? value : null;\r\n          //   }\r\n          // );\r\n        }\r\n        // if valueType = 2 (Parameters)\r\n        // then we need to replace the value with parameters and change the valueType to 1 (Literal)\r\n        else if (filter.valueType == FilterValueType.Parameter) {\r\n          filter.value = filter.value.replace(\r\n            /([^}]+)/g,\r\n            (match: string, key: string) => {\r\n              const value = parameters[key];\r\n              return value !== undefined ? value : null;\r\n            }\r\n          );\r\n          filter.valueType = FilterValueType.Literal;\r\n        }\r\n      });\r\n      (data?.WhereClause?.filters || []).forEach((element: any) => {\r\n        if (\r\n          element.valueType === FilterValueType.Parameter &&\r\n          parameters[element.fieldName]\r\n        ) {\r\n          element.value = parameters[element.fieldName];\r\n        }\r\n      });\r\n    }\r\n\r\n    return data;\r\n  }\r\n\r\n  /**\r\n   * Transforms old APISelectQuery format to new CRUD API format\r\n   * @param apiSelectQuery - The old format select query\r\n   * @returns CRUDSelectPayload - The new format payload\r\n   */\r\n  private transformToCRUDPayload(apiSelectQuery: APISelectQuery): CRUDSelectPayload {\r\n    const payload = new CRUDSelectPayload();\r\n\r\n    // Basic properties transformation\r\n    payload.EntityName = this.getEntityName(apiSelectQuery.QueryObjectID);\r\n    payload.SelectedFields = apiSelectQuery.ResultField_AppfieldIds || [];\r\n    payload.Distinct = apiSelectQuery.Distinct || false;\r\n\r\n    // Transform complex properties\r\n    payload.includes = this.transformJoinsToIncludes(apiSelectQuery.Joins);\r\n    payload.Pager = this.transformPager(apiSelectQuery.TopCount);\r\n    payload.whereClause = this.transformWhereClause(apiSelectQuery.WhereClause);\r\n    payload.Sort = this.transformSort(apiSelectQuery.Sort);\r\n\r\n    return payload;\r\n  }\r\n\r\n  /**\r\n   * Gets entity name from QueryObjectID\r\n   */\r\n  private getEntityName(queryObjectId: string): string {\r\n    const appObject = this.metadataHelper.getAppObjectByIdOrName(queryObjectId);\r\n    return appObject?.ObjectName || queryObjectId;\r\n  }\r\n\r\n  /**\r\n   * Transforms Joins to includes array\r\n   */\r\n  private transformJoinsToIncludes(joins?: any[]): any[] | undefined {\r\n    if (!joins || joins.length === 0) return undefined;\r\n\r\n    return joins.map((join: any) =>\r\n      join.Relationship?.childDetails?.LookupObject || join\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Transforms TopCount to Pager object\r\n   */\r\n  private transformPager(topCount?: number): CRUDPager | undefined {\r\n    if (!topCount) return undefined;\r\n\r\n    const pager = new CRUDPager();\r\n    pager.pageNumber = 1;\r\n    pager.pageSize = topCount;\r\n    pager.returnTotalCount = true;\r\n    return pager;\r\n  }\r\n\r\n  /**\r\n   * Transforms WhereClause to new format\r\n   */\r\n  private transformWhereClause(whereClause?: any): CRUDWhereClause | undefined {\r\n    if (!whereClause?.Filters || whereClause.Filters.length === 0) return undefined;\r\n\r\n    const crudWhereClause = new CRUDWhereClause();\r\n    crudWhereClause.filters = whereClause.Filters.map((filter: any) =>\r\n      this.transformFilter(filter)\r\n    );\r\n    return crudWhereClause;\r\n  }\r\n\r\n  /**\r\n   * Transforms a single filter to new format\r\n   */\r\n  private transformFilter(filter: any): CRUDFilter {\r\n    const crudFilter = new CRUDFilter();\r\n    crudFilter.fieldName = filter.FieldID;\r\n    crudFilter.operator = filter.RelationalOperator;\r\n    crudFilter.value = filter.Value || filter.value;\r\n    crudFilter.valueType = filter.ValueType;\r\n    crudFilter.conjunction = filter.ConjuctionClause;\r\n    crudFilter.groupId = filter.GroupID;\r\n    crudFilter.sequence = filter.Sequence;\r\n    return crudFilter;\r\n  }\r\n\r\n  /**\r\n   * Transforms Sort array to new format\r\n   */\r\n  private transformSort(sorts?: any[]): CRUDSort[] | undefined {\r\n    if (!sorts || sorts.length === 0) return undefined;\r\n\r\n    return sorts.map((sort: any) => {\r\n      const crudSort = new CRUDSort();\r\n      crudSort.FieldName = sort.FieldID;\r\n      crudSort.Direction = sort.SortSequence;\r\n      return crudSort;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Executes a select query by its ID, using the provided parameters.\r\n   *\r\n   * @param selectQueryId - The ID of the select query to be executed.\r\n   * @param parameters - Optional parameters to be applied to the query.\r\n   * @returns The result of the select query execution.\r\n   * @throws An error if the API response status code is not '200'.\r\n   */\r\n  executeSelectQueryById(selectQueryId: string, parameters?: any, additionalConfig?: any): Observable<CommonApiResponse> {\r\n    return this.executeRAWDSQWithName({\r\n      AppObjectName: AppObjectsConstants.TABD_Queries,\r\n      DSQName: DataSourceQueriesConstants.Detail_TABD_Queries,\r\n      Reqtokens: {\r\n        ID: selectQueryId,\r\n      },\r\n    }).pipe(\r\n      switchMap((res: any) => {\r\n        if (res.IsSuccess && res.Result.length) {\r\n          const Configuration = JSON.parse(res.Result[0].Configuration || '{}');\r\n          if (Configuration.WhereClause?.filters) {\r\n            Configuration.WhereClause.filters = this.removeWhereClauseForEmptyParams(Configuration.WhereClause.filters, parameters || {});\r\n          }\r\n          return this.selectExecutor(Configuration, parameters, additionalConfig);\r\n        } else {\r\n          throw new Error(res.Message || 'Failed to fetch select query configuration.');\r\n        }\r\n      })\r\n    );\r\n  }\r\n  removeWhereClauseForEmptyParams(filters: any[], parameters: Record<string, any>): any[] {\r\n    return filters.filter((filter: any) => {\r\n      if (filter.ValueType === FilterValueType.Parameter) {\r\n        const parameterName = filter.Value;\r\n        if (parameterName in parameters && parameters[parameterName] === '') {\r\n          return false; // Remove filter\r\n        }\r\n      }\r\n      if (Object.keys(parameters || {}).length === 0 && filter.ValueType === FilterValueType.Parameter) {\r\n        return false; // Remove filter\r\n      }\r\n      return true; // Keep filter\r\n    });\r\n  }\r\n\r\n  // /**\r\n  //  * Get Resource Language By Language Code\r\n  //  * @param languageCode - Language Code\r\n  //  * @returns Response from the API\r\n  //  */\r\n  // getResourceLanguageByLanguageCode(languageCode: number): any {\r\n  //   const headers = getHeaders();\r\n  //   if (headers) {\r\n  //     return this.apiService.post(\r\n  //       `${API.languageResource}`,\r\n  //       { LanguageCode: languageCode },\r\n  //       headers\r\n  //     );\r\n  //   }\r\n  //   return null;\r\n  // }\r\n\r\n  /**\r\n   * Get Search Data from Kibana microservice\r\n   * @param searchQuery - Search Query string\r\n   * @param limit - Limit of search results\r\n   * @returns Response from the API\r\n   */\r\n  getSearchData(payload: SearchDataPayload, params?: any): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.getFromService(\r\n      APIServices.kibanaService,\r\n      `${API.globalSearch}?searchQuery=${payload.searchQuery}&limit=${payload.limit}${payload?.appObjectId ? `&appObjectId=${payload.appObjectId}` : ''}`,\r\n      params,\r\n      headers\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Executes an HTTP request with the specified method, URL, headers, and body.\r\n   *\r\n   * @param fullUrl -The full URL of the request containing the query parameters.\r\n   * @param method - The HTTP method to be used ('GET', 'POST', 'PUT', 'DELETE').\r\n   * @param headers - The headers to include in the request.\r\n   * @param body - The body content for methods like POST and PUT.\r\n   * @returns The API response corresponding to the request.\r\n   */\r\n  executeHttpRequest(payload: HttpExecuteRequestPayload): any {\r\n    const headers = {\r\n      ...(payload?.headers || {}),\r\n      'X-Skip-Interceptor': 'true',\r\n      'X-Skip-Auth': 'true',\r\n      'X-Track-API-Details': 'true',\r\n    };\r\n    if (payload.method == 'GET') {\r\n      return this.apiService.getByUrl(payload.fullUrl, { headers });\r\n    } else if (payload.method == 'POST') {\r\n      return this.apiService.postByUrl(payload.fullUrl, payload.body, { headers });\r\n    } else if (payload.method == 'PUT') {\r\n      return this.apiService.putByUrl(payload.fullUrl, payload.body, { headers });\r\n    } else if (payload.method == 'DELETE') {\r\n      return this.apiService.deleteByUrl(payload.fullUrl, { headers });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Generates an HTTP Request based on the provided DataSourceQuery name\r\n   * @param QueryName - The name of the DataSourceQuery\r\n   * @returns The result of the generated HTTP request\r\n   */\r\n  generateHttpRequest(dataSourceQueryName: string): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.get(\r\n      `${API.GenerateHttpRequest}?dsqName=${dataSourceQueryName}`,\r\n      undefined,\r\n      headers\r\n    );\r\n  }\r\n}\r\n"]}

package/esm2022/lib/tab-core-utility/app/crud/tab-insert.service.mjs

@@ -1,20 +1,22 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { Injectable, inject } from '@angular/core';
-import { DSQHelper } from '../helpers/common/dsq.helpers';
+import { of, throwError } from 'rxjs';
+import { switchMap, map, catchError } from 'rxjs/operators';
 import { ScreenHelper } from '../helpers/screen/screen.helpers';
-import { WhereClauseHelper } from '../helpers/common/where-clause.helpers';
-import { RequestResponseHelper } from '../helpers/common/req-res.helpers';
-import { getAppObject, getDataFromDataSourceQueryID, syncAppObjectFields } from '../utils/tab-app.util';
-import { getPrimaryKeyFields, removeMultiplePrimaryKey, removePrimaryKey } from '../utils/req-res.util';
-import { createDynamicData, removeBlankValue } from '../utils/json.util';
-import { QueryType } from '../enums/query.enum';
+import { MetadataHelper } from '../helpers/common/meta-data.helpers';
+import { syncAppObjectFields } from '../utils/tab-app.util';
+import { getPrimaryKeyFields, removeMultiplePrimaryKey, removePrimaryKey, getHeaders } from '../utils/req-res.util';
+import { removeBlankValue, createDynamicData } from '../utils/json.util';
+import { ApiService } from '../../core/http-client/api.service';
+import { SignalRService } from '../../core/service/signalr/signalr.service';
+import { API, APIServices } from '../constants/api-constants';
 import * as i0 from "@angular/core";
 export class TabInsertService {
     constructor() {
-        this.dsqHelper = inject(DSQHelper);
         this.screenHelper = inject(ScreenHelper);
-        this.whereClauseHelper = inject(WhereClauseHelper);
-        this.requestResponseHelper = inject(RequestResponseHelper);
+        this.apiService = inject(ApiService);
+        this.signalRService = inject(SignalRService);
+        this.metadataHelper = inject(MetadataHelper);
     }
     /**
      * Inserts data by screen ID.
@@ -24,28 +26,28 @@ export class TabInsertService {
      */
     insertByScreenId(screenId, data) {
         const screen = this.screenHelper.getScreen(screenId);
-        const screenDataSource = getDataFromDataSourceQueryID(screen.DataSourceQuery);
-        return this.insertByObjectId(screenDataSource.ObjectID_Tosave, data);
+        const screenDataSource = this.metadataHelper.getDataSourceQueryByIdOrName(screen.DataSourceQuery);
+        return this.insertByObjectId(screenDataSource?.ObjectID_Tosave || '', data);
     }
     /**
-     * Inserts data by object ID.
-     * @param objectId The ID of the object.
-     * @param data The data to insert.
-     * @returns An Observable with the insert result.
+     * Insert using /records/insert endpoint with SYNC/ASYNC support
+     * @param objectId The ID of the object
+     * @param data The data to insert
+     * @param headers Optional headers
+     * @returns Observable with insertedId
      */
     insertByObjectId(objectId, data, headers) {
-        const appObject = getAppObject(objectId);
-        return this.prepareInsert(appObject, data, headers);
-    }
-    /**
-     * Prepares data for insertion.
-     * @param appObject The app object.
-     * @param data The data to insert.
-     * @returns An Observable with the prepared data.
-     */
-    prepareInsert(appObject, data, headers) {
-        const crudTableName = appObject.SystemDBTableName;
+        // Get AppObject metadata
+        const appObjectModel = this.metadataHelper.getAppObjectByIdOrName(objectId);
+        const appObject = appObjectModel?.toJSON();
+        if (!appObjectModel?.ID) {
+            return throwError(() => new Error(`AppObject not found: ${objectId}`));
+        }
+        // Get entity name (table name)
+        const entityName = appObjectModel.SystemDBTableName;
+        // Sync and filter data
         syncAppObjectFields(data.data, appObject);
+        // Remove primary keys
         const PrimaryKeyFields = getPrimaryKeyFields(appObject);
         if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {
             removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);
@@ -53,19 +55,68 @@ export class TabInsertService {
         else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {
             removeMultiplePrimaryKey(data.data, PrimaryKeyFields);
         }
-        const whereClause = this.whereClauseHelper.bindWhereClauseForInsert();
-        const dataObj = createDynamicData(data.data);
-        removeBlankValue(dataObj);
-        const requestPayload = this.requestResponseHelper.insertPayload(crudTableName, whereClause, dataObj);
-        return this.insert(requestPayload, headers);
+        // Remove blank values
+        const filteredData = { ...data.data };
+        removeBlankValue(filteredData);
+        // Transform to new API format using createDynamicData utility
+        const requestBody = {
+            entityName: entityName,
+            fields: createDynamicData(filteredData)
+        };
+        const header = getHeaders(headers);
+        // POST to new endpoint
+        return this.apiService.postToService(APIServices.crudService, API.recordsInsert, requestBody, header).pipe(switchMap((response) => {
+            if (!response?.IsSuccess) {
+                console.error('[TabInsertService] Insert failed:', response?.Errors);
+                return of(response);
+            }
+            // CASE 1: SYNC - Has insertedId immediately
+            if (response?.Result?.length) {
+                return of({
+                    ...response,
+                    Result: response.Result
+                });
+            }
+            // CASE 2: ASYNC - Has correlationId
+            else if (response?.CorrelationId) {
+                return this.handleAsyncInsert(response);
+            }
+            // CASE 3: Unknown response format
+            return of(response);
+        }), catchError((error) => {
+            console.error('[TabInsertService] Insert error:', error);
+            return throwError(() => error);
+        }));
     }
     /**
-     * Inserts data.
-     * @param data The data to insert.
-     * @returns An Observable with the insert result.
+     * Handle async insert - wait for SignalR notification
+     * @param response Initial response with correlationId
+     * @returns Observable with insertedId from SignalR notification
      */
-    insert(data, headers) {
-        return this.dsqHelper.executeQuery(data, QueryType.Insert, headers);
+    handleAsyncInsert(response) {
+        const correlationId = response?.CorrelationId;
+        if (!correlationId) {
+            console.error('[TabInsertService] Missing correlationId in async response');
+            return of(response);
+        }
+        // Wait for SignalR notification with matching correlationId
+        return this.signalRService.waitForOperation(correlationId).pipe(map((notification) => {
+            // Check if operation succeeded
+            if (!notification.isSuccess) {
+                throw new Error(notification.errorMessage || 'Insert operation failed');
+            }
+            // Return response with insertedId from notification (match old API format)
+            return {
+                ...response,
+                Result: notification.recordId, // Just the ID string
+                RecordAffectted: notification.affectedRecords || 1
+            };
+        }), catchError((error) => {
+            if (error.message === 'Operation timed out') {
+                return throwError(() => new Error('Insert operation timed out. The operation may still complete in the background. Please refresh to see the result.'));
+            }
+            return throwError(() => error);
+        }));
     }
     static { this.ɵfac = function TabInsertService_Factory(t) { return new (t || TabInsertService)(); }; }
     static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TabInsertService, factory: TabInsertService.ɵfac, providedIn: 'root' }); }
@@ -74,4 +125,4 @@ export class TabInsertService {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-insert.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/crud/tab-insert.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\r\nimport { Injectable, inject } from '@angular/core';\r\nimport { Observable, of, throwError } from 'rxjs';\r\nimport { switchMap, map, catchError } from 'rxjs/operators';\r\nimport { ScreenHelper } from '../helpers/screen/screen.helpers';\r\nimport { MetadataHelper } from '../helpers/common/meta-data.helpers';\r\nimport { syncAppObjectFields } from '../utils/tab-app.util';\r\nimport { AppObject, AppScreen } from '../models/app-object.class';\r\nimport { getPrimaryKeyFields, removeMultiplePrimaryKey, removePrimaryKey, getHeaders } from '../utils/req-res.util';\r\nimport { removeBlankValue, createDynamicData } from '../utils/json.util';\r\nimport { ApiService } from '../../core/http-client/api.service';\r\nimport { SignalRService } from '../../core/service/signalr/signalr.service';\r\nimport { API, APIServices } from '../constants/api-constants';\r\nimport { CommonApiResponse } from '../interfaces/common.interface';\r\n\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class TabInsertService {\r\n  private readonly screenHelper = inject(ScreenHelper);\r\n  private readonly apiService = inject(ApiService);\r\n  private readonly signalRService = inject(SignalRService);\r\n  private readonly metadataHelper = inject(MetadataHelper);\r\n\r\n  /**\r\n   * Inserts data by screen ID.\r\n   * @param screenId The ID of the screen.\r\n   * @param data The data to insert.\r\n   * @returns An Observable with the insert result.\r\n   */\r\n  insertByScreenId(screenId: string, data: any) {\r\n    const screen: AppScreen = this.screenHelper.getScreen(screenId);\r\n    const screenDataSource = this.metadataHelper.getDataSourceQueryByIdOrName(screen.DataSourceQuery);\r\n    return this.insertByObjectId(screenDataSource?.ObjectID_Tosave || '', data);\r\n  }\r\n\r\n  /**\r\n   * Insert using /records/insert endpoint with SYNC/ASYNC support\r\n   * @param objectId The ID of the object\r\n   * @param data The data to insert\r\n   * @param headers Optional headers\r\n   * @returns Observable with insertedId\r\n   */\r\n  insertByObjectId(objectId: string, data: any, headers?: any): Observable<CommonApiResponse> {\r\n    // Get AppObject metadata\r\n    const appObjectModel = this.metadataHelper.getAppObjectByIdOrName(objectId);\r\n    const appObject: AppObject = appObjectModel?.toJSON();\r\n\r\n    if (!appObjectModel?.ID) {\r\n      return throwError(() => new Error(`AppObject not found: ${objectId}`));\r\n    }\r\n\r\n    // Get entity name (table name)\r\n    const entityName = appObjectModel.SystemDBTableName;\r\n\r\n    // Sync and filter data\r\n    syncAppObjectFields(data.data, appObject);\r\n\r\n    // Remove primary keys\r\n    const PrimaryKeyFields = getPrimaryKeyFields(appObject);\r\n    if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {\r\n      removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);\r\n    } else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {\r\n      removeMultiplePrimaryKey(data.data, PrimaryKeyFields);\r\n    }\r\n\r\n    // Remove blank values\r\n    const filteredData = { ...data.data };\r\n    removeBlankValue(filteredData);\r\n\r\n    // Transform to new API format using createDynamicData utility\r\n    const requestBody = {\r\n      entityName: entityName,\r\n      fields: createDynamicData(filteredData)\r\n    };\r\n\r\n    const header = getHeaders(headers);\r\n\r\n    // POST to new endpoint\r\n    return this.apiService.postToService(\r\n      APIServices.crudService,\r\n      API.recordsInsert,\r\n      requestBody,\r\n      header\r\n    ).pipe(\r\n      switchMap((response: CommonApiResponse) => {\r\n        if (!response?.IsSuccess) {\r\n          console.error('[TabInsertService] Insert failed:', response?.Errors);\r\n          return of(response);\r\n        }\r\n\r\n        // CASE 1: SYNC - Has insertedId immediately\r\n        if (response?.Result?.length) {\r\n          return of({\r\n            ...response,\r\n            Result: response.Result\r\n          });\r\n        }\r\n\r\n        // CASE 2: ASYNC - Has correlationId\r\n        else if (response?.CorrelationId) {\r\n          return this.handleAsyncInsert(response);\r\n        }\r\n\r\n        // CASE 3: Unknown response format\r\n        return of(response);\r\n      }),\r\n      catchError((error) => {\r\n        console.error('[TabInsertService] Insert error:', error);\r\n        return throwError(() => error);\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Handle async insert - wait for SignalR notification\r\n   * @param response Initial response with correlationId\r\n   * @returns Observable with insertedId from SignalR notification\r\n   */\r\n  private handleAsyncInsert(response: CommonApiResponse): Observable<CommonApiResponse> {\r\n    const correlationId = response?.CorrelationId;\r\n\r\n    if (!correlationId) {\r\n      console.error('[TabInsertService] Missing correlationId in async response');\r\n      return of(response);\r\n    }\r\n\r\n    // Wait for SignalR notification with matching correlationId\r\n    return this.signalRService.waitForOperation(correlationId).pipe(\r\n      map((notification) => {\r\n        // Check if operation succeeded\r\n        if (!notification.isSuccess) {\r\n          throw new Error(notification.errorMessage || 'Insert operation failed');\r\n        }\r\n\r\n        // Return response with insertedId from notification (match old API format)\r\n        return {\r\n          ...response,\r\n          Result: notification.recordId, // Just the ID string\r\n          RecordAffectted: notification.affectedRecords || 1\r\n        };\r\n      }),\r\n      catchError((error) => {\r\n        if (error.message === 'Operation timed out') {\r\n          return throwError(() => new Error(\r\n            'Insert operation timed out. The operation may still complete in the background. Please refresh to see the result.'\r\n          ));\r\n        }\r\n        return throwError(() => error);\r\n      })\r\n    );\r\n  }\r\n}"]}