@techextensor/tab-core-utility 2.2.194 → 2.2.195

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

@@ -1,162 +1,190 @@
 /* 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 { APIFilterCriteria } from "../models/api-query.class";
-import { QueryType } from "../enums/query.enum";
-import { getAppObject, getAppObjectFromDataSourceQueryID, getAppObjectFromSystemDBTableName, getDataFromDataSourceQueryID, syncAppObjectFields } from "../utils/tab-app.util";
-import { AppObject } from "../models/app-object.class";
+import { MetadataHelper } from "../helpers/common/meta-data.helpers";
+import { syncAppObjectFields } from "../utils/tab-app.util";
 import { createDynamicData } from "../utils/json.util";
-import { getEditRecordId, getPrimaryKeyFields, removeMultiplePrimaryKey, removePrimaryKey } from "../utils/req-res.util";
+import { getEditRecordId, getPrimaryKeyFields, removeMultiplePrimaryKey, removePrimaryKey, getHeaders } from "../utils/req-res.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 TabUpdateService {
     constructor() {
-        this.dsqHelper = inject(DSQHelper);
         this.screenHelper = inject(ScreenHelper);
         this.whereClauseHelper = inject(WhereClauseHelper);
-        this.requestResponseHelper = inject(RequestResponseHelper);
-    }
-    update(data, headers) {
-        return this.dsqHelper.executeQuery(data, QueryType.Update, headers);
-    }
-    updateUsingDSQ(dsqId, data, tableName, queryFieldsArray, headers) {
-        const appObject = getDataFromDataSourceQueryID(dsqId);
-        if (appObject) {
-            if (data && data.data) {
-                const whereClause = this.whereClauseHelper.bindWhereClauseForUpdate(tableName, queryFieldsArray);
-                let dataObj = [];
-                dataObj = createDynamicData(data.data);
-                const requestPayload = this.requestResponseHelper.updateRequestPayload(tableName, whereClause, dataObj);
-                return this.update(requestPayload, headers);
-            }
-        }
-        return null;
+        this.apiService = inject(ApiService);
+        this.signalRService = inject(SignalRService);
+        this.metadataHelper = inject(MetadataHelper);
     }
     /**
-     * Parth B Thakkar - 2024-11-06
-     * Updates a record in the database based on the provided object ID.
-     * Same code as updateUsingScreenId with minor modifications like using the object ID directly instead of the screen ID.
-     * @param objectId The object ID of the record to update.
-     * @param data The data to update the record with.
-     * @returns The response from the update operation.
+     * Update using /records/update endpoint with SYNC/ASYNC support
+     * @param objectId The object ID
+     * @param data The data to update
+     * @param headers Optional headers
+     * @returns Observable with update result
      */
