ui-soxo-bootstrap-core 2.6.46-dev.5 → 2.6.46-dev.6

package/core/components/landing-api/landing-api.js

@@ -2,7 +2,7 @@ import { useContext, useEffect, useRef, useState } from 'react';
 
 import { Route, Switch } from 'react-router-dom';
 
-import { Skeleton } from 'antd';
+import { Skeleton, message, Modal } from 'antd';
 
 import { Card, ChangePassword, GlobalContext, GlobalHeader, ModuleRoutes, Profile, SettingsUtil, SpotlightSearch, useTranslation } from '../../lib';
 
@@ -46,7 +46,6 @@ function getRandomMessage(previousMessage = '') {
  */
 export default function LandingApi({ history, CustomComponents, CustomModels, appSettings, transitionPending = false, onHomeReady, ...props }) {
   const [loader, setLoader] = useState(false);
-
   // const [modules, setModules] = useState([]);
 
   const [connected] = useState();
@@ -66,7 +65,67 @@ export default function LandingApi({ history, CustomComponents, CustomModels, ap
 
   var config = {};
 
-  //fetch license summary
+ 
+
+  // Variable decides the control of homepage
+  // #TODO This is a temporary fix - Homemage
+
+  let disableHomepage = false;
+
+  if (process.env.REACT_APP_DISABLEHOMEPAGE) {
+    disableHomepage = JSON.parse(process.env.REACT_APP_DISABLEHOMEPAGE);
+  }
+
+  /**
+   * Normalizes the user's branch access list from `organization_details`.
+   *
+   * The API can return `organization_details` as a JSON string, so we always
+   * parse it through `safeJSON` before reading the branch collection.
+   *
+   * @returns {Array} List of branches the current user can access.
+   */
+  const getAccessibleBranches = () => {
+    const orgDetails = safeJSON(user?.organization_details);
+    return Array.isArray(orgDetails?.branch) ? orgDetails.branch : [];
+  };
+
+  /**
+   * Resolves the currently selected branch record using the persisted db pointer.
+   *
+   * @param {Array} branches
+   * @returns {Object|null}
+   */
+  const getCurrentBranchRecord = (branches) => {
+    const currentDbPtr = localStorage.getItem('db_ptr');
+    return branches.find((branch) => String(branch.dbPtr) === String(currentDbPtr)) || null;
+  };
+
+  /**
+   * Resolves the target branch from the URL `index` query parameter.
+   *
+   * @param {Array} branches
+   * @param {string|null} branchId
+   * @returns {Object|null}
+   */
+  const getBranchRecordById = (branches, branchId) => {
+    return branches.find((branch) => String(branch.branch_id) === String(branchId)) || null;
+  };
+
+  /**
+   * Persists branch-specific auth data after a successful switch.
+   *
+   * @param {Object} tokenBundle
+   * @param {string} dbPtr
+   */
+  const persistBranchSession = (tokenBundle, dbPtr) => {
+    const accessToken = tokenBundle?.access_token;
+    const refreshToken = tokenBundle?.refresh_token;
+
+    if (accessToken) localStorage.setItem('access_token', accessToken);
+    if (refreshToken) localStorage.setItem('refresh_token', refreshToken);
+    if (dbPtr) localStorage.setItem('db_ptr', dbPtr);
+  };
+
   const fetchSummary = async () => {
     try {
       const res = await MenusAPI.getSummary();
@@ -81,16 +140,6 @@ export default function LandingApi({ history, CustomComponents, CustomModels, ap
       console.error(err);
     }
   };
-
-  // Variable decides the control of homepage
-  // #TODO This is a temporary fix - Homemage
-
-  let disableHomepage = false;
-
-  if (process.env.REACT_APP_DISABLEHOMEPAGE) {
-    disableHomepage = JSON.parse(process.env.REACT_APP_DISABLEHOMEPAGE);
-  }
-
   // useEffect(() => {
 
   //     // Initialize the menus for the logged in user
@@ -106,6 +155,67 @@ export default function LandingApi({ history, CustomComponents, CustomModels, ap
   //     }
   // }, [loader]);
 
+  /**
+   * Synchronizes the active branch with the `index` query parameter.
+   *
+   * Flow:
+   * 1. Read the target branch id from the URL.
+   * 2. Compare it against the branch represented by the current `db_ptr`.
+   * 3. Switch branch only when the user has access and the branch actually differs.
+   * 4. Refresh auth/profile state and reload menus for the new branch context.
+   */
+  useEffect(() => {
+    const handleUrlBranchSwitch = async () => {
+      const searchParams = new URLSearchParams(history.location.search);
+      const urlDbPtr = searchParams.get('index');
+      if (!urlDbPtr) return;
+
+      const accessibleBranches = getAccessibleBranches();
+      const currentBranch = getCurrentBranchRecord(accessibleBranches);
+      const targetBranch = getBranchRecordById(accessibleBranches, urlDbPtr);
+
+      if (!targetBranch || String(currentBranch?.branch_id) === String(urlDbPtr)) return;
+
+      setLoader(true);
+
+      try {
+        const switchResult = await MenusAPI.switchBranch(
+          {
+            firm_id: targetBranch.firm_ptr,
+            branch_id: targetBranch.branch_id,
+          },
+          targetBranch.dbPtr
+        );
+
+        if (!switchResult?.success) {
+          Modal.error({
+            title: 'Branch Switch Failed',
+            content: switchResult?.message || 'An error occurred while attempting to switch branches.',
+          });
+          return;
+        }
+
+        persistBranchSession(switchResult?.token, targetBranch.dbPtr);
+        window.dispatchEvent(new CustomEvent('branchChanged', { detail: targetBranch.dbPtr }));
+
+        const accessToken = switchResult?.token?.access_token;
+        const profileResult = await MenusAPI.getProfile(accessToken);
+        const updatedUser = { ...profileResult, loggedCheckDone: true };
+
+        dispatch({ type: 'user', payload: updatedUser });
+        localStorage.setItem('userInfo', JSON.stringify(updatedUser));
+
+        await initializeUserMenus();
+      } catch (error) {
+        console.error('Auto branch switch failed:', error);
+      } finally {
+        setLoader(false);
+      }
+    };
+
+    if (user?.id && history?.location) handleUrlBranchSwitch();
+  }, [history?.location?.search, user?.id]);
+
   useEffect(() => {
     // Initialize the menus for the logged in user
     initializeUserMenus();
@@ -183,7 +293,7 @@ export default function LandingApi({ history, CustomComponents, CustomModels, ap
     setLoader(true);
 
     // setReports(report)
-
+    fetchSummary();
     const result = await MenusAPI.getMenus(user);
 
     // console.log(result);

package/core/lib/components/index.js

@@ -109,7 +109,7 @@ import ConsentComponent from './consent/consent'
 import TaskOverviewLegacy from './../models/process/components/task-overview-legacy/task-overview-legacy'
 
 import ReportingDashboard from '../../modules/reporting/components/reporting-dashboard/reporting-dashboard';
-
+import ReportingTable from '../../modules/reporting/components/reporting-dashboard/reporting-table'
 import ProcessStepsPage from '../../modules/steps/steps'
 export {
 
@@ -198,7 +198,7 @@ export {
   TaskOverviewLegacy,
   // WebCamera,
   ConsentComponent,
-
+ReportingTable,
   ReportingDashboard,
   ProcessStepsPage
 

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: {
@@ -116,6 +115,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,
+    });
+  };
   /**
    *
    */

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,

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,153 @@ 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({
+          content: 'This data is another branch. Switch to that branch to view details?',
+          onOk: () => {
+            if (hasTargetBranchAccess) {
+              Location.navigate({ url: redirectLink });
+              return;
+            }
+
+            Modal.error({
+              title: 'Branch Switch Failed',
+              content: "You don't have permission to view this branch's details.",
+            });
+          },
+        });
+      }}
+    >
+      {label}
+    </a>
+  );
+}
 /**
  * Renders table cell content for a configured display column.
  *
@@ -210,10 +395,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' },