@messaia/cdk 20.2.2 → 20.2.4

package/fesm2022/messaia-cdk.mjs

@@ -20008,42 +20008,63 @@ class GenericFormBaseComponent extends BaseComponent {
      * Loads an item by ID.
      * This method fetches the item if the component is in edit mode and the service endpoint is defined.
      *
-     * @param callback - A function to be called after the item has been successfully loaded.
-     *                   This function will receive the loaded item as an argument.
-     */
-    loadItem(callback) {
+     * @param successCallback - A function to be called after the item has been successfully loaded.
+     *                          This function will receive the loaded item as an argument.
+     * @param errorCallback - A function to be called if an error occurs during loading.
+     *                        This function will receive the error as an argument.
+     * @param headers - Optional HTTP headers to include in the request.
+     * @param handleError - Indicates whether to automatically handle and parse errors (default: true).
+     * @param observeResponse - If true, the full HTTP response will be observed instead of just the body (default: false).
+     */
+    loadItem(successCallback, errorCallback, headers, handleError = true, observeResponse = true) {
         if (this.isEditMode && this.service?.endpoint) {
             /* Set loading state to true to indicate that an item is being loaded */
             this.isLoading = true;
             /* Trigger change detection to update the view with the loading state */
             this.changeDetectorRef.detectChanges();
             /* Call the asynchronous method to load the item */
-            this.loadItemAsync().subscribe({
+            this.loadItemAsync(headers, handleError, observeResponse).subscribe({
                 /* Handle the response when the item is successfully loaded */
                 next: (item) => {
                     /* Set loading state to false to indicate that loading has completed */
                     this.isLoading = false;
-                    /* Execute the callback if provided, passing the loaded item */
-                    if (callback) {
-                        callback(item);
+                    /* Execute the success callback if provided */
+                    if (successCallback) {
+                        successCallback(item);
                     }
                 },
                 /* Handle any errors that occur during the loading process */
-                error: (error) => this.parseErrors(error)
+                error: (error) => {
+                    /* Set loading state to false to indicate that loading has completed with error */
+                    this.isLoading = false;
+                    /* Parse the error internally */
+                    this.parseErrors(error);
+                    /* Execute the error callback if provided */
+                    if (errorCallback) {
+                        errorCallback(error);
+                    }
+                }
             });
         }
     }
     /**
      * Loads an item by ID asynchronously.
+     *
+     * @param headers - Optional HTTP headers to include in the request.
+     * @param handleError - Indicates whether to automatically handle and parse errors (default: true).
+     * @param observeResponse - If true, the full HTTP response will be observed instead of just the body (default: false).
      * @returns An Observable of the loaded entity.
      */
-    loadItemAsync() {
+    loadItemAsync(headers, handleError = true, observeResponse = true) {
         if (this.id) {
+            /* Merge provided headers with default 'Disable-Cache' header */
+            const mergedHeaders = Object.assign({ 'Disable-Cache': 'Yes' }, headers || {});
+            /* Perform the GET request to load the entity */
             return this.service.get(this.id, Object.assign(this.query || {}, {
                 includes: this.includes?.length ? this.includes : this.updateIncludes,
                 projection: this.projection?.join(','),
                 observe: 'response'
-            }), { 'Disable-Cache': 'Yes' }, true, true).pipe(map((response) => {
+            }), mergedHeaders, handleError, observeResponse).pipe(map((response) => {
                 /* Read permissions from the http headers */
                 const permissions = response?.headers?.get('Permissions')?.split(';') ?? [];
                 return {
@@ -20850,7 +20871,7 @@ class BaseInterceptor {
         event => {
             if (event instanceof HttpResponse) {
                 /* Check for specific headers in the response */
-                if (req.headers.get('Show-Message')) {
+                if (req.headers.get('Show-Message')?.trim().toLowerCase() == 'yes') {
                     /* Show success messages for different types of requests */
                     if (req.method == 'POST') {
                         this.snackBar.open($localize `:@@snackbar.send.success:Data sent successfully.`, undefined, {
@@ -20885,6 +20906,10 @@ class BaseInterceptor {
         }, 
         /* Handle errors */
         error => {
+            /* Check if the 'Show-Message' header is set to 'yes' */
+            if (req.headers.get('Show-Message')?.trim().toLowerCase() != 'yes') {
+                return;
+            }
             /* Handle validation errors for status code 400 (Bad Request) */
             if (error.status == 400) {
                 let message = this.parseErrors(error.error);