@visns-studio/visns-components 5.4.2 → 5.4.4

package/package.json

@@ -1,7 +1,7 @@
 {
     "dependencies": {
         "@emotion/is-prop-valid": "^1.3.1",
-        "@fontsource/barlow": "^5.1.1",
+        "@fontsource/barlow": "^5.2.5",
         "@inovua/reactdatagrid-community": "^5.10.2",
         "@inovua/reactdatagrid-enterprise": "^5.10.2",
         "@nivo/bar": "^0.88.0",
@@ -19,7 +19,7 @@
         "fabric": "^6.5.4",
         "file-saver": "^2.0.5",
         "framer-motion": "^11.18.2",
-        "html-react-parser": "^5.2.2",
+        "html-react-parser": "^5.2.3",
         "lodash": "^4.17.21",
         "lodash.debounce": "^4.0.8",
         "moment": "^2.30.1",
@@ -78,7 +78,7 @@
         "react-dom": "^17.0.0 || ^18.0.0"
     },
     "name": "@visns-studio/visns-components",
-    "version": "5.4.2",
+    "version": "5.4.4",
     "description": "Various packages to assist in the development of our Custom Applications.",
     "main": "src/index.js",
     "files": [

package/src/components/crm/generic/GenericDetail.jsx

@@ -1070,10 +1070,14 @@ function GenericDetail({
                         case 'dropzone':
                             const downloadFile = (file) => {
                                 const { id, file_url, file_name } = file;
+                                const toastId = toast.loading(
+                                    'Downloading file...'
+                                );
 
                                 // If file_url exists, use it for the download, else use the id to download
                                 const urlToDownload =
-                                    file_url || `/ajax/files/download/${id}`;
+                                    file_url ||
+                                    `/ajax/files/downloadContent/${id}`;
 
                                 // Use fetch to retrieve the file as a blob
                                 fetch(urlToDownload, {
@@ -1083,19 +1087,129 @@ function GenericDetail({
                                             'application/octet-stream', // Specify content type as binary
                                     },
                                 })
-                                    .then((response) => response.blob()) // Convert response to Blob
+                                    .then(async (response) => {
+                                        if (!response.ok) {
+                                            // Try to extract error message from response if possible
+                                            // Clone the response to read it as JSON first
+                                            const clonedResponse =
+                                                response.clone();
+
+                                            try {
+                                                // First try to parse as JSON
+                                                const errorData =
+                                                    await clonedResponse.json();
+
+                                                if (
+                                                    errorData &&
+                                                    errorData.error
+                                                ) {
+                                                    throw new Error(
+                                                        errorData.error
+                                                    );
+                                                } else if (
+                                                    errorData &&
+                                                    errorData.message
+                                                ) {
+                                                    throw new Error(
+                                                        errorData.message
+                                                    );
+                                                } else if (
+                                                    errorData &&
+                                                    errorData.value
+                                                ) {
+                                                    throw new Error(
+                                                        errorData.value
+                                                    );
+                                                } else {
+                                                    // JSON parsed but no known error fields
+                                                    throw new Error(
+                                                        `HTTP error! Status: ${response.status}`
+                                                    );
+                                                }
+                                            } catch (jsonError) {
+                                                // If we can't parse as JSON, try to get text
+                                                try {
+                                                    const textResponse =
+                                                        response.clone();
+                                                    const errorText =
+                                                        await textResponse.text();
+
+                                                    // Check if the text looks like JSON but wasn't parsed correctly
+                                                    if (
+                                                        errorText.includes(
+                                                            '"error":'
+                                                        )
+                                                    ) {
+                                                        // Try to extract the error message with regex
+                                                        const errorMatch =
+                                                            errorText.match(
+                                                                /"error":"([^"]+)"/i
+                                                            );
+                                                        if (
+                                                            errorMatch &&
+                                                            errorMatch[1]
+                                                        ) {
+                                                            throw new Error(
+                                                                errorMatch[1]
+                                                            );
+                                                        }
+                                                    }
+
+                                                    // If we got text but couldn't extract a specific error
+                                                    if (
+                                                        errorText &&
+                                                        errorText.length < 100
+                                                    ) {
+                                                        throw new Error(
+                                                            errorText
+                                                        );
+                                                    }
+                                                } catch (textError) {
+                                                    // If all else fails, fall back to status
+                                                    throw new Error(
+                                                        `HTTP error! Status: ${response.status}`
+                                                    );
+                                                }
+                                            }
+                                        }
+                                        return response.blob(); // Convert response to Blob
+                                    })
                                     .then((blob) => {
+                                        // Validate that we have a valid blob with content
+                                        if (!blob || blob.size === 0) {
+                                            throw new Error(
+                                                'Downloaded file is empty or invalid'
+                                            );
+                                        }
+
                                         // Use FileSaver to download the file with the specified name
                                         saveAs(blob, file_name);
+
+                                        toast.update(toastId, {
+                                            render: 'Download successful!',
+                                            type: 'success',
+                                            isLoading: false,
+                                            autoClose: 5000,
+                                            closeButton: true,
+                                        });
                                     })
                                     .catch((error) => {
                                         console.error(
                                             'Error downloading the file:',
                                             error
                                         );
+
+                                        toast.update(toastId, {
+                                            render: `Error downloading file: ${
+                                                error.message || 'Unknown error'
+                                            }`,
+                                            type: 'error',
+                                            isLoading: false,
+                                            autoClose: 5000,
+                                            closeButton: true,
+                                        });
                                     });
                             };
-
                             const deleteFile = (e, id, name) => {
                                 if (e) {
                                     e.stopPropagation();

package/src/components/crm/generic/GenericDynamic.jsx

@@ -434,42 +434,109 @@ const GenericDynamic = ({
 
     const handleCustomButton = async (s) => {
         let payload = {};
-        switch (s.type) {
-            case 'save':
-                if (s.payload?.length > 0) {
-                    s.payload.forEach((p) => {
-                        if (data[p]) {
-                            payload[p] = data[p];
-                        }
-                    });
-                }
+        let toastId;
 
-                const resSave = await Download(s.url, s.method, payload);
+        try {
+            switch (s.type) {
+                case 'save':
+                    toastId = toast.loading('Downloading file...');
+
+                    if (s.payload?.length > 0) {
+                        s.payload.forEach((p) => {
+                            if (data[p]) {
+                                payload[p] = data[p];
+                            }
+                        });
+                    }
 
-                if (resSave.data) {
-                    saveAs(resSave.data);
-                }
-                break;
-            case 'fetch':
-                if (s.payload?.length > 0) {
-                    s.payload.forEach((p) => {
-                        if (data[p]) {
-                            payload[p] = data[p];
+                    const resSave = await Download(s.url, s.method, payload);
+
+                    if (resSave.data) {
+                        // Check if response has a value property which indicates an error
+                        if (resSave.data.value) {
+                            toast.update(toastId, {
+                                render: `Error: ${resSave.data.value}`,
+                                type: 'error',
+                                isLoading: false,
+                                autoClose: 5000,
+                                closeButton: true,
+                            });
+                        } else {
+                            saveAs(resSave.data);
+                            toast.update(toastId, {
+                                render: 'Download successful!',
+                                type: 'success',
+                                isLoading: false,
+                                autoClose: 5000,
+                                closeButton: true,
+                            });
                         }
-                    });
-                }
+                    } else {
+                        toast.update(toastId, {
+                            render: 'Error: No data received',
+                            type: 'error',
+                            isLoading: false,
+                            autoClose: 5000,
+                            closeButton: true,
+                        });
+                    }
+                    break;
 
-                const resFetch = await CustomFetch(s.url, s.method, payload);
+                case 'fetch':
+                    toastId = toast.loading('Fetching data...');
 
-                if (resFetch.data.error === '') {
-                    toast.success(
-                        s.message ? s.message : 'Form fetched successfully'
+                    if (s.payload?.length > 0) {
+                        s.payload.forEach((p) => {
+                            if (data[p]) {
+                                payload[p] = data[p];
+                            }
+                        });
+                    }
+
+                    const resFetch = await CustomFetch(
+                        s.url,
+                        s.method,
+                        payload
                     );
-                }
-                break;
-            default:
-                console.info(s, 'default');
-                break;
+
+                    if (resFetch.data.error === '') {
+                        toast.update(toastId, {
+                            render: s.message
+                                ? s.message
+                                : 'Form fetched successfully',
+                            type: 'success',
+                            isLoading: false,
+                            autoClose: 5000,
+                            closeButton: true,
+                        });
+                    } else {
+                        toast.update(toastId, {
+                            render: `Error: ${resFetch.data.error}`,
+                            type: 'error',
+                            isLoading: false,
+                            autoClose: 5000,
+                            closeButton: true,
+                        });
+                    }
+                    break;
+
+                default:
+                    console.info(s, 'default');
+                    break;
+            }
+        } catch (error) {
+            console.error('Error in handleCustomButton:', error);
+            if (toastId) {
+                toast.update(toastId, {
+                    render: `Error: ${error.message || 'Unknown error'}`,
+                    type: 'error',
+                    isLoading: false,
+                    autoClose: 5000,
+                    closeButton: true,
+                });
+            } else {
+                toast.error(`Error: ${error.message || 'Unknown error'}`);
+            }
         }
     };
 
@@ -713,10 +780,33 @@ const GenericDynamic = ({
                         setActiveFormKey(0);
                     }
                 } else {
-                    const activeFormData =
-                        data[type].length > 0 && Array.isArray(data[type])
-                            ? data[type][0]
-                            : data[type];
+                    let activeFormData;
+
+                    if (Array.isArray(data[type])) {
+                        console.info('a');
+                        // Check if this is an array of fields or an array of arrays of fields
+                        if (data[type].length > 0) {
+                            // Check if the first item has field properties or is itself an array of fields
+                            const firstItem = data[type][0];
+                            if (
+                                Array.isArray(firstItem) ||
+                                (typeof firstItem === 'object' &&
+                                    firstItem !== null &&
+                                    (firstItem.hasOwnProperty('id') ||
+                                        firstItem.hasOwnProperty('type')))
+                            ) {
+                                activeFormData = data[type];
+                            } else {
+                                activeFormData = data[type][0];
+                            }
+                        } else {
+                            // Empty array, use as is
+                            activeFormData = data[type];
+                        }
+                    } else {
+                        // Not an array, use as is
+                        activeFormData = data[type];
+                    }
 
                     setActiveForm(activeFormData);
                     setActiveFormKey(0);