-    updateByObjectId(objectId, data) {
+    updateByObjectId(objectId, data, headers) {
         const fields = [];
-        let appObject = AppObject;
-        appObject = getAppObject(objectId);
-        appObject.Fields.forEach((element) => {
+        const appObjectModel = this.metadataHelper.getAppObjectByIdOrName(objectId);
+        const appObject = appObjectModel?.toJSON();
+        if (!appObjectModel?.ID) {
+            return throwError(() => new Error(`AppObject not found: ${objectId}`));
+        }
+        appObjectModel.fields().forEach((element) => {
             fields.push({ Field: element });
         });
-        const crudTableName = appObject.SystemDBTableName;
+        const crudTableName = appObjectModel.SystemDBTableName;
         syncAppObjectFields(data.data, appObject);
         const PrimaryKeyFields = getPrimaryKeyFields(appObject);
-        let whereClause = APIFilterCriteria;
-        if (appObject) {
-            if (data.data) {
-                const recordId = getEditRecordId(data.data, PrimaryKeyFields[0]?.FieldName);
-                data['recordId'] = recordId;
-                if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {
-                    removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);
-                    whereClause = this.whereClauseHelper.bindWhereClauseForUpdateGrid(fields, data.recordId, PrimaryKeyFields[0].FieldName, crudTableName);
-                }
-                else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {
-                    whereClause =
-                        this.whereClauseHelper.bindWhereClauseForMultiplePrimaryKeys(data.data, PrimaryKeyFields, crudTableName);
-                    removeMultiplePrimaryKey(data.data, PrimaryKeyFields);
-                }
-                const dataObj = createDynamicData(data.data);
-                const requestPayload = this.requestResponseHelper.updateRequestPayload(crudTableName, whereClause, dataObj);
-                return this.update(requestPayload);
+        if (!appObject || !data.data) {
+            return null;
+        }
+        const recordId = getEditRecordId(data.data, PrimaryKeyFields[0]?.FieldName);
+        data['recordId'] = recordId;
+        let whereClause;
+        if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {
+            removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);
+            whereClause = this.whereClauseHelper.bindWhereClauseForUpdateGrid(fields, data.recordId, PrimaryKeyFields[0].FieldName, crudTableName);
+        }
+        else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {
+            whereClause = this.whereClauseHelper.bindWhereClauseForMultiplePrimaryKeys(data.data, PrimaryKeyFields, crudTableName);
+            removeMultiplePrimaryKey(data.data, PrimaryKeyFields);
+        }
+        // Remove blank values
+        const filteredData = { ...data.data };
+        // Transform to new API format using createDynamicData utility
+        const requestBody = {
+            entityName: crudTableName,
+            fields: createDynamicData(filteredData),
+            whereClause: whereClause
+        };
+        const header = getHeaders(headers);
+        // PUT to new endpoint
+        return this.apiService.putToService(APIServices.crudService, API.recordsUpdate, requestBody, header).pipe(switchMap((response) => {
+            if (!response?.IsSuccess) {
+                console.error('[TabUpdateService] Update failed:', response?.Errors);
+                return of(response);
+            }
+            // CASE 1: SYNC - Operation completed immediately
+            if (response?.Result?.length) {
+                return of({
+                    ...response,
+                    Result: response?.Result?.[0]
+                });
+            }
+            // CASE 2: ASYNC - Has correlationId
+            else if (response?.CorrelationId) {
+                return this.handleAsyncUpdate(response);
             }
+            // CASE 3: Unknown response format
+            return of(response);
+        }), catchError((error) => {
+            console.error('[TabUpdateService] Update error:', error);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Handle async update - wait for SignalR notification
+     * @param response Initial response with correlationId
+     * @returns Observable with update result
+     */
+    handleAsyncUpdate(response) {
+        const correlationId = response?.CorrelationId;
+        if (!correlationId) {
+            console.error('[TabUpdateService] Missing correlationId in async response');
+            return of(response);
         }
-        return null;
+        // 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 || 'Update operation failed');
+            }
+            // Return response with success
+            return {
+                ...response,
+                Result: notification.result?.[0],
+                RecordAffectted: notification.affectedRecords || 1
+            };
+        }), catchError((error) => {
+            if (error.message === 'Operation timed out') {
+                return throwError(() => new Error('Update operation timed out. The operation may still complete in the background. Please refresh to see the result.'));
+            }
+            return throwError(() => error);
+        }));
     }
+    /**
+     * Update using screen ID
+     * @param screenId The screen ID
+     * @param data The data to update
+     * @param objectIdToSave Optional object ID to save
+     * @param headers Optional headers
+     * @returns Observable with update result
+     */
     updateUsingScreenId(screenId, data, objectIdToSave, headers) {
-        let fields;
-        let appObject = AppObject;
-        let crudTableName;
+        let objectId;
         if (screenId) {
             const screen = this.screenHelper.getScreen(screenId);
-            const screenDataSource = getDataFromDataSourceQueryID(screen.DataSourceQuery);
-            appObject = getAppObject(screenDataSource.ObjectID_Tosave);
-            crudTableName = appObject.SystemDBTableName;
-            fields = screenDataSource?.Fields?.map((field) => {
-                const appField = appObject?.Fields?.find((f) => f?.ID?.toLowerCase() === field?.AppFieldID?.toLowerCase()) ?? {};
-                return {
-                    ...field,
-                    Field: appField
-                };
-            });
-            syncAppObjectFields(data.data, appObject);
+            const screenDataSource = this.metadataHelper.getDataSourceQueryByIdOrName(screen.DataSourceQuery);
+            objectId = screenDataSource?.ObjectID || '';
         }
         if (objectIdToSave) {
-            fields = [];
-            appObject = getAppObject(objectIdToSave);
-            appObject.Fields.forEach((element) => {
-                fields.push({ Field: element });
-            });
-            crudTableName = appObject.SystemDBTableName;
-            syncAppObjectFields(data.data, appObject);
-        }
-        const PrimaryKeyFields = getPrimaryKeyFields(appObject);
-        let whereClause = APIFilterCriteria;
-        if (appObject) {
-            if (data.data) {
-                const recordId = getEditRecordId(data.data, PrimaryKeyFields[0]?.FieldName);
-                data['recordId'] = recordId;
-                if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {
-                    removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);
-                    whereClause = this.whereClauseHelper.bindWhereClauseForUpdateGrid(fields, data.recordId, PrimaryKeyFields[0].FieldName, crudTableName);
-                }
-                else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {
-                    whereClause = this.whereClauseHelper.bindWhereClauseForMultiplePrimaryKeys(data.data, PrimaryKeyFields, crudTableName);
-                    removeMultiplePrimaryKey(data.data, PrimaryKeyFields);
-                }
-                const dataObj = createDynamicData(data.data);
-                const requestPayload = this.requestResponseHelper.updateRequestPayload(crudTableName, whereClause, dataObj);
-                return this.update(requestPayload, headers);
-            }
-        }
-        return null;
-    }
-    updateScreen(screenId, screenData) {
-        const screen = this.screenHelper.getScreen(screenId);
-        if (screen) {
-            const appObject = getAppObjectFromSystemDBTableName('TABMD_AppScreen');
-            if (appObject) {
-                syncAppObjectFields(screenData, appObject);
-            }
-            Object.assign({}, screen, { Container: screenData.Container });
-            const queryFilters = [];
-            queryFilters.push({ FieldName: 'ID', FieldValue: screenId });
-            const whereClause = this.whereClauseHelper.bindWhereClauseForUpdate('TABMD_AppScreen', queryFilters);
-            const dataObj = createDynamicData(screenData);
-            const requestPayload = this.requestResponseHelper.updateRequestPayload('TABMD_AppScreen', whereClause, dataObj);
-            return this.update(requestPayload);
+            objectId = objectIdToSave;
         }
-        return null;
+        return this.updateByObjectId(objectId, data, headers);
     }
     /**
-     * Update records using the provided DSQ ID, data, filters
-     * @param dsqId The ID of the DataSourceQuery to use for the update
+     * Update using DSQ ID with custom table name and query fields
+     * Uses custom queryFieldsArray for where clause instead of primary key
+     * @param dsqId The DSQ ID
      * @param data The data to update
-     * @param filters The filters to apply to the update
-     * @returns The response from the update operation
+     * @param tableName The table name
+     * @param queryFieldsArray Query fields array for custom where clause
+     * @param headers Optional headers
+     * @returns Observable with update result
      */
-    updateUsingDsqIdFiltersAndCustomViewId(dsqId, data, filters) {
-        const appObject = getAppObjectFromDataSourceQueryID(dsqId);
-        if (appObject) {
-            if (data) {
-                const whereClause = this.whereClauseHelper.bindWhereClauseForUpdateUsingFilters(appObject.SystemDBTableName, filters, appObject.Fields);
-                let dataObj = [];
-                dataObj = createDynamicData(data);
-                const requestPayload = this.requestResponseHelper.updateRequestPayload(appObject.SystemDBTableName, whereClause, dataObj);
-                return this.update(requestPayload);
-            }
+    updateUsingDSQ(dsqId, data, tableName, queryFieldsArray, headers) {
+        const screenDataSource = this.metadataHelper.getDataSourceQueryByIdOrName(dsqId);
+        if (!screenDataSource || !data?.data) {
+            return null;
         }
-        return null;
+        const appObjectModel = this.metadataHelper.getAppObjectByIdOrName(screenDataSource.ObjectID || '');
+        if (!appObjectModel) {
+            return null;
+        }
+        // Use provided tableName or fallback to appObject's table name
+        const entityName = tableName || appObjectModel.SystemDBTableName;
+        const whereClause = this.whereClauseHelper.bindWhereClauseForUpdate(entityName, queryFieldsArray);
+        const dataObj = createDynamicData(data.data);
+        const requestBody = {
+            entityName: entityName,
+            fields: dataObj,
+            whereClause: whereClause
+        };
+        const header = getHeaders(headers);
+        return this.apiService.putToService(APIServices.crudService, API.recordsUpdate, requestBody, header).pipe(switchMap((response) => {
+            if (!response?.IsSuccess) {
+                console.error('[TabUpdateService] Update using DSQ failed:', response?.Errors);
+                return of(response);
+            }
+            if (response?.Result?.length) {
+                return of({
+                    ...response,
+                    Result: response?.Result?.[0]
+                });
+            }
+            else if (response?.CorrelationId) {
+                return this.handleAsyncUpdate(response);
+            }
+            return of(response);
+        }), catchError((error) => {
+            console.error('[TabUpdateService] Update using DSQ error:', error);
+            return throwError(() => error);
+        }));
     }
     static { this.ɵfac = function TabUpdateService_Factory(t) { return new (t || TabUpdateService)(); }; }
     static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: TabUpdateService, factory: TabUpdateService.ɵfac, providedIn: 'root' }); }
@@ -165,4 +193,4 @@ export class TabUpdateService {
         type: Injectable,
         args: [{ providedIn: 'root' }]
     }], null, null); })();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-update.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/crud/tab-update.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 { DSQHelper } from \"../helpers/common/dsq.helpers\";\r\nimport { ScreenHelper } from \"../helpers/screen/screen.helpers\";\r\nimport { WhereClauseHelper } from \"../helpers/common/where-clause.helpers\";\r\nimport { RequestResponseHelper } from \"../helpers/common/req-res.helpers\";\r\nimport { APIFilterCriteria, APIUpdateQuery } from \"../models/api-query.class\";\r\nimport { QueryType } from \"../enums/query.enum\";\r\nimport { getAppObject, getAppObjectFromDataSourceQueryID, getAppObjectFromSystemDBTableName, getDataFromDataSourceQueryID, syncAppObjectFields } from \"../utils/tab-app.util\";\r\nimport { AppObject, AppScreen } from \"../models/app-object.class\";\r\nimport { createDynamicData } from \"../utils/json.util\";\r\nimport { getEditRecordId, getPrimaryKeyFields, removeMultiplePrimaryKey, removePrimaryKey } from \"../utils/req-res.util\";\r\nimport { UpdateQueryParameter } from \"../models/data-source-queries.class\";\r\n\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class TabUpdateService {\r\n  private readonly dsqHelper = inject(DSQHelper);\r\n  private readonly screenHelper = inject(ScreenHelper);\r\n  private readonly whereClauseHelper = inject(WhereClauseHelper);\r\n  private readonly requestResponseHelper = inject(RequestResponseHelper);\r\n\r\n  update(data: APIUpdateQuery ,headers?: any) {\r\n    return this.dsqHelper.executeQuery(data, QueryType.Update, headers);\r\n  }\r\n\r\n  updateUsingDSQ(dsqId: string, data: any, tableName: string, queryFieldsArray?: any, headers?: any) {\r\n    const appObject: AppObject = getDataFromDataSourceQueryID(dsqId);\r\n    if (appObject) {\r\n      if (data && data.data) {\r\n        const whereClause: APIFilterCriteria = this.whereClauseHelper.bindWhereClauseForUpdate(tableName, queryFieldsArray);\r\n        let dataObj: any = [];\r\n        dataObj = createDynamicData(data.data);\r\n        const requestPayload = this.requestResponseHelper.updateRequestPayload(tableName, whereClause, dataObj);\r\n        return this.update(requestPayload, headers);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  /**\r\n   * Parth B Thakkar - 2024-11-06\r\n   * Updates a record in the database based on the provided object ID.\r\n   * Same code as updateUsingScreenId with minor modifications like using the object ID directly instead of the screen ID.\r\n   * @param objectId The object ID of the record to update.\r\n   * @param data The data to update the record with.\r\n   * @returns The response from the update operation.\r\n   */\r\n  updateByObjectId(objectId: string, data: any) {\r\n    const fields: any[] = [];\r\n    let appObject: any = AppObject;\r\n\r\n    appObject = getAppObject(objectId);\r\n    appObject.Fields.forEach((element: any) => {\r\n      fields.push({ Field: element });\r\n    });\r\n    const crudTableName = appObject.SystemDBTableName;\r\n    syncAppObjectFields(data.data, appObject);\r\n\r\n    const PrimaryKeyFields: any = getPrimaryKeyFields(appObject);\r\n    let whereClause: any = APIFilterCriteria;\r\n    if (appObject) {\r\n      if (data.data) {\r\n        const recordId = getEditRecordId(\r\n          data.data,\r\n          PrimaryKeyFields[0]?.FieldName\r\n        );\r\n        data['recordId'] = recordId;\r\n\r\n        if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {\r\n          removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);\r\n          whereClause = this.whereClauseHelper.bindWhereClauseForUpdateGrid(\r\n            fields,\r\n            data.recordId,\r\n            PrimaryKeyFields[0].FieldName,\r\n            crudTableName\r\n          );\r\n        } else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {\r\n          whereClause =\r\n            this.whereClauseHelper.bindWhereClauseForMultiplePrimaryKeys(\r\n              data.data,\r\n              PrimaryKeyFields,\r\n              crudTableName\r\n            );\r\n          removeMultiplePrimaryKey(data.data, PrimaryKeyFields);\r\n        }\r\n        const dataObj: any = createDynamicData(data.data);\r\n        const requestPayload = this.requestResponseHelper.updateRequestPayload(\r\n          crudTableName,\r\n          whereClause,\r\n          dataObj\r\n        );\r\n        return this.update(requestPayload);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n  updateUsingScreenId(screenId: string, data: any, objectIdToSave?: string, headers?: any) {\r\n    let fields;\r\n    let appObject: any = AppObject;\r\n    let crudTableName;\r\n    if (screenId) {\r\n      const screen: AppScreen = this.screenHelper.getScreen(screenId);\r\n      const screenDataSource = getDataFromDataSourceQueryID(screen.DataSourceQuery);\r\n      appObject = getAppObject(screenDataSource.ObjectID_Tosave);\r\n      crudTableName = appObject.SystemDBTableName;\r\n      fields = screenDataSource?.Fields?.map((field: any) => {\r\n        const appField = appObject?.Fields?.find((f: any) => f?.ID?.toLowerCase() === field?.AppFieldID?.toLowerCase()) ?? {};\r\n        return {\r\n          ...field,\r\n          Field: appField\r\n        };\r\n      });\r\n      syncAppObjectFields(data.data, appObject);\r\n    }\r\n    if (objectIdToSave) {\r\n      fields = [];\r\n      appObject = getAppObject(objectIdToSave);\r\n      appObject.Fields.forEach((element: any) => {\r\n        fields.push({ Field: element })\r\n      });\r\n      crudTableName = appObject.SystemDBTableName;\r\n      syncAppObjectFields(data.data, appObject);\r\n    }\r\n\r\n    const PrimaryKeyFields: any = getPrimaryKeyFields(appObject);\r\n    let whereClause: any = APIFilterCriteria;\r\n    if (appObject) {\r\n      if (data.data) {\r\n        const recordId = getEditRecordId(data.data, PrimaryKeyFields[0]?.FieldName);\r\n        data['recordId'] = recordId;\r\n\r\n        if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {\r\n          removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);\r\n          whereClause = this.whereClauseHelper.bindWhereClauseForUpdateGrid(fields, data.recordId, PrimaryKeyFields[0].FieldName, crudTableName);\r\n        } else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {\r\n          whereClause = this.whereClauseHelper.bindWhereClauseForMultiplePrimaryKeys(data.data, PrimaryKeyFields, crudTableName);\r\n          removeMultiplePrimaryKey(data.data, PrimaryKeyFields);\r\n        }\r\n        const dataObj: any = createDynamicData(data.data);\r\n        const requestPayload = this.requestResponseHelper.updateRequestPayload(crudTableName, whereClause, dataObj);\r\n        return this.update(requestPayload, headers);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n  updateScreen(screenId: string, screenData: any) {\r\n    const screen: AppScreen = this.screenHelper.getScreen(screenId);\r\n    if (screen) {\r\n      const appObject = getAppObjectFromSystemDBTableName('TABMD_AppScreen');\r\n      if (appObject) {\r\n        syncAppObjectFields(screenData, appObject);\r\n      }\r\n      Object.assign({}, screen, { Container: screenData.Container });\r\n      const queryFilters: UpdateQueryParameter[] = [];\r\n      queryFilters.push({ FieldName: 'ID', FieldValue: screenId })\r\n      const whereClause = this.whereClauseHelper.bindWhereClauseForUpdate('TABMD_AppScreen', queryFilters);\r\n      const dataObj: any = createDynamicData(screenData);\r\n      const requestPayload = this.requestResponseHelper.updateRequestPayload('TABMD_AppScreen', whereClause, dataObj);\r\n      return this.update(requestPayload);\r\n    }\r\n    return null;\r\n  }\r\n  /**\r\n   * Update records using the provided DSQ ID, data, filters\r\n   * @param dsqId The ID of the DataSourceQuery to use for the update\r\n   * @param data The data to update\r\n   * @param filters The filters to apply to the update\r\n   * @returns The response from the update operation\r\n   */\r\n  updateUsingDsqIdFiltersAndCustomViewId(\r\n    dsqId: string,\r\n    data: any,\r\n    filters: any\r\n  ) {\r\n    const appObject: AppObject = getAppObjectFromDataSourceQueryID(dsqId);\r\n    if (appObject) {\r\n      if (data) {\r\n        const whereClause: APIFilterCriteria =\r\n          this.whereClauseHelper.bindWhereClauseForUpdateUsingFilters(\r\n            appObject.SystemDBTableName,\r\n            filters,\r\n            appObject.Fields\r\n          );\r\n        let dataObj: any = [];\r\n        dataObj = createDynamicData(data);\r\n        const requestPayload = this.requestResponseHelper.updateRequestPayload(\r\n          appObject.SystemDBTableName,\r\n          whereClause,\r\n          dataObj\r\n        );\r\n        return this.update(requestPayload);\r\n      }\r\n    }\r\n    return null;\r\n  }\r\n\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tab-update.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/crud/tab-update.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 { Observable, of, throwError } from 'rxjs';\r\nimport { switchMap, map, catchError } from 'rxjs/operators';\r\nimport { ScreenHelper } from \"../helpers/screen/screen.helpers\";\r\nimport { WhereClauseHelper } from \"../helpers/common/where-clause.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 { createDynamicData } from \"../utils/json.util\";\r\nimport { getEditRecordId, getPrimaryKeyFields, removeMultiplePrimaryKey, removePrimaryKey, getHeaders } from \"../utils/req-res.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 TabUpdateService {\r\n  private readonly screenHelper = inject(ScreenHelper);\r\n  private readonly whereClauseHelper = inject(WhereClauseHelper);\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   * Update using /records/update endpoint with SYNC/ASYNC support\r\n   * @param objectId The object ID\r\n   * @param data The data to update\r\n   * @param headers Optional headers\r\n   * @returns Observable with update result\r\n   */\r\n  updateByObjectId(objectId: string, data: any, headers?: any): Observable<CommonApiResponse> | null {\r\n    const fields: any[] = [];\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    appObjectModel.fields().forEach((element: any) => {\r\n      fields.push({ Field: element });\r\n    });\r\n\r\n    const crudTableName = appObjectModel.SystemDBTableName;\r\n    syncAppObjectFields(data.data, appObject);\r\n\r\n    const PrimaryKeyFields: any = getPrimaryKeyFields(appObject);\r\n\r\n    if (!appObject || !data.data) {\r\n      return null;\r\n    }\r\n\r\n    const recordId = getEditRecordId(data.data, PrimaryKeyFields[0]?.FieldName);\r\n    data['recordId'] = recordId;\r\n\r\n    let whereClause: any;\r\n    if (PrimaryKeyFields && PrimaryKeyFields.length === 1) {\r\n      removePrimaryKey(data.data, PrimaryKeyFields[0]?.FieldName);\r\n      whereClause = this.whereClauseHelper.bindWhereClauseForUpdateGrid(\r\n        fields,\r\n        data.recordId,\r\n        PrimaryKeyFields[0].FieldName,\r\n        crudTableName\r\n      );\r\n    } else if (PrimaryKeyFields && PrimaryKeyFields.length > 1) {\r\n      whereClause = this.whereClauseHelper.bindWhereClauseForMultiplePrimaryKeys(\r\n        data.data,\r\n        PrimaryKeyFields,\r\n        crudTableName\r\n      );\r\n      removeMultiplePrimaryKey(data.data, PrimaryKeyFields);\r\n    }\r\n\r\n    // Remove blank values\r\n    const filteredData = { ...data.data };\r\n\r\n    // Transform to new API format using createDynamicData utility\r\n    const requestBody = {\r\n      entityName: crudTableName,\r\n      fields: createDynamicData(filteredData),\r\n      whereClause: whereClause\r\n    };\r\n\r\n    const header = getHeaders(headers);\r\n\r\n    // PUT to new endpoint\r\n    return this.apiService.putToService(\r\n      APIServices.crudService,\r\n      API.recordsUpdate,\r\n      requestBody,\r\n      header\r\n    ).pipe(\r\n      switchMap((response: CommonApiResponse) => {\r\n        if (!response?.IsSuccess) {\r\n          console.error('[TabUpdateService] Update failed:', response?.Errors);\r\n          return of(response);\r\n        }\r\n\r\n        // CASE 1: SYNC - Operation completed immediately\r\n        if (response?.Result?.length) {\r\n          return  of({\r\n            ...response,\r\n            Result: response?.Result?.[0]\r\n          });\r\n        }\r\n\r\n        // CASE 2: ASYNC - Has correlationId\r\n        else if (response?.CorrelationId) {\r\n          return this.handleAsyncUpdate(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('[TabUpdateService] Update error:', error);\r\n        return throwError(() => error);\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Handle async update - wait for SignalR notification\r\n   * @param response Initial response with correlationId\r\n   * @returns Observable with update result\r\n   */\r\n  private handleAsyncUpdate(response: CommonApiResponse): Observable<CommonApiResponse> {\r\n    const correlationId = response?.CorrelationId;\r\n\r\n    if (!correlationId) {\r\n      console.error('[TabUpdateService] 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 || 'Update operation failed');\r\n        }\r\n\r\n        // Return response with success\r\n        return {\r\n          ...response,\r\n          Result: notification.result?.[0],\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            'Update 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\r\n  /**\r\n   * Update using screen ID\r\n   * @param screenId The screen ID\r\n   * @param data The data to update\r\n   * @param objectIdToSave Optional object ID to save\r\n   * @param headers Optional headers\r\n   * @returns Observable with update result\r\n   */\r\n  updateUsingScreenId(screenId: string, data: any, objectIdToSave?: string, headers?: any) {\r\n    let objectId: string;\r\n\r\n    if (screenId) {\r\n      const screen: AppScreen = this.screenHelper.getScreen(screenId);\r\n      const screenDataSource = this.metadataHelper.getDataSourceQueryByIdOrName(screen.DataSourceQuery);\r\n      objectId = screenDataSource?.ObjectID || '';\r\n    }\r\n\r\n    if (objectIdToSave) {\r\n      objectId = objectIdToSave;\r\n    }\r\n\r\n    return this.updateByObjectId(objectId!, data, headers);\r\n  }\r\n\r\n  /**\r\n   * Update using DSQ ID with custom table name and query fields\r\n   * Uses custom queryFieldsArray for where clause instead of primary key\r\n   * @param dsqId The DSQ ID\r\n   * @param data The data to update\r\n   * @param tableName The table name\r\n   * @param queryFieldsArray Query fields array for custom where clause\r\n   * @param headers Optional headers\r\n   * @returns Observable with update result\r\n   */\r\n  updateUsingDSQ(dsqId: string, data: any, tableName?: string, queryFieldsArray?: any, headers?: any) {\r\n    const screenDataSource = this.metadataHelper.getDataSourceQueryByIdOrName(dsqId);\r\n    if (!screenDataSource || !data?.data) {\r\n      return null;\r\n    }\r\n\r\n    const appObjectModel = this.metadataHelper.getAppObjectByIdOrName(screenDataSource.ObjectID || '');\r\n    if (!appObjectModel) {\r\n      return null;\r\n    }\r\n\r\n    // Use provided tableName or fallback to appObject's table name\r\n    const entityName = tableName || appObjectModel.SystemDBTableName;\r\n\r\n    const whereClause = this.whereClauseHelper.bindWhereClauseForUpdate(entityName, queryFieldsArray);\r\n    const dataObj: any = createDynamicData(data.data);\r\n\r\n    const requestBody = {\r\n      entityName: entityName,\r\n      fields: dataObj,\r\n      whereClause: whereClause\r\n    };\r\n\r\n    const header = getHeaders(headers);\r\n\r\n    return this.apiService.putToService(\r\n      APIServices.crudService,\r\n      API.recordsUpdate,\r\n      requestBody,\r\n      header\r\n    ).pipe(\r\n      switchMap((response: CommonApiResponse) => {\r\n        if (!response?.IsSuccess) {\r\n          console.error('[TabUpdateService] Update using DSQ failed:', response?.Errors);\r\n          return of(response);\r\n        }\r\n\r\n        if (response?.Result?.length) {\r\n          return  of({\r\n            ...response,\r\n            Result: response?.Result?.[0]\r\n          });\r\n        } else if (response?.CorrelationId) {\r\n          return this.handleAsyncUpdate(response);\r\n        }\r\n\r\n        return of(response);\r\n      }),\r\n      catchError((error) => {\r\n        console.error('[TabUpdateService] Update using DSQ error:', error);\r\n        return throwError(() => error);\r\n      })\r\n    );\r\n  }\r\n}"]}

