@techextensor/tab-core-utility 2.2.194 → 2.2.195

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

@@ -1,42 +1,171 @@
 import { Injectable, inject } from "@angular/core";
 import { ApiService } from "../../core/http-client/api.service";
 import { getHeaders } from "../utils/req-res.util";
-import { API } from "../constants/api-constants";
+import { API, APIServices } from "../constants/api-constants";
+import { of, throwError } from "rxjs";
+import { switchMap, map, catchError } from "rxjs/operators";
+import { ConjuctionClause, FilterValueType, RelationalOperator } from "../enums/dsq.enum";
+import { SignalRService } from "../../core/service/signalr/signalr.service";
 import * as i0 from "@angular/core";
 export class TabFormioService {
     constructor() {
         this.apiService = inject(ApiService);
+        this.signalRService = inject(SignalRService);
     }
     /**
      * Fetches screen data from the server based on the screen ID and optional configuration.
+     * NEW: Uses metadata service endpoint - returns new API format directly
      *
      * @param screenId - The ID of the screen to retrieve.
      * @param config - Optional configuration including layoutId and version.
      * @param params - Additional parameters for the API call.
-     * @returns The screen data if headers are available, otherwise null.
+     * @returns The screen data in new API format (camelCase)
      */
     getScreen(screenId, config, params) {
         // Retrieve headers for the API request
         const headers = getHeaders();
-        // Construct the API endpoint with the screenId and optional configuration
-        return this.apiService.get(`${API.getScreen}?screenId=${screenId}${config?.layoutId ? `&layoutId=${config?.layoutId}` : ''}${config?.version ? `&version=${config?.version}` : ''}`, params, headers);
+        // NEW API: GET /screen/{screenId} via metadata service
+        // Query params: layoutId, version (if provided)
+        let endpoint = `${API.screen}/${screenId}`;
+        const queryParams = [];
+        if (config?.layoutId) {
+            queryParams.push(`layoutId=${config.layoutId}`);
+        }
+        if (config?.version) {
+            queryParams.push(`version=${config.version}`);
+        }
+        if (queryParams.length > 0) {
+            endpoint += `?${queryParams.join('&')}`;
+        }
+        return this.apiService.getFromService(APIServices.metadataService, endpoint, params, headers);
     }
     /**
      * Retrieves the submission data from the server.
-     * @param data - Object containing screenId and reqtokens
-     * @returns A Subject emitting the submission data or undefined.
+     * NEW: Uses formio service endpoint - returns new API format directly
+     *
+     * @param screenId - The ID of the screen to retrieve data for
+     * @param requestPayload - Request payload containing Reqtokens and other parameters
+     * @returns The screen data in new API format (camelCase)
      */
     getScreenData(screenId, requestPayload) {
         const headers = getHeaders();
-        return this.apiService.post(`${API.getScreenData}/${screenId}`, requestPayload, headers);
+        // NEW API: POST /formio/screendata/{screenId} via formio service
+        return this.apiService.postToService(APIServices.formioService, `${API.screenData}/${screenId}`, requestPayload, headers);
     }
     /**
-    * Called when the form is submitted.
-    * @param data Object containing submission data.
-    */
+     * Process form request - handles both SYNC and ASYNC operations transparently
+     *
+     * SYNC Operation: Backend returns insertedId immediately → Fetch full record → Return
+     * ASYNC Operation: Backend returns correlationId → Wait for SignalR notification → Fetch full record → Return
+     *
+     * Developer code stays the same for both cases - platform handles complexity
+     *
+     * @param data Object containing submission data (ScreenId, Data)
+     * @returns Observable with full record data (always returns complete record)
+     */
     processRequest(data) {
         const headers = getHeaders();
-        return this.apiService.post(`${API.processRequest}`, data, headers);
+        return this.apiService.postToService(APIServices.formioService, `${API.processRequest}`, data, headers).pipe(switchMap((response) => {
+            // Check for success
+            if (!response?.IsSuccess) {
+                console.error('[TabFormioService] ProcessRequest failed:', response?.Errors);
+                return of(response);
+            }
+            // CASE 1: SYNC - Has insertedId immediately (not null)
+            if (response?.Result?.insertedId) {
+                return this.handleSyncOperation(response);
+            }
+            // CASE 2: ASYNC - Has CorrelationId and insertedId is null
+            else if (response?.CorrelationId) {
+                return this.handleAsyncOperation(response);
+            }
+            // CASE 3: Other response (return as-is)
+            return of(response);
+        }), catchError((error) => {
+            console.error('[TabFormioService] ProcessRequest error:', error);
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Handle SYNC operation - fetch full record immediately
+     */
+    handleSyncOperation(response) {
+        const { insertedId, objectName, primaryKeyField } = response?.Result || {};
+        if (!objectName || !insertedId) {
+            console.error('[TabFormioService] Missing objectName or insertedId in sync response');
+            return of(response);
+        }
+        const pkField = primaryKeyField || 'Id'; // Default to 'Id' if not provided
+        return this.fetchFullRecord(objectName, insertedId, pkField).pipe(map((fullRecord) => ({
+            ...response,
+            Result: fullRecord
+        })), catchError((error) => {
+            console.error('[TabFormioService] Failed to fetch full record:', error);
+            // Return partial response if fetch fails
+            return of(response);
+        }));
+    }
+    /**
+     * Handle ASYNC operation - wait for SignalR notification, then fetch full record
+     */
+    handleAsyncOperation(response) {
+        const correlationId = response?.CorrelationId;
+        const primaryKeyField = response?.Result?.primaryKeyField || 'Id'; // Get from original response
+        if (!correlationId) {
+            console.error('[TabFormioService] Missing correlationId in async response');
+            return of(response);
+        }
+        // Wait for SignalR notification with matching correlationId
+        return this.signalRService.waitForOperation(correlationId).pipe(switchMap((notification) => {
+            // Check if operation succeeded
+            if (!notification.isSuccess) {
+                return throwError(() => new Error(notification.errorMessage || 'Operation failed'));
+            }
+            // Fetch full record using result from notification
+            return this.fetchFullRecord(notification.entityName, notification.result?.[0], primaryKeyField);
+        }), 
+        // Build normalized response
+        map((fullRecord) => ({
+            ...response,
+            Result: fullRecord
+        })), 
+        // Handle errors (timeout, fetch failure, etc.)
+        catchError((error) => {
+            if (error.message === 'Operation timed out') {
+                return throwError(() => new Error('Operation timed out. The operation may still complete in the background. Please refresh to see the result.'));
+            }
+            return throwError(() => error);
+        }));
+    }
+    /**
+     * Fetch full record from CRUD service
+     * @param objectName - Entity/Table name
+     * @param recordId - Record ID to fetch
+     * @param primaryKeyField - Primary key field name (defaults to 'Id')
+     */
+    fetchFullRecord(objectName, recordId, primaryKeyField = 'Id') {
+        return this.apiService.postToService(APIServices.crudService, API.QueriesSelect, {
+            EntityName: objectName,
+            ResultField_AppfieldIds: ['*'],
+            whereClause: {
+                filters: [
+                    {
+                        fieldName: primaryKeyField, // Use dynamic primary key field
+                        operator: RelationalOperator.EqualTo,
+                        value: recordId,
+                        valueType: FilterValueType.Literal,
+                        conjunction: ConjuctionClause.AND,
+                        groupId: 0,
+                        sequence: 1
+                    }
+                ]
+            },
+        }).pipe(map((selectResponse) => {
+            if (selectResponse?.Result && selectResponse?.Result?.length) {
+                return selectResponse.Result[0];
+            }
+            throw new Error('Record not found after operation');
+        }));
     }
     /**
      * Retrieves the formIO components for the given appObjectId and type.
@@ -56,4 +185,4 @@ export class TabFormioService {
         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-formio.service.js","sourceRoot":"","sources":["../../../../../../../../libs/data-access/src/lib/tab-core-utility/app/crud/tab-formio.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, inject } from \"@angular/core\";\r\nimport { ApiService } from \"../../core/http-client/api.service\";\r\nimport { getHeaders } from \"../utils/req-res.util\";\r\nimport { API, APIServices } from \"../constants/api-constants\";\r\nimport { CommonApiResponse, GetScreenConfig, ProcessRequestPayload } from \"../interfaces/common.interface\";\r\nimport { Observable, of, throwError } from \"rxjs\";\r\nimport { switchMap, map, catchError } from \"rxjs/operators\";\r\nimport { BuildFormComponentType } from \"../enums/common.enum\";\r\nimport { ConjuctionClause, FilterValueType, RelationalOperator } from \"../enums/dsq.enum\";\r\nimport { SignalRService } from \"../../core/service/signalr/signalr.service\";\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class TabFormioService {\r\n  private readonly apiService = inject(ApiService);\r\n  private readonly signalRService = inject(SignalRService);\r\n\r\n  /**\r\n   * Fetches screen data from the server based on the screen ID and optional configuration.\r\n   * NEW: Uses metadata service endpoint - returns new API format directly\r\n   *\r\n   * @param screenId - The ID of the screen to retrieve.\r\n   * @param config - Optional configuration including layoutId and version.\r\n   * @param params - Additional parameters for the API call.\r\n   * @returns The screen data in new API format (camelCase)\r\n   */\r\n  getScreen(screenId: string, config?: GetScreenConfig, params?: any): Observable<CommonApiResponse> {\r\n    // Retrieve headers for the API request\r\n    const headers = getHeaders();\r\n\r\n    // NEW API: GET /screen/{screenId} via metadata service\r\n    // Query params: layoutId, version (if provided)\r\n    let endpoint = `${API.screen}/${screenId}`;\r\n    const queryParams: string[] = [];\r\n\r\n    if (config?.layoutId) {\r\n      queryParams.push(`layoutId=${config.layoutId}`);\r\n    }\r\n    if (config?.version) {\r\n      queryParams.push(`version=${config.version}`);\r\n    }\r\n\r\n    if (queryParams.length > 0) {\r\n      endpoint += `?${queryParams.join('&')}`;\r\n    }\r\n\r\n    return this.apiService.getFromService(\r\n      APIServices.metadataService,\r\n      endpoint,\r\n      params,\r\n      headers\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Retrieves the submission data from the server.\r\n   * NEW: Uses formio service endpoint - returns new API format directly\r\n   *\r\n   * @param screenId - The ID of the screen to retrieve data for\r\n   * @param requestPayload - Request payload containing Reqtokens and other parameters\r\n   * @returns The screen data in new API format (camelCase)\r\n   */\r\n  getScreenData(screenId: string, requestPayload: any): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n\r\n    // NEW API: POST /formio/screendata/{screenId} via formio service\r\n    return this.apiService.postToService(\r\n      APIServices.formioService,\r\n      `${API.screenData}/${screenId}`,\r\n      requestPayload,\r\n      headers\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Process form request - handles both SYNC and ASYNC operations transparently\r\n   *\r\n   * SYNC Operation: Backend returns insertedId immediately → Fetch full record → Return\r\n   * ASYNC Operation: Backend returns correlationId → Wait for SignalR notification → Fetch full record → Return\r\n   *\r\n   * Developer code stays the same for both cases - platform handles complexity\r\n   *\r\n   * @param data Object containing submission data (ScreenId, Data)\r\n   * @returns Observable with full record data (always returns complete record)\r\n   */\r\n  processRequest(data: ProcessRequestPayload): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n\r\n    return this.apiService.postToService(\r\n      APIServices.formioService,\r\n      `${API.processRequest}`,\r\n      data,\r\n      headers\r\n    ).pipe(\r\n      switchMap((response: CommonApiResponse) => {\r\n        // Check for success\r\n        if (!response?.IsSuccess) {\r\n          console.error('[TabFormioService] ProcessRequest failed:', response?.Errors);\r\n          return of(response);\r\n        }\r\n\r\n        // CASE 1: SYNC - Has insertedId immediately (not null)\r\n        if (response?.Result?.insertedId) {\r\n          return this.handleSyncOperation(response);\r\n        }\r\n\r\n        // CASE 2: ASYNC - Has CorrelationId and insertedId is null\r\n        else if (response?.CorrelationId) {\r\n          return this.handleAsyncOperation(response);\r\n        }\r\n\r\n        // CASE 3: Other response (return as-is)\r\n        return of(response);\r\n      }),\r\n      catchError((error) => {\r\n        console.error('[TabFormioService] ProcessRequest error:', error);\r\n        return throwError(() => error);\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Handle SYNC operation - fetch full record immediately\r\n   */\r\n  private handleSyncOperation(response: CommonApiResponse): Observable<CommonApiResponse> {\r\n    const { insertedId, objectName, primaryKeyField } = response?.Result || {};\r\n\r\n    if (!objectName || !insertedId) {\r\n      console.error('[TabFormioService] Missing objectName or insertedId in sync response');\r\n      return of(response);\r\n    }\r\n\r\n    const pkField = primaryKeyField || 'Id'; // Default to 'Id' if not provided\r\n\r\n    return this.fetchFullRecord(objectName, insertedId, pkField).pipe(\r\n      map((fullRecord) => ({\r\n        ...response,\r\n        Result: fullRecord\r\n      })),\r\n      catchError((error) => {\r\n        console.error('[TabFormioService] Failed to fetch full record:', error);\r\n        // Return partial response if fetch fails\r\n        return of(response);\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Handle ASYNC operation - wait for SignalR notification, then fetch full record\r\n   */\r\n  private handleAsyncOperation(response: CommonApiResponse): Observable<CommonApiResponse> {\r\n    const correlationId = response?.CorrelationId;\r\n    const primaryKeyField = response?.Result?.primaryKeyField || 'Id'; // Get from original response\r\n\r\n    if (!correlationId) {\r\n      console.error('[TabFormioService] 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      switchMap((notification) => {\r\n        // Check if operation succeeded\r\n        if (!notification.isSuccess) {\r\n          return throwError(\r\n            () => new Error(notification.errorMessage || 'Operation failed')\r\n          );\r\n        }\r\n\r\n        // Fetch full record using result from notification\r\n        return this.fetchFullRecord(notification.entityName, notification.result?.[0], primaryKeyField);\r\n      }),\r\n\r\n      // Build normalized response\r\n      map((fullRecord) => ({\r\n        ...response,\r\n        Result: fullRecord\r\n      })),\r\n\r\n      // Handle errors (timeout, fetch failure, etc.)\r\n      catchError((error) => {\r\n        if (error.message === 'Operation timed out') {\r\n          return throwError(\r\n            () =>\r\n              new Error(\r\n                'Operation timed out. The operation may still complete in the background. Please refresh to see the result.'\r\n              )\r\n          );\r\n        }\r\n        return throwError(() => error);\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Fetch full record from CRUD service\r\n   * @param objectName - Entity/Table name\r\n   * @param recordId - Record ID to fetch\r\n   * @param primaryKeyField - Primary key field name (defaults to 'Id')\r\n   */\r\n  private fetchFullRecord(objectName: string, recordId: string, primaryKeyField = 'Id'): Observable<any> {\r\n    return this.apiService.postToService(\r\n      APIServices.crudService,\r\n      API.QueriesSelect,\r\n      {\r\n        EntityName: objectName,\r\n        ResultField_AppfieldIds: ['*'],\r\n        whereClause: {\r\n          filters: [\r\n            {\r\n              fieldName: primaryKeyField, // Use dynamic primary key field\r\n              operator: RelationalOperator.EqualTo,\r\n              value: recordId,\r\n              valueType: FilterValueType.Literal,\r\n              conjunction: ConjuctionClause.AND,\r\n              groupId: 0,\r\n              sequence: 1\r\n            }\r\n          ]\r\n        },\r\n      }).pipe(\r\n        map((selectResponse: CommonApiResponse) => {\r\n          if (selectResponse?.Result && selectResponse?.Result?.length) {\r\n            return selectResponse.Result[0];\r\n          }\r\n          throw new Error('Record not found after operation');\r\n        })\r\n      );\r\n  }\r\n\r\n  /**\r\n   * Retrieves the formIO components for the given appObjectId and type.\r\n   * @param appObjectId - The ID of the app object.\r\n   * @param type - The type of the components to retrieve. Can be either 'CommonFilter' or 'BulkUpdate'\r\n   * @param params - Additional parameters for the API call.\r\n   * @returns The formIO components in the response body.\r\n   */\r\n  buildFormIOComponents(appObjectId: string, type: BuildFormComponentType, params?: any): Observable<CommonApiResponse> {\r\n    const headers = getHeaders();\r\n    return this.apiService.get(\r\n      `${API.BuildFormIOComponents}?appObjectId=${appObjectId}&Type=${type}`,\r\n      params,\r\n      headers\r\n    );\r\n  }\r\n}"]}