ui-soxo-bootstrap-core 2.6.40-dev.12 → 2.6.40-dev.16

package/core/lib/components/sidemenu/sidemenu.js

@@ -385,6 +385,71 @@ export default function SideMenu({ loading, modules = [], callback, appSettings,
 
   const rootSubmenuKeys = Menus.screenMenus(modules, 'order').map((m) => m.id || m.path || m.caption);
 
+  /**
+   * Recursively renders the menu tree to any depth. Any menu that has visible
+   * children is rendered as a <SubMenu>; everything else becomes a clickable
+   * leaf <Menu.Item>. This replaces the old hard-coded 3-level rendering so
+   * menus nested 4, 5, 6+ levels deep all show up.
+   *
+   * Keys are kept identical to the previous implementation
+   * (SubMenu => id || path || caption, leaf => path || caption) so the
+   * openKeys / selectedKeys / onOpenChange logic continues to work.
+   */
+  const renderMenuTree = (items, { isRoot = false, parentKey } = {}) => {
+    const visibleItems = Menus.screenMenus(items, 'order').filter((record) => {
+      // Drop entries without a caption — they have no label to render.
+      const hasCaption = typeof record.caption === 'string' && record.caption.trim().length > 0;
+      if (!hasCaption) return false;
+
+      // The visibility / icon rule only applies to top-level menus, matching the
+      // previous behaviour; nested items just need a caption.
+      if (!isRoot) return true;
+
+      if (record.id) {
+        if (record.is_visible) return true;
+        return !!record.icon_name;
+      }
+
+      return true;
+    });
+
+    return visibleItems.map((menu, index) => {
+      const icon = menu.icon_name || 'fa-solid fas fa-user';
+
+      // Children that actually have something to show (a caption).
+      const children =
+        menu && menu.sub_menus
+          ? Menus.screenMenus(menu.sub_menus, 'order').filter((s) => typeof s.caption === 'string' && s.caption.trim().length > 0)
+          : [];
+
+      if (children.length) {
+        return (
+          <SubMenu
+            className="popup"
+            style={{ color: state.theme.colors.leftSectionColor }}
+            key={menu.id || menu.path || menu.caption}
+            title={
+              <span>
+                <CollapsedIconMenu menu={menu} caption={menu.caption} icon={icon} collapsed={collapsed} />
+              </span>
+            }
+          >
+            {renderMenuTree(menu.sub_menus, { isRoot: false, parentKey: menu.path || menu.caption })}
+          </SubMenu>
+        );
+      }
+
+      return (
+        <Menu.Item
+          key={menu.path || menu.caption}
+          onClick={() => onMenuClick({ ...menu, parentKey: parentKey || menu.path || menu.caption, isRoot }, index)}
+        >
+          <CollapsedIconMenu menu={menu} caption={menu.caption} icon={icon} collapsed={collapsed} />
+        </Menu.Item>
+      );
+    });
+  };
+
   return (
     <div className="sidemenu">
       {loading ? (
@@ -490,153 +555,7 @@ export default function SideMenu({ loading, modules = [], callback, appSettings,
               })
             } */}
 
-            {Menus.screenMenus(modules, 'order')
-
-              .filter((record) => {
-                icon = record;
-
-                // Drop entries without a caption — they have no permission/label
-                // to render, so showing just an icon is misleading.
-                const hasCaption = typeof record.caption === 'string' && record.caption.trim().length > 0;
-                if (!hasCaption) return false;
-
-                if (record.id) {
-                  if (record.is_visible) {
-                    return true;
-                  }
-
-                  if (record.icon_name) {
-                    return true;
-                  } else {
-                    return false;
-                  }
-                } else {
-                  return true;
-                }
-              })
-              .map((menu, index) => {
-                // return <MenuItem menu={menu} index={index} />
-
-                let sub_menus = menu && menu.sub_menus
-                  ? Menus.screenMenus(menu.sub_menus).filter((s) => typeof s.caption === 'string' && s.caption.trim().length > 0)
-                  : [];
-
-                if (menu && sub_menus && sub_menus.length) {
-                  // let randomIndex = parseInt(Math.random() * 10000000000);
-
-                  return (
-                    <SubMenu
-                      className="popup"
-                      style={{ color: state.theme.colors.leftSectionColor }}
-                      // key={`first-level-${randomIndex}-${menu.caption}`}
-
-                      key={menu.id || menu.path || menu.caption}
-                      title={
-                        <>
-                          <CollapsedIconMenu
-                            menu={menu}
-                            caption={menu.caption}
-                            icon={menu.icon_name || 'fa-solid fas fa-user'}
-                            collapsed={collapsed}
-                          />
-                        </>
-                      }
-                    >
-                      {sub_menus.map((submenu, innerIndex) => {
-                        // let randomIndex = parseInt(Math.random() * 10000000000);
-
-                        let third_menus = submenu && submenu.sub_menus ? Menus.screenMenus(submenu.sub_menus) : [];
-
-                        if (third_menus && third_menus.length) {
-                          return (
-                            <SubMenu
-                              className="popup"
-                              // key={`second-level-${randomIndex}-${submenu.id}`}
-
-                              key={submenu.id || submenu.path || submenu.caption}
-                              title={
-                                <span>
-                                  <CollapsedIconMenu
-                                    menu={menu}
-                                    caption={submenu.caption}
-                                    icon={submenu.icon_name || 'fa-solid fas fa-user'}
-                                    collapsed={collapsed}
-                                  />
-                                </span>
-                              }
-                            >
-                              {third_menus.map((menu) => {
-                                // let randomIndex = parseInt(Math.random() * 10000000000);
-
-                                return (
-                                  <Menu.Item
-                                    // onClick={() => {
-                                    //   onMenuClick(menu, index);
-                                    // }}
-                                    onClick={() => {
-                                      onMenuClick({ ...menu, parentKey: submenu.path || submenu.caption }, index);
-                                    }}
-                                    // key={`second-level-${randomIndex}-${index}`}
-
-                                    key={menu.path || menu.caption}
-                                  >
-                                    <CollapsedIconMenu
-                                      menu={menu}
-                                      caption={menu.caption}
-                                      icon={menu.icon_name || 'fa-solid fas fa-user'}
-                                      collapsed={collapsed}
-                                    />
-                                  </Menu.Item>
-                                );
-                              })}
-                            </SubMenu>
-                          );
-                        } else {
-                          // let randomIndex = parseInt(Math.random() * 10000000000);
-
-                          return (
-                            <Menu.Item
-                              // onClick={() => {
-                              //   onMenuClick(submenu, index);
-                              // }}
-                              onClick={() => {
-                                onMenuClick({ ...submenu, parentKey: menu.path || menu.caption }, index);
-                              }}
-                              // key={`first-level-${randomIndex}-${innerIndex}`}
-                              key={submenu.path || submenu.caption}
-                            >
-                              <CollapsedIconMenu
-                                menu={menu}
-                                caption={submenu.caption}
-                                icon={submenu.icon_name || 'fa-solid fas fa-user'}
-                                collapsed={collapsed}
-                              />
-                            </Menu.Item>
-                          );
-                        }
-                      })}
-                    </SubMenu>
-                  );
-                } else {
-                  // let randomIndex = parseInt(Math.random() * 10000000000);
-
-                  return (
-                    <Menu.Item
-                      // onClick={() => {
-                      //   onMenuClick(menu, index);
-                      // }}
-
-                      onClick={() => {
-                        onMenuClick({ ...menu, parentKey: menu.path || menu.caption, isRoot: true }, index);
-                      }}
-                      // key={`${menu.id}-${randomIndex}`}
-                      key={menu.path || menu.caption}
-                    >
-                      <CollapsedIconMenu menu={menu} caption={menu.caption} icon={menu.icon_name || 'fa-solid fas fa-user'} collapsed={collapsed} />
-                    </Menu.Item>
-                  );
-                }
-              })}
+            {renderMenuTree(modules, { isRoot: true })}
 
             {loading ? (
               <div class="skeleton-wrapper"></div>

package/core/models/menus/components/menu-add/menu-add.js

@@ -116,6 +116,13 @@ const MenuAdd = ({ model, callback, edit, history, formContent, match, additiona
       values.step = formContent.step || step;
     }
 
+    //  Cleared selects come back as undefined; send null so the backend clears them
+    ['model_id', 'page_id', 'header_id'].forEach((field) => {
+      if (values[field] === undefined) {
+        values[field] = null;
+      }
+    });
+
     if (values.attributes && typeof values === 'object') {
       values = {
         ...values,
@@ -183,7 +190,7 @@ const MenuAdd = ({ model, callback, edit, history, formContent, match, additiona
               {/* Model */}
               <Form.Item label="Models" name={'model_id'}>
                 {/* <ReferenceSelect value={model.id} label={model.name} model={Models} /> */}
-                <Select showSearch style={{ width: '100%' }} placeholder="Select a Page" optionFilterProp="label">
+                <Select showSearch style={{ width: '100%' }} placeholder="Select a Page" optionFilterProp="label" allowClear>
                   {models.map((model, key) => (
                     <Option key={key} label={model.name} value={model.id}>
                       {model.name}
@@ -198,7 +205,7 @@ const MenuAdd = ({ model, callback, edit, history, formContent, match, additiona
               <Form.Item label="Pages" name={'page_id'}>
                 {/* <ReferenceSelect value={pages.id} label={pages.name} model={Pages} /> */}
 
-                <Select showSearch optionFilterProp="children" style={{ width: '100%' }}>
+                <Select showSearch optionFilterProp="children" style={{ width: '100%' }} allowClear>
                   {pages.map((model, key) => (
                     <Option key={key} value={model.id}>
                       {model.name}
@@ -229,13 +236,33 @@ const MenuAdd = ({ model, callback, edit, history, formContent, match, additiona
               {/* Pages Ends */}
 
               {/* Path */}
-              <Form.Item name="path" label="Path" rules={[{ required: true, message: 'Path is required' }]}>
+              <Form.Item
+                name="path"
+                label="Path"
+                rules={[
+                  { required: true, message: 'Path is required' },
+                  {
+                    pattern: /^\//,
+                    message: 'Path must start with /',
+                  },
+                ]}
+              >
                 <Input placeholder="Enter path" />
               </Form.Item>
               {/* Path Ends */}
 
               {/* Route */}
-              <Form.Item name="route" label="Route" rules={[{ required: true, message: 'Route is required' }]}>
+              <Form.Item
+                name="route"
+                label="Route"
+                rules={[
+                  { required: false, message: 'Route is required' },
+                  {
+                    pattern: /^\//,
+                    message: 'Route must start with /',
+                  },
+                ]}
+              >
                 <Input placeholder="Enter route" />
               </Form.Item>
               {/* Route Ends */}

package/core/models/menus/components/menu-lists/menu-lists.js

@@ -30,8 +30,9 @@ const MenuLists = ({ model, match, relativeAdd = false, additional_queries = [],
   const [query, setQuery] = useState('');
   const [dragMode, setDragMode] = useState(false);
   const [orderChanged, setOrderChanged] = useState(false);
-  // keys of manually-expanded top-level panels (used when NOT searching)
-  const [manualOpenKeys, setManualOpenKeys] = useState([]);
+  // keys of currently-expanded top-level panels. Seeded from the search results
+  // when the query changes, but the user can freely toggle panels afterwards.
+  const [openKeys, setOpenKeys] = useState([]);
 
   const [nextId, setNextId] = useState(10000);
 
@@ -183,6 +184,16 @@ const MenuLists = ({ model, match, relativeAdd = false, additional_queries = [],
         return;
       }
 
+      // Prevent moving a menu into one of its own descendants
+      // (e.g. A > B, C — A cannot be dropped under B or C).
+      if (targetParentId) {
+        const draggedNode = findMenuById(records, draggedItem.id);
+        if (draggedNode && findMenuById(draggedNode.sub_menus || [], targetParentId)) {
+          message.warning('Cannot move a menu into its own sub menu');
+          return;
+        }
+      }
+
       // Remove item from original location
       const { newItems: itemsAfterRemove, foundItem } = findAndRemoveItem(records, draggedItem.id);
 
@@ -196,7 +207,7 @@ const MenuLists = ({ model, match, relativeAdd = false, additional_queries = [],
 
       setRecords(finalItems);
       setOrderChanged(true);
-      message.success(`Moved "${foundItem.name}" to level ${targetLevel}`);
+      message.success(`Moved "${foundItem.caption}" to level ${targetLevel}`);
     },
     [records]
   );
@@ -234,10 +245,13 @@ const MenuLists = ({ model, match, relativeAdd = false, additional_queries = [],
   const searchActive = !!query;
   const visibleItems = filterMenus(records, query);
 
-  // While searching, derive the open panels synchronously from the visible tree
-  // (every branch on the path to a match), so the matched sub-menu is revealed.
-  // When not searching, use the user's manually-expanded panels.
-  const activeKeys = searchActive ? expandableKeys(visibleItems) : manualOpenKeys;
+  // When the query changes, seed the open panels from the search results (every
+  // branch on the path to a match) so the matched sub-menu is revealed. After
+  // that the user can collapse/expand freely via the Collapse onChange below.
+  useEffect(() => {
+    setOpenKeys(query ? expandableKeys(filterMenus(records, query)) : []);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [query]);
 
   const onSearch = (event) => {
     setQuery(event.target.value);
@@ -395,8 +409,8 @@ const MenuLists = ({ model, match, relativeAdd = false, additional_queries = [],
               <DndProvider backend={HTML5Backend}>
                 <Collapse
                   accordion={!searchActive}
-                  activeKey={activeKeys}
-                  onChange={(keys) => setManualOpenKeys(Array.isArray(keys) ? keys : keys ? [keys] : [])}
+                  activeKey={openKeys}
+                  onChange={(keys) => setOpenKeys(Array.isArray(keys) ? keys : keys ? [keys] : [])}
                 >
                   {visibleItems && visibleItems.length > 0 ? (
                     visibleItems.map((item, index) => (
@@ -549,13 +563,21 @@ function NestedMenu({
   onChange,
 }) {
   const [localItems, setLocalItems] = useState(items);
-  // keys of manually-expanded sub-panels (used when NOT searching)
-  const [manualOpenKeys, setManualOpenKeys] = useState([]);
+  // keys of currently-expanded sub-panels. Seeded from the search results when
+  // the query changes, but the user can freely toggle panels afterwards.
+  const [openKeys, setOpenKeys] = useState([]);
 
   useEffect(() => {
     setLocalItems(items);
   }, [items]);
 
+  // Seed the open sub-panels from the search path when the query changes; keep
+  // the user's toggles otherwise so a search-opened panel can be closed.
+  useEffect(() => {
+    setOpenKeys(searchActive ? (items || []).filter((c) => c.sub_menus && c.sub_menus.length > 0).map((c) => String(c.id)) : []);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [query, searchActive]);
+
   const moveSubMenu = useCallback(
     (from, to) => {
       if (!dragMode || from === to) return;
@@ -574,17 +596,11 @@ function NestedMenu({
     return null;
   }
 
-  // While searching, derive the open sub-panels from the items so the path to a
-  // match stays expanded; otherwise use the user's manually-expanded panels.
-  const activeKeys = searchActive
-    ? localItems.filter((c) => c.sub_menus && c.sub_menus.length > 0).map((c) => String(c.id))
-    : manualOpenKeys;
-
   return (
     <Collapse
       accordion={!searchActive}
-      activeKey={activeKeys}
-      onChange={(keys) => setManualOpenKeys(Array.isArray(keys) ? keys : keys ? [keys] : [])}
+      activeKey={openKeys}
+      onChange={(keys) => setOpenKeys(Array.isArray(keys) ? keys : keys ? [keys] : [])}
     >
       {localItems.map((child, index) => (
         <Panel

package/core/models/roles/components/role-add/role-add.js

@@ -145,11 +145,19 @@ const RoleAdd = ({ model, callback, edit, formContent = {}, match, additional_qu
     });
 
     try {
-      await RolesAPI.createRole(payload); //  single API
+      const res = await RolesAPI.createRole(payload); //  single API
+
+      // it via success: false — show that message as a warning.
+      if (res?.success === false) {
+        message.warning(res.message || 'Failed to save role');
+        return;
+      }
+
       message.success(formContent?.id ? 'Role Updated' : 'Role Added');
       callback();
     } catch (err) {
-      // message.error('Something went wrong');
+      // Surface any unexpected backend error message as a warning.
+      message.warning(err?.message || err?.result?.message || 'Failed to save role');
     } finally {
       onSubmittingChange?.(false);
     }

package/core/models/roles/roles.js

@@ -163,6 +163,9 @@ class RolesAPI extends BaseAPI {
     return ApiUtils.post({
       url: `core-roles/save-core-role`,
       formBody,
+      // Let the caller surface the backend message (as a warning) instead of
+      // the default red error toast from the http layer.
+      hideError: true,
     });
   };
 

package/core/modules/reporting/components/reporting-dashboard/reporting-dashboard.js

@@ -687,6 +687,29 @@ export default function ReportingDashboard({
   );
 }
 
+/**
+ * Filters report records using the same search text that drives the table.
+ *
+ * @param {Array<Object>} records - Report rows.
+ * @param {string} searchText - Current table search text.
+ * @returns {Array<Object>} Rows matching the search text.
+ */
+function filterReportRecords(records, searchText) {
+  if (!Array.isArray(records)) return [];
+
+  const query = String(searchText || '').trim().toLowerCase();
+
+  if (!query) return records;
+
+  return records.filter((record) =>
+    Object.values(record).some((value) => {
+      if (value === undefined || value === null || typeof value === 'object') return false;
+
+      return String(value).toLowerCase().indexOf(query) !== -1;
+    })
+  );
+}
+
 /**
  *
  * @param root0
@@ -804,13 +827,13 @@ function GuestList({
         return col;
       });
       const summaryCols = columns.filter((col) => col.enable_summary);
-      let dataToExport = [...patients];
+      let dataToExport = [...filterReportRecords(patients, query)];
 
       if (summaryCols.length > 0) {
         // Build one synthetic row for CSV export that mirrors the table layout:
         // numeric summary cells are populated from `calculateSummaryValues`, while
         // non-summary columns stay blank unless a configured caption should be shown.
-        const summaryValues = calculateSummaryValues(summaryCols, patients);
+        const summaryValues = calculateSummaryValues(summaryCols, dataToExport);
         const summaryRow = { isSummaryRow: true };
 
         cols.forEach((col, index) => {
@@ -837,37 +860,15 @@ function GuestList({
       }
       let exportDatas = getExportData(dataToExport, exportCols);
 
-      if (exportDatas.exportDataColumns.length && exportDatas.exportDataHeaders.length) {
+      if (exportDatas.exportDataHeaders.length) {
         setExportData({ exportDatas });
+      } else {
+        setExportData({});
       }
     }
-  }, [patients, columns]);
+  }, [patients, columns, query]);
 
-  let filtered;
-
-  if (patients) {
-    filtered = patients.filter((record) => {
-      if (query) {
-        // Keys
-        let keys = Object.keys(record);
-
-        let flag = false;
-
-        keys.forEach((key) => {
-          let ele = record[key];
-
-          if (ele && typeof ele === 'string' && ele.toLowerCase().indexOf(query.toLowerCase()) !== -1) {
-            flag = true;
-          }
-        });
-
-        /**Will return flag */
-        return flag;
-      } else {
-        return true;
-      }
-    });
-  }
+  let filtered = filterReportRecords(patients, query);
 
   /**
    * Checks for a match in the filtered patient list based on a scanned code,
@@ -1056,7 +1057,7 @@ function GuestList({
               dataSource={filtered ? filtered : patients} // In case if there is no filtered values we can use patient data
               columns={cols}
               sticky
-              pagination={false}
+              pagination={true}
               summary={(pageData) => {
                 const summaryCols = columns.filter((col) => col.enable_summary);
                 if (!summaryCols.length) return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ui-soxo-bootstrap-core",
-  "version": "2.6.40-dev.12",
+  "version": "2.6.40-dev.16",
   "description": "All the Core Components for you to start",
   "keywords": [
     "all in one"