package/esm2022/lib/tab-core-utility/app/enums/query.enum.mjs

@@ -1,16 +1,16 @@
 export var QueryType;
 (function (QueryType) {
     QueryType[QueryType["Select"] = 0] = "Select";
-    QueryType[QueryType["Insert"] = 1] = "Insert";
-    QueryType[QueryType["Update"] = 2] = "Update";
-    QueryType[QueryType["Delete"] = 3] = "Delete";
-    QueryType[QueryType["Upsert"] = 4] = "Upsert";
-    QueryType[QueryType["BulkUpdate"] = 5] = "BulkUpdate";
-    QueryType[QueryType["BulkInsert"] = 6] = "BulkInsert";
+    // Insert,
+    // Update,
+    // Delete,
+    QueryType[QueryType["Upsert"] = 1] = "Upsert";
+    QueryType[QueryType["BulkUpdate"] = 2] = "BulkUpdate";
+    QueryType[QueryType["BulkInsert"] = 3] = "BulkInsert";
 })(QueryType || (QueryType = {}));
 export var JoinType;
 (function (JoinType) {
     JoinType[JoinType["LeftJoin"] = 1] = "LeftJoin";
     JoinType[JoinType["RightJoin"] = 2] = "RightJoin";
 })(JoinType || (JoinType = {}));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnkuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2FwcC9lbnVtcy9xdWVyeS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFNBUVg7QUFSRCxXQUFZLFNBQVM7SUFDbkIsNkNBQU0sQ0FBQTtJQUNOLDZDQUFNLENBQUE7SUFDTiw2Q0FBTSxDQUFBO0lBQ04sNkNBQU0sQ0FBQTtJQUNOLDZDQUFNLENBQUE7SUFDTixxREFBVSxDQUFBO0lBQ1YscURBQVUsQ0FBQTtBQUNaLENBQUMsRUFSVyxTQUFTLEtBQVQsU0FBUyxRQVFwQjtBQUVELE1BQU0sQ0FBTixJQUFZLFFBR1g7QUFIRCxXQUFZLFFBQVE7SUFDbEIsK0NBQVksQ0FBQTtJQUNaLGlEQUFhLENBQUE7QUFDZixDQUFDLEVBSFcsUUFBUSxLQUFSLFFBQVEsUUFHbkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBRdWVyeVR5cGUge1xyXG4gIFNlbGVjdCxcclxuICBJbnNlcnQsXHJcbiAgVXBkYXRlLFxyXG4gIERlbGV0ZSxcclxuICBVcHNlcnQsXHJcbiAgQnVsa1VwZGF0ZSxcclxuICBCdWxrSW5zZXJ0LFxyXG59XHJcblxyXG5leHBvcnQgZW51bSBKb2luVHlwZSB7XHJcbiAgTGVmdEpvaW4gPSAxLFxyXG4gIFJpZ2h0Sm9pbiA9IDIsXHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnkuZW51bS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZGF0YS1hY2Nlc3Mvc3JjL2xpYi90YWItY29yZS11dGlsaXR5L2FwcC9lbnVtcy9xdWVyeS5lbnVtLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBTixJQUFZLFNBUVg7QUFSRCxXQUFZLFNBQVM7SUFDbkIsNkNBQU0sQ0FBQTtJQUNOLFVBQVU7SUFDVixVQUFVO0lBQ1YsVUFBVTtJQUNWLDZDQUFNLENBQUE7SUFDTixxREFBVSxDQUFBO0lBQ1YscURBQVUsQ0FBQTtBQUNaLENBQUMsRUFSVyxTQUFTLEtBQVQsU0FBUyxRQVFwQjtBQUVELE1BQU0sQ0FBTixJQUFZLFFBR1g7QUFIRCxXQUFZLFFBQVE7SUFDbEIsK0NBQVksQ0FBQTtJQUNaLGlEQUFhLENBQUE7QUFDZixDQUFDLEVBSFcsUUFBUSxLQUFSLFFBQVEsUUFHbkIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBRdWVyeVR5cGUge1xyXG4gIFNlbGVjdCxcclxuICAvLyBJbnNlcnQsXHJcbiAgLy8gVXBkYXRlLFxyXG4gIC8vIERlbGV0ZSxcclxuICBVcHNlcnQsXHJcbiAgQnVsa1VwZGF0ZSxcclxuICBCdWxrSW5zZXJ0LFxyXG59XHJcblxyXG5leHBvcnQgZW51bSBKb2luVHlwZSB7XHJcbiAgTGVmdEpvaW4gPSAxLFxyXG4gIFJpZ2h0Sm9pbiA9IDIsXHJcbn1cclxuIl19

