@visns-studio/visns-components 5.9.13 → 5.9.144

package/package.json

@@ -87,7 +87,7 @@
         "react-dom": "^17.0.0 || ^18.0.0"
     },
     "name": "@visns-studio/visns-components",
-    "version": "5.9.13",
+    "version": "5.9.144",
     "description": "Various packages to assist in the development of our Custom Applications.",
     "main": "src/index.js",
     "files": [

package/src/components/crm/DataGrid.jsx

@@ -1498,7 +1498,9 @@ const DataGrid = forwardRef(
                                     CustomFetch(
                                         s.url + '/' + d[form.primaryKey],
                                         s.method,
-                                        {},
+                                        {
+                                            ...s.data,
+                                        },
                                         function (result) {
                                             if (result.error === '') {
                                                 handleReload();
@@ -2299,9 +2301,140 @@ const DataGrid = forwardRef(
             let allow = true;
 
             if (s.active) {
+                // Helper function to get nested values for main active condition (searches for target value)
+                const getNestedValueForMain = (data, path, targetValue) => {
+                    if (Array.isArray(path)) {
+                        return path.reduce(
+                            (currentValue, key) =>
+                                currentValue && currentValue[key] !== undefined
+                                    ? currentValue[key]
+                                    : undefined,
+                            data
+                        );
+                    } else if (typeof path === 'string' && path.includes('.')) {
+                        const keys = path.split('.');
+                        let currentValue = data;
+
+                        for (let i = 0; i < keys.length; i++) {
+                            const key = keys[i];
+
+                            if (!currentValue) return undefined;
+
+                            // Handle array search pattern like "customers[].pivot.is_primary"
+                            if (key.includes('[]')) {
+                                const arrayKey = key.replace('[]', '');
+                                const remainingPath = keys
+                                    .slice(i + 1)
+                                    .join('.');
+
+                                if (Array.isArray(currentValue[arrayKey])) {
+                                    // Search through the array for the target value
+                                    for (const item of currentValue[arrayKey]) {
+                                        const result = remainingPath
+                                            ? getNestedValueForMain(
+                                                  item,
+                                                  remainingPath,
+                                                  targetValue
+                                              )
+                                            : item;
+                                        if (result === targetValue) {
+                                            return result;
+                                        }
+                                    }
+                                }
+                                return undefined;
+                            } else {
+                                currentValue = currentValue[key];
+                            }
+                        }
+
+                        return currentValue;
+                    } else {
+                        // Fallback to simple property access
+                        return data[path];
+                    }
+                };
+                
+                // Helper function to get nested values for additional conditions (returns first valid value)
+                const getNestedValueForAdditional = (data, path) => {
+                    if (Array.isArray(path)) {
+                        return path.reduce(
+                            (currentValue, key) =>
+                                currentValue && currentValue[key] !== undefined
+                                    ? currentValue[key]
+                                    : undefined,
+                            data
+                        );
+                    } else if (typeof path === 'string' && path.includes('.')) {
+                        const keys = path.split('.');
+                        let currentValue = data;
+
+                        for (let i = 0; i < keys.length; i++) {
+                            const key = keys[i];
+
+                            if (!currentValue) return undefined;
+
+                            // Handle array search pattern like "customers[].id"
+                            if (key.includes('[]')) {
+                                const arrayKey = key.replace('[]', '');
+                                const remainingPath = keys
+                                    .slice(i + 1)
+                                    .join('.');
+
+                                if (Array.isArray(currentValue[arrayKey])) {
+                                    // Return the first valid result from the array
+                                    for (const item of currentValue[arrayKey]) {
+                                        const result = remainingPath
+                                            ? getNestedValueForAdditional(
+                                                  item,
+                                                  remainingPath
+                                              )
+                                            : item;
+                                        if (result !== undefined) {
+                                            return result;
+                                        }
+                                    }
+                                }
+                                return undefined;
+                            } else {
+                                currentValue = currentValue[key];
+                            }
+                        }
+
+                        return currentValue;
+                    } else {
+                        // Fallback to simple property access
+                        return data[path];
+                    }
+                };
+
+                // Get the active value using nested path or simple property access
+                const activeValue = getNestedValueForMain(d, s.active.id, s.active.value);
+                const hasActiveProperty = activeValue !== undefined;
+
+                // Check additional conditions if they exist
+                const checkAdditionalConditions = () => {
+                    if (
+                        !s.active.additional ||
+                        !Array.isArray(s.active.additional)
+                    ) {
+                        return true; // No additional conditions, so they pass
+                    }
+
+                    // All additional conditions must be met
+                    return s.active.additional.every((condition) => {
+                        const conditionValue = getNestedValueForAdditional(d, condition.id);
+                        // Type-flexible comparison - convert both to strings for comparison
+                        return String(conditionValue) === String(condition.value);
+                    });
+                };
+
+                const additionalConditionsMet = checkAdditionalConditions();
+
                 if (
-                    d.hasOwnProperty(s.active.id) &&
-                    d[s.active.id] === s.active.value &&
+                    hasActiveProperty &&
+                    String(activeValue) === String(s.active.value) &&
+                    additionalConditionsMet &&
                     s.active.type !== 'greater' &&
                     s.active.type !== 'not null'
                 ) {
@@ -2310,14 +2443,16 @@ const DataGrid = forwardRef(
                     };
                 } else if (
                     s.active.type === 'greater' &&
-                    d[s.active.id] > s.active.value
+                    Number(activeValue) > Number(s.active.value) &&
+                    additionalConditionsMet
                 ) {
                     iconStyle = {
                         color: s.active.colour,
                     };
                 } else if (
                     s.active.type === 'not null' &&
-                    d[s.active.id] !== null
+                    activeValue !== null &&
+                    additionalConditionsMet
                 ) {
                     iconStyle = {
                         color: s.active.colour,

package/src/components/crm/Field.jsx

@@ -259,11 +259,13 @@ function Field({
                 if (Array.isArray(s.child)) {
                     s.child.forEach((a) => {
                         if (a) {
+                            console.info(a);
                             filter = {
                                 where: [
                                     {
                                         id: s.id,
                                         value: _inputValue,
+                                        ...(a.whereHas && { whereHas: a.whereHas }),
                                     },
                                 ],
                             };

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

@@ -2127,6 +2127,41 @@ function GenericDetail({
                                 config.columns &&
                                 config.settings
                             ) {
+                                const processUrlParams = (obj) => {
+                                    if (Array.isArray(obj)) {
+                                        return obj.map(processUrlParams);
+                                    } else if (obj && typeof obj === 'object') {
+                                        const processed = {};
+                                        for (const [
+                                            key,
+                                            value,
+                                        ] of Object.entries(obj)) {
+                                            if (value === 'urlParam') {
+                                                processed[key] =
+                                                    routeParams[urlParam];
+                                            } else if (
+                                                typeof value === 'object' && value !== null
+                                            ) {
+                                                processed[key] =
+                                                    processUrlParams(value);
+                                            } else {
+                                                processed[key] = value;
+                                            }
+                                        }
+                                        return processed;
+                                    }
+                                    return obj;
+                                };
+
+                                const processedSettings = config.settings
+                                    ? processUrlParams(config.settings)
+                                    : config.settings;
+
+                                const processedConfig = {
+                                    ...config,
+                                    settings: processedSettings,
+                                };
+
                                 return (
                                     <>
                                         {activeTabConfig.dropzone &&
@@ -2292,7 +2327,7 @@ function GenericDetail({
                                         <div className={styles.grid__row}>
                                             <div className={styles.grid__full}>
                                                 <Table
-                                                    {...config}
+                                                    {...processedConfig}
                                                     ref={gridRef}
                                                     gridHeight={
                                                         windowHeight * 0.65