ui-soxo-bootstrap-core 2.6.31 → 2.6.32-dev.0

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

@@ -117,7 +117,8 @@ function CollapsedIconMenu({ menu, collapsed, icon, caption }) {
     return () => window.removeEventListener('resize', handleResize);
   }, []);
 
-  const menuText = t(caption);
+  const hasCaption = typeof caption === 'string' && caption.length > 0;
+  const menuText = hasCaption ? t(caption) : '';
   const menuContent = (
     <>
       {/* If value of collapsed is false show caption & icon else hiding caption and showing only icon*/}
@@ -129,9 +130,7 @@ function CollapsedIconMenu({ menu, collapsed, icon, caption }) {
 
           <div style={{ color: state.theme.colors.leftSectionColor }}>
             <span className="caption">
-              {/* {caption} */}
-              {/* <Trans i18nKey="Appointments"></Trans> */}
-              {t(`${caption}`)}
+              {menuText}
             </span>
           </div>
         </div>
@@ -142,8 +141,7 @@ function CollapsedIconMenu({ menu, collapsed, icon, caption }) {
           </span>
 
           <span style={{ color: state.theme.colors.colorPrimaryText, paddingLeft: '6px' }}>
-            {/* <>{caption}</> */}
-            {t(`${caption}`)}
+            {menuText}
           </span>
         </div>
       )}
@@ -151,7 +149,7 @@ function CollapsedIconMenu({ menu, collapsed, icon, caption }) {
   );
 
   // On mobile, or when the menu is collapsed (based on original logic), don't show the popover tooltip.
-  return isMobile || collapsed ? (
+  return isMobile || collapsed || !hasCaption ? (
     menuContent
   ) : (
     <Popover content={menuText} placement="right">
@@ -497,6 +495,11 @@ export default function SideMenu({ loading, modules = [], callback, appSettings,
               .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;
@@ -514,7 +517,9 @@ export default function SideMenu({ loading, modules = [], callback, appSettings,
               .map((menu, index) => {
                 // return <MenuItem menu={menu} index={index} />
 
-                let sub_menus = menu && menu.sub_menus ? Menus.screenMenus(menu.sub_menus) : [];
+                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);

package/core/models/core-scripts/core-scripts.js

@@ -69,7 +69,6 @@ class CoreScript extends Base {
     // Settings db pointer
     if (!dbPtr) dbPtr = localStorage.db_ptr;
     return ApiUtils.post({
-        // baseUrl: 'http://localhost:8002/dev/',  
       url: `core-scripts/dashboardquery/${id}`,
       formBody,
       headers: {
@@ -91,6 +90,20 @@ class CoreScript extends Base {
     });
   };
 
+  getCorescript = (formBody,dbPtr) => {
+   
+    if (!dbPtr) dbPtr = localStorage.db_ptr;
+    return ApiUtils.post({
+    //   baseUrl: 'http://localhost:8002/dev/',
+      url: `core-scripts/get-core-script`,
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: 'Bearer ' + localStorage.access_token,
+        db_ptr: dbPtr,
+      },
+      formBody,
+    });
+  };
   getQuery = (formBody) => {
     return ApiUtils.post({
       url: `core-scripts/execute-script-api`,

package/core/models/menus/menus.js

@@ -160,6 +160,29 @@ class MenusAPI extends Base {
     });
   };
 
+  getBranches = () => {
+    return ApiUtils.get({
+      url: 'branches',
+    });
+  };
+
+  switchBranch = (formBody, dbPtr) => {
+    return ApiUtils.post({
+      url: `auth/switch-branch`,
+      headers: { db_ptr: dbPtr },
+      formBody,
+    });
+  };
+
+  getProfile = (token) => {
+    return ApiUtils.get({
+      url: 'auth/profile',
+      headers: {
+        Authorization: `Bearer ${token}`,
+      },
+    });
+  };
+
   /**
    * create menu
    */
@@ -185,7 +208,6 @@ class MenusAPI extends Base {
         : 'menus/get-menus'; // NURA
 
     if (!dbPtr) dbPtr = localStorage.db_ptr;
-
     return this.get({
       url,
       config,
@@ -305,6 +327,12 @@ class MenusAPI extends Base {
       // }
     ];
   };
+  // license summary api call
+  getSummary = () => {
+    return ApiUtils.get({
+      url: 'license/summary',
+    });
+  };
 }
 
 export default MenusAPI;

package/core/modules/reporting/components/reporting-dashboard/display-columns/display-cell-renderer.js

@@ -1,7 +1,10 @@
-import React from 'react';
-import { Tag } from 'antd';
+import React, { useState, useContext } from 'react';
+import { Modal, Tag } from 'antd';
 import * as Icons from '@ant-design/icons';
 import { Link } from 'react-router-dom';
+import { GlobalContext, safeJSON, Location } from '../../../../../lib';
+// import { PdfViewer } from '../../../../../lib';
+import { CoreScripts } from '../../../../../models';
 
 /**
  * Utilities for rendering Reporting Dashboard display columns.
@@ -74,7 +77,7 @@ export function isActionTypeEntry(entry = {}) {
  * @param {DisplayRecord} record
  * @returns {string}
  */
-export function getRedirectLink(entry = {}, record = {}) {
+export function getRedirectLink(entry = {}, record = {}, CustomComponents = {}) {
   let redirectLink = entry.redirect_link || '';
 
   if (Array.isArray(entry.replace_variables)) {
@@ -87,6 +90,41 @@ export function getRedirectLink(entry = {}, record = {}) {
   return redirectLink;
 }
 
+/**
+ * Resolves the PDF/file location for file-based action entries.
+ *
+ * Supports either:
+ * - `entry.file_location` as a direct URL/path
+ * - `entry.file_location` as a record field name
+ *
+ * @param {DisplayColumnEntry} entry
+ * @param {DisplayRecord} record
+ * @returns {string}
+ */
+export function getFileLocation(entry = {}, record = {}) {
+  if (entry.file_location && typeof entry.file_location === 'string' && record[entry.file_location]) {
+    return record[entry.file_location];
+  }
+
+  return record.file_location || entry.file_location || '';
+}
+
+/**
+ * Resolves a value from the row when a config field points to a record key,
+ * otherwise returns the provided literal value.
+ *
+ * @param {*} value
+ * @param {DisplayRecord} record
+ * @returns {*}
+ */
+function resolveRecordValue(value, record = {}) {
+  if (typeof value === 'string' && Object.prototype.hasOwnProperty.call(record, value)) {
+    return record[value];
+  }
+
+  return value;
+}
+
 /**
  * Resolves action label text with backward-compatible precedence.
  *
@@ -170,6 +208,154 @@ function renderCustomComponent({ entry, record, CustomComponents, refresh }) {
   );
 }
 
+/**
+ * Renders a PDF file action inside a modal viewer.
+ *
+ * @param {Object} root0
+ * @param {DisplayColumnEntry} root0.entry
+ * @param {DisplayRecord} root0.record
+ * @param {Object.<string, React.ComponentType<any>>} root0.CustomComponents
+ * @returns {React.ReactNode}
+ */
+function FileActionLink({ entry, record, CustomComponents }) {
+  const [isPdfVisible, setIsPdfVisible] = useState(false);
+  const fileUrl = getFileLocation(entry, record);
+  const actionLabel = getActionLabel(entry, record);
+  const FileLoaderComponent = CustomComponents?.FileLoader;
+
+  if (!fileUrl) {
+    return null;
+  }
+
+  const fileLoaderProps = {
+    url: fileUrl,
+    type: resolveRecordValue(entry.file_type, record) || 'pdf',
+    defaultScale: resolveRecordValue(entry.default_scale, record),
+    viewerType: resolveRecordValue(entry.viewer_type, record),
+    config: {
+      requireLinuxPath: resolveRecordValue(entry.require_linux_path, record),
+      replaceBranch: resolveRecordValue(entry.replace_branch, record),
+      ...(entry.file_loader_config || {}),
+    },
+    entry,
+    record,
+  };
+
+  return (
+    <>
+      {/* 1. Add the trigger link/button here */}
+      <a
+        onClick={(e) => {
+          e.preventDefault();
+          setIsPdfVisible(true);
+        }}
+        style={{ cursor: 'pointer' }}
+      >
+        {actionLabel}
+      </a>
+
+      <Modal
+        open={isPdfVisible}
+        onCancel={() => setIsPdfVisible(false)}
+        footer={null}
+        destroyOnClose
+        width={950}
+        style={{ top: 10 }}
+        title={actionLabel}
+      >
+        {/* 2. Ensure the loader component exists */}
+        {FileLoaderComponent ? <FileLoaderComponent {...fileLoaderProps} /> : <p>Loader not found</p>}
+      </Modal>
+    </>
+  );
+}
+
+/**
+ * Returns the branch access list from the signed-in user's organization details.
+ *
+ * `organization_details` may arrive as a JSON string, so this helper keeps the
+ * parsing logic in one place before branch comparisons are made.
+ *
+ * @param {Object} user
+ * @returns {Array}
+ */
+function getAccessibleBranches(user = {}) {
+  const orgDetails = safeJSON(user?.organization_details);
+  return Array.isArray(orgDetails?.branch) ? orgDetails.branch : [];
+}
+
+/**
+ * Resolves branch metadata used to decide whether an action link should prompt
+ * for a branch switch before navigation.
+ *
+ * When an action entry includes `replace_variables` with the `index` field, the
+ * row is treated as branch-aware content. We compare the record's branch id
+ * against the active branch from `localStorage.db_ptr`, and also resolve whether
+ * the user has access to the target branch.
+ *
+ * @param {DisplayColumnEntry} entry
+ * @param {DisplayRecord} record
+ * @param {Object} user
+ * @returns {{requiresBranchSwitch: boolean, hasTargetBranchAccess: boolean}}
+ */
+function getBranchNavigationState(entry = {}, record = {}, user = {}) {
+  const branchFieldConfig = entry.replace_variables?.find((variable) => variable.field === 'index');
+
+  if (!branchFieldConfig) {
+    return { requiresBranchSwitch: false, hasTargetBranchAccess: false };
+  }
+
+  const accessibleBranches = getAccessibleBranches(user);
+  const activeDbPtr = localStorage.getItem('db_ptr');
+  const activeBranch = accessibleBranches.find((branch) => String(branch.dbPtr) === String(activeDbPtr));
+  const targetBranchId = record[branchFieldConfig.field];
+  const targetBranch = accessibleBranches.find((branch) => String(branch.branch_id) === String(targetBranchId));
+
+  return {
+    requiresBranchSwitch: Boolean(targetBranchId) && String(activeBranch?.branch_id) !== String(targetBranchId),
+    hasTargetBranchAccess: Boolean(targetBranch),
+  };
+}
+
+/**
+ * Renders a branch-switch confirmation link for cross-branch records.
+ *
+ * The actual branch change is handled by the landing page via the `index`
+ * query parameter. This link only confirms intent and blocks navigation when
+ * the user does not have access to the target branch.
+ *
+ * @param {Object} root0
+ * @param {string} root0.label
+ * @param {string} root0.redirectLink
+ * @param {boolean} root0.hasTargetBranchAccess
+ * @returns {React.ReactNode}
+ */
+function BranchAwareActionLink({ label, redirectLink, hasTargetBranchAccess }) {
+  return (
+    <a
+      onClick={(e) => {
+        e.preventDefault();
+        Modal.confirm({
+          title: 'Switch Branch?', // Adding a title makes it look more standard
+          content: 'This record belongs to another branch. Would you like to switch branches to view the details?',
+          onOk: () => {
+            if (hasTargetBranchAccess) {
+              Location.navigate({ url: redirectLink });
+              return;
+            }
+
+            Modal.error({
+              title: 'Access Denied',
+              content: 'This data belongs to another branch.Would you like to switch branches to view the details?',
+            });
+          },
+        });
+      }}
+    >
+      {label}
+    </a>
+  );
+}
 /**
  * Renders table cell content for a configured display column.
  *
@@ -210,10 +396,21 @@ export function renderDisplayCell({ entry, record, CustomComponents, refresh })
     }
     return null;
   }
-
   if (isLegacyActionEntry(entry) || isActionTypeEntry(entry)) {
+    if (entry.redirect_link_type === 'file') {
+      return <FileActionLink entry={entry} record={record} CustomComponents={CustomComponents} />;
+    }
+    const { user = {} } = useContext(GlobalContext);
+
     const redirectLink = getRedirectLink(entry, record);
-    return <Link to={`${redirectLink}`}>{getActionLabel(entry, record)}</Link>;
+    const label = getActionLabel(entry, record);
+    const { requiresBranchSwitch, hasTargetBranchAccess } = getBranchNavigationState(entry, record, user);
+
+    if (requiresBranchSwitch) {
+      return <BranchAwareActionLink label={label} redirectLink={redirectLink} hasTargetBranchAccess={hasTargetBranchAccess} />;
+    }
+
+    return <Link to={`${redirectLink}`}>{label}</Link>;
   }
 
   if (entry.field === 'custom') {

package/core/modules/reporting/components/reporting-dashboard/display-columns/display-cell-renderer.test.js

@@ -3,6 +3,7 @@ import {
   isLegacyActionEntry,
   isActionTypeEntry,
   getRedirectLink,
+  getFileLocation,
   getActionLabel,
   renderDisplayCell,
 } from './display-cell-renderer';
@@ -28,6 +29,13 @@ describe('display-cell-renderer', () => {
     expect(link).toBe('/bill/10/visit/OP100');
   });
 
+  test('resolves file location from direct config value or record field', () => {
+    expect(getFileLocation({ file_location: 'https://example.com/report.pdf' }, {})).toBe('https://example.com/report.pdf');
+    expect(getFileLocation({ file_location: 'document_url' }, { document_url: 'https://example.com/record.pdf' })).toBe(
+      'https://example.com/record.pdf',
+    );
+  });
+
   test('keeps legacy action label behavior unchanged', () => {
     const entry = {
       field: 'action',
@@ -77,6 +85,71 @@ describe('display-cell-renderer', () => {
     expect(element.props.opb_id).toBe(1);
   });
 
+  test('renders file action entry as pdf viewer trigger', () => {
+    const element = renderDisplayCell({
+      entry: {
+        type: 'action',
+        field: 'action_text',
+        redirect_link_type: 'file',
+        file_location: 'https://example.com/report.pdf',
+        label: 'Open PDF',
+      },
+      record: { action_text: 'Preview PDF' },
+      refresh: jest.fn(),
+      CustomComponents: {},
+    });
+
+    expect(typeof element.type).toBe('function');
+    expect(element.props.entry.redirect_link_type).toBe('file');
+    expect(element.props.entry.file_location).toBe('https://example.com/report.pdf');
+  });
+
+  test('passes file action props to CustomComponents.FileUpload when available', () => {
+    const FileUpload = () => null;
+    const element = renderDisplayCell({
+      entry: {
+        type: 'action',
+        field: 'action_text',
+        redirect_link_type: 'file',
+        file_location: 'document_path',
+        file_type: 'document_type',
+        default_scale: 'zoom_level',
+        viewer_type: 'inline_viewer',
+        require_linux_path: 'needs_linux_path',
+        replace_branch: 'should_replace_branch',
+        file_loader_config: {
+          sample: true,
+        },
+      },
+      record: {
+        action_text: 'Preview',
+        document_path: '\\\\server\\reports\\doc.pdf',
+        document_type: 'pdf',
+        zoom_level: 1.25,
+        inline_viewer: true,
+        needs_linux_path: true,
+        should_replace_branch: false,
+      },
+      refresh: jest.fn(),
+      CustomComponents: { FileUpload },
+    });
+
+    expect(typeof element.type).toBe('function');
+
+    const modalContent = element.props.children[1].props.children;
+    expect(modalContent.type).toBe(FileUpload);
+    expect(modalContent.props.url).toBe('\\\\server\\reports\\doc.pdf');
+    expect(modalContent.props.type).toBe('pdf');
+    expect(modalContent.props.defaultScale).toBe(1.25);
+    expect(modalContent.props.viewerType).toBe(true);
+    expect(modalContent.props.config).toEqual({
+      requireLinuxPath: true,
+      replaceBranch: false,
+      sample: true,
+    });
+    expect(modalContent.props.record.document_path).toBe('\\\\server\\reports\\doc.pdf');
+  });
+
   test('renders styled tag/span/icon/text for non-action path', () => {
     const tagElement = renderDisplayCell({
       entry: { field: 'status', enableColor: true, columnType: 'tag' },