package/esm2022/lib/tab-core-utility/app/helpers/auth-response.adapter.mjs

@@ -0,0 +1,79 @@
+/**
+ * AuthResponseAdapter - Transforms new auth API response to legacy format
+ *
+ * The new identity service returns a flat response structure with camelCase fields.
+ * This adapter converts it to the old nested structure expected by the application.
+ *
+ * New format (flat):
+ *   { userId, email, userName, accessToken, refreshToken, expiresIn, roles, ... }
+ *
+ * Old format (nested):
+ *   { user: { Id, UserName, Roles, PersonData, Attributes, ... }, Token, RefreshToken, RefreshTokenExpiry }
+ *
+ * Note: A duplicate LoginResponseAdapter exists on branch TE-42-8422/Api-Rewrite.
+ * On merge, discard one and keep this file.
+ */
+export class AuthResponseAdapter {
+    /**
+     * Transforms the normalized CommonApiResponse's Result from new flat format to old nested format.
+     * If the Result is already in old format (has .user or .Token), returns as-is.
+     *
+     * @param response - The CommonApiResponse (already top-level normalized by ResponseAdapter)
+     * @returns The response with Result transformed to legacy nested format
+     */
+    static normalize(response) {
+        const result = response?.Result;
+        // If null, already old format (has .user wrapper or .Token), return as-is
+        if (!result || result.user || result.Token) {
+            return response;
+        }
+        // Transform new flat format to old nested format
+        response.Result = {
+            user: {
+                Id: result.userId ?? null,
+                UserName: result.email ?? result.userName ?? null,
+                DefaultTenantId: result.defaultTenantId ?? null,
+                DefaultAppId: result.defaultAppId ?? null,
+                Roles: AuthResponseAdapter.transformRoles(result.roles),
+                Teams: null,
+                PersonData: null,
+                MailingAddress: null,
+                Locale: null,
+                Attributes: null,
+            },
+            Token: result.accessToken ?? null,
+            RefreshToken: result.refreshToken ?? null,
+            RefreshTokenExpiry: result.expiresIn
+                ? new Date(Date.now() + result.expiresIn * 1000).toISOString()
+                : null,
+            Success: result.succeeded ?? false,
+            Errors: result.error ?? null,
+        };
+        return response;
+    }
+    /**
+     * Transforms roles from new camelCase format to old PascalCase format.
+     * Structure: { tenantId: { appId: { envId: [{ id, roleName, description }] } } }
+     * becomes:   { tenantId: { appId: { envId: [{ ID, RoleName, Description }] } } }
+     */
+    static transformRoles(roles) {
+        if (!roles)
+            return {};
+        const transformed = {};
+        for (const [tenantId, tenantData] of Object.entries(roles)) {
+            transformed[tenantId] = {};
+            for (const [appId, appData] of Object.entries(tenantData)) {
+                transformed[tenantId][appId] = {};
+                for (const [envId, envRoles] of Object.entries(appData)) {
+                    transformed[tenantId][appId][envId] = envRoles.map(role => ({
+                        ID: role.id ?? role.ID,
+                        RoleName: role.roleName ?? role.RoleName,
+                        Description: role.description ?? role.Description,
+                    }));
+                }
+            }
+        }
+        return transformed;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0aC1yZXNwb25zZS5hZGFwdGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9kYXRhLWFjY2Vzcy9zcmMvbGliL3RhYi1jb3JlLXV0aWxpdHkvYXBwL2hlbHBlcnMvYXV0aC1yZXNwb25zZS5hZGFwdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsTUFBTSxPQUFPLG1CQUFtQjtJQUU5Qjs7Ozs7O09BTUc7SUFDSCxNQUFNLENBQUMsU0FBUyxDQUFDLFFBQTJCO1FBQzFDLE1BQU0sTUFBTSxHQUFHLFFBQVEsRUFBRSxNQUFNLENBQUM7UUFFaEMsMEVBQTBFO1FBQzFFLElBQUksQ0FBQyxNQUFNLElBQUksTUFBTSxDQUFDLElBQUksSUFBSSxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUM7WUFDM0MsT0FBTyxRQUFRLENBQUM7UUFDbEIsQ0FBQztRQUVELGlEQUFpRDtRQUNqRCxRQUFRLENBQUMsTUFBTSxHQUFHO1lBQ2hCLElBQUksRUFBRTtnQkFDSixFQUFFLEVBQUUsTUFBTSxDQUFDLE1BQU0sSUFBSSxJQUFJO2dCQUN6QixRQUFRLEVBQUUsTUFBTSxDQUFDLEtBQUssSUFBSSxNQUFNLENBQUMsUUFBUSxJQUFJLElBQUk7Z0JBQ2pELGVBQWUsRUFBRSxNQUFNLENBQUMsZUFBZSxJQUFJLElBQUk7Z0JBQy9DLFlBQVksRUFBRSxNQUFNLENBQUMsWUFBWSxJQUFJLElBQUk7Z0JBQ3pDLEtBQUssRUFBRSxtQkFBbUIsQ0FBQyxjQUFjLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQztnQkFDdkQsS0FBSyxFQUFFLElBQUk7Z0JBQ1gsVUFBVSxFQUFFLElBQUk7Z0JBQ2hCLGNBQWMsRUFBRSxJQUFJO2dCQUNwQixNQUFNLEVBQUUsSUFBSTtnQkFDWixVQUFVLEVBQUUsSUFBSTthQUNqQjtZQUNELEtBQUssRUFBRSxNQUFNLENBQUMsV0FBVyxJQUFJLElBQUk7WUFDakMsWUFBWSxFQUFFLE1BQU0sQ0FBQyxZQUFZLElBQUksSUFBSTtZQUN6QyxrQkFBa0IsRUFBRSxNQUFNLENBQUMsU0FBUztnQkFDbEMsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxNQUFNLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxDQUFDLFdBQVcsRUFBRTtnQkFDOUQsQ0FBQyxDQUFDLElBQUk7WUFDUixPQUFPLEVBQUUsTUFBTSxDQUFDLFNBQVMsSUFBSSxLQUFLO1lBQ2xDLE1BQU0sRUFBRSxNQUFNLENBQUMsS0FBSyxJQUFJLElBQUk7U0FDN0IsQ0FBQztRQUVGLE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7SUFFRDs7OztPQUlHO0lBQ0ssTUFBTSxDQUFDLGNBQWMsQ0FBQyxLQUFVO1FBQ3RDLElBQUksQ0FBQyxLQUFLO1lBQUUsT0FBTyxFQUFFLENBQUM7UUFFdEIsTUFBTSxXQUFXLEdBQVEsRUFBRSxDQUFDO1FBRTVCLEtBQUssTUFBTSxDQUFDLFFBQVEsRUFBRSxVQUFVLENBQUMsSUFBSSxNQUFNLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDM0QsV0FBVyxDQUFDLFFBQVEsQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUUzQixLQUFLLE1BQU0sQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLElBQUksTUFBTSxDQUFDLE9BQU8sQ0FBQyxVQUFpQixDQUFDLEVBQUUsQ0FBQztnQkFDakUsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQztnQkFFbEMsS0FBSyxNQUFNLENBQUMsS0FBSyxFQUFFLFFBQVEsQ0FBQyxJQUFJLE1BQU0sQ0FBQyxPQUFPLENBQUMsT0FBYyxDQUFDLEVBQUUsQ0FBQztvQkFDL0QsV0FBVyxDQUFDLFFBQVEsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLEtBQUssQ0FBQyxHQUFJLFFBQWtCLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQzt3QkFDckUsRUFBRSxFQUFFLElBQUksQ0FBQyxFQUFFLElBQUksSUFBSSxDQUFDLEVBQUU7d0JBQ3RCLFFBQVEsRUFBRSxJQUFJLENBQUMsUUFBUSxJQUFJLElBQUksQ0FBQyxRQUFRO3dCQUN4QyxXQUFXLEVBQUUsSUFBSSxDQUFDLFdBQVcsSUFBSSxJQUFJLENBQUMsV0FBVztxQkFDbEQsQ0FBQyxDQUFDLENBQUM7Z0JBQ04sQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO1FBRUQsT0FBTyxXQUFXLENBQUM7SUFDckIsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLyogZXNsaW50LWRpc2FibGUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWV4cGxpY2l0LWFueSAqL1xyXG5pbXBvcnQgeyBDb21tb25BcGlSZXNwb25zZSB9IGZyb20gJy4uL2ludGVyZmFjZXMvY29tbW9uLmludGVyZmFjZSc7XHJcblxyXG4vKipcclxuICogQXV0aFJlc3BvbnNlQWRhcHRlciAtIFRyYW5zZm9ybXMgbmV3IGF1dGggQVBJIHJlc3BvbnNlIHRvIGxlZ2FjeSBmb3JtYXRcclxuICpcclxuICogVGhlIG5ldyBpZGVudGl0eSBzZXJ2aWNlIHJldHVybnMgYSBmbGF0IHJlc3BvbnNlIHN0cnVjdHVyZSB3aXRoIGNhbWVsQ2FzZSBmaWVsZHMuXHJcbiAqIFRoaXMgYWRhcHRlciBjb252ZXJ0cyBpdCB0byB0aGUgb2xkIG5lc3RlZCBzdHJ1Y3R1cmUgZXhwZWN0ZWQgYnkgdGhlIGFwcGxpY2F0aW9uLlxyXG4gKlxyXG4gKiBOZXcgZm9ybWF0IChmbGF0KTpcclxuICogICB7IHVzZXJJZCwgZW1haWwsIHVzZXJOYW1lLCBhY2Nlc3NUb2tlbiwgcmVmcmVzaFRva2VuLCBleHBpcmVzSW4sIHJvbGVzLCAuLi4gfVxyXG4gKlxyXG4gKiBPbGQgZm9ybWF0IChuZXN0ZWQpOlxyXG4gKiAgIHsgdXNlcjogeyBJZCwgVXNlck5hbWUsIFJvbGVzLCBQZXJzb25EYXRhLCBBdHRyaWJ1dGVzLCAuLi4gfSwgVG9rZW4sIFJlZnJlc2hUb2tlbiwgUmVmcmVzaFRva2VuRXhwaXJ5IH1cclxuICpcclxuICogTm90ZTogQSBkdXBsaWNhdGUgTG9naW5SZXNwb25zZUFkYXB0ZXIgZXhpc3RzIG9uIGJyYW5jaCBURS00Mi04NDIyL0FwaS1SZXdyaXRlLlxyXG4gKiBPbiBtZXJnZSwgZGlzY2FyZCBvbmUgYW5kIGtlZXAgdGhpcyBmaWxlLlxyXG4gKi9cclxuZXhwb3J0IGNsYXNzIEF1dGhSZXNwb25zZUFkYXB0ZXIge1xyXG5cclxuICAvKipcclxuICAgKiBUcmFuc2Zvcm1zIHRoZSBub3JtYWxpemVkIENvbW1vbkFwaVJlc3BvbnNlJ3MgUmVzdWx0IGZyb20gbmV3IGZsYXQgZm9ybWF0IHRvIG9sZCBuZXN0ZWQgZm9ybWF0LlxyXG4gICAqIElmIHRoZSBSZXN1bHQgaXMgYWxyZWFkeSBpbiBvbGQgZm9ybWF0IChoYXMgLnVzZXIgb3IgLlRva2VuKSwgcmV0dXJucyBhcy1pcy5cclxuICAgKlxyXG4gICAqIEBwYXJhbSByZXNwb25zZSAtIFRoZSBDb21tb25BcGlSZXNwb25zZSAoYWxyZWFkeSB0b3AtbGV2ZWwgbm9ybWFsaXplZCBieSBSZXNwb25zZUFkYXB0ZXIpXHJcbiAgICogQHJldHVybnMgVGhlIHJlc3BvbnNlIHdpdGggUmVzdWx0IHRyYW5zZm9ybWVkIHRvIGxlZ2FjeSBuZXN0ZWQgZm9ybWF0XHJcbiAgICovXHJcbiAgc3RhdGljIG5vcm1hbGl6ZShyZXNwb25zZTogQ29tbW9uQXBpUmVzcG9uc2UpOiBDb21tb25BcGlSZXNwb25zZSB7XHJcbiAgICBjb25zdCByZXN1bHQgPSByZXNwb25zZT8uUmVzdWx0O1xyXG5cclxuICAgIC8vIElmIG51bGwsIGFscmVhZHkgb2xkIGZvcm1hdCAoaGFzIC51c2VyIHdyYXBwZXIgb3IgLlRva2VuKSwgcmV0dXJuIGFzLWlzXHJcbiAgICBpZiAoIXJlc3VsdCB8fCByZXN1bHQudXNlciB8fCByZXN1bHQuVG9rZW4pIHtcclxuICAgICAgcmV0dXJuIHJlc3BvbnNlO1xyXG4gICAgfVxyXG5cclxuICAgIC8vIFRyYW5zZm9ybSBuZXcgZmxhdCBmb3JtYXQgdG8gb2xkIG5lc3RlZCBmb3JtYXRcclxuICAgIHJlc3BvbnNlLlJlc3VsdCA9IHtcclxuICAgICAgdXNlcjoge1xyXG4gICAgICAgIElkOiByZXN1bHQudXNlcklkID8/IG51bGwsXHJcbiAgICAgICAgVXNlck5hbWU6IHJlc3VsdC5lbWFpbCA/PyByZXN1bHQudXNlck5hbWUgPz8gbnVsbCxcclxuICAgICAgICBEZWZhdWx0VGVuYW50SWQ6IHJlc3VsdC5kZWZhdWx0VGVuYW50SWQgPz8gbnVsbCxcclxuICAgICAgICBEZWZhdWx0QXBwSWQ6IHJlc3VsdC5kZWZhdWx0QXBwSWQgPz8gbnVsbCxcclxuICAgICAgICBSb2xlczogQXV0aFJlc3BvbnNlQWRhcHRlci50cmFuc2Zvcm1Sb2xlcyhyZXN1bHQucm9sZXMpLFxyXG4gICAgICAgIFRlYW1zOiBudWxsLFxyXG4gICAgICAgIFBlcnNvbkRhdGE6IG51bGwsXHJcbiAgICAgICAgTWFpbGluZ0FkZHJlc3M6IG51bGwsXHJcbiAgICAgICAgTG9jYWxlOiBudWxsLFxyXG4gICAgICAgIEF0dHJpYnV0ZXM6IG51bGwsXHJcbiAgICAgIH0sXHJcbiAgICAgIFRva2VuOiByZXN1bHQuYWNjZXNzVG9rZW4gPz8gbnVsbCxcclxuICAgICAgUmVmcmVzaFRva2VuOiByZXN1bHQucmVmcmVzaFRva2VuID8/IG51bGwsXHJcbiAgICAgIFJlZnJlc2hUb2tlbkV4cGlyeTogcmVzdWx0LmV4cGlyZXNJblxyXG4gICAgICAgID8gbmV3IERhdGUoRGF0ZS5ub3coKSArIHJlc3VsdC5leHBpcmVzSW4gKiAxMDAwKS50b0lTT1N0cmluZygpXHJcbiAgICAgICAgOiBudWxsLFxyXG4gICAgICBTdWNjZXNzOiByZXN1bHQuc3VjY2VlZGVkID8/IGZhbHNlLFxyXG4gICAgICBFcnJvcnM6IHJlc3VsdC5lcnJvciA/PyBudWxsLFxyXG4gICAgfTtcclxuXHJcbiAgICByZXR1cm4gcmVzcG9uc2U7XHJcbiAgfVxyXG5cclxuICAvKipcclxuICAgKiBUcmFuc2Zvcm1zIHJvbGVzIGZyb20gbmV3IGNhbWVsQ2FzZSBmb3JtYXQgdG8gb2xkIFBhc2NhbENhc2UgZm9ybWF0LlxyXG4gICAqIFN0cnVjdHVyZTogeyB0ZW5hbnRJZDogeyBhcHBJZDogeyBlbnZJZDogW3sgaWQsIHJvbGVOYW1lLCBkZXNjcmlwdGlvbiB9XSB9IH0gfVxyXG4gICAqIGJlY29tZXM6ICAgeyB0ZW5hbnRJZDogeyBhcHBJZDogeyBlbnZJZDogW3sgSUQsIFJvbGVOYW1lLCBEZXNjcmlwdGlvbiB9XSB9IH0gfVxyXG4gICAqL1xyXG4gIHByaXZhdGUgc3RhdGljIHRyYW5zZm9ybVJvbGVzKHJvbGVzOiBhbnkpOiBhbnkge1xyXG4gICAgaWYgKCFyb2xlcykgcmV0dXJuIHt9O1xyXG5cclxuICAgIGNvbnN0IHRyYW5zZm9ybWVkOiBhbnkgPSB7fTtcclxuXHJcbiAgICBmb3IgKGNvbnN0IFt0ZW5hbnRJZCwgdGVuYW50RGF0YV0gb2YgT2JqZWN0LmVudHJpZXMocm9sZXMpKSB7XHJcbiAgICAgIHRyYW5zZm9ybWVkW3RlbmFudElkXSA9IHt9O1xyXG5cclxuICAgICAgZm9yIChjb25zdCBbYXBwSWQsIGFwcERhdGFdIG9mIE9iamVjdC5lbnRyaWVzKHRlbmFudERhdGEgYXMgYW55KSkge1xyXG4gICAgICAgIHRyYW5zZm9ybWVkW3RlbmFudElkXVthcHBJZF0gPSB7fTtcclxuXHJcbiAgICAgICAgZm9yIChjb25zdCBbZW52SWQsIGVudlJvbGVzXSBvZiBPYmplY3QuZW50cmllcyhhcHBEYXRhIGFzIGFueSkpIHtcclxuICAgICAgICAgIHRyYW5zZm9ybWVkW3RlbmFudElkXVthcHBJZF1bZW52SWRdID0gKGVudlJvbGVzIGFzIGFueVtdKS5tYXAocm9sZSA9PiAoe1xyXG4gICAgICAgICAgICBJRDogcm9sZS5pZCA/PyByb2xlLklELFxyXG4gICAgICAgICAgICBSb2xlTmFtZTogcm9sZS5yb2xlTmFtZSA/PyByb2xlLlJvbGVOYW1lLFxyXG4gICAgICAgICAgICBEZXNjcmlwdGlvbjogcm9sZS5kZXNjcmlwdGlvbiA/PyByb2xlLkRlc2NyaXB0aW9uLFxyXG4gICAgICAgICAgfSkpO1xyXG4gICAgICAgIH1cclxuICAgICAgfVxyXG4gICAgfVxyXG5cclxuICAgIHJldHVybiB0cmFuc2Zvcm1lZDtcclxuICB9XHJcbn0iXX0=