ui-soxo-bootstrap-core 2.6.37 → 2.6.40-dev.0

package/core/models/users/components/assign-role/assign-role.js

@@ -160,7 +160,7 @@ export default function AssignRole() {
     const role_id = role.id;
     try {
       const res = await MenusAPI.getCoreMenuByRoleId(role_id);
-      const allMenus = res.result || [];
+      const allMenus = Array.isArray(res?.result) ? res.result : [];
 
       setModules(allMenus);
     } catch (e) {
@@ -264,11 +264,12 @@ export default function AssignRole() {
   const handleViewAll = async () => {
     setLoadingMenus(true);
     setModules([]);
-    setActiveRole({ name: 'All Roles' });
+    setActiveRole({ name: 'All Roles', isViewAll: true });
 
     try {
       const res = await MenusAPI.getMenubyUser(id);
-      setModules(res?.result?.menus ?? []);
+      const userMenus = Array.isArray(res?.result?.menus) ? res.result.menus : [];
+      setModules(userMenus);
       setLoadingMenus(false);
     } catch (err) {
       setLoadingMenus(false);
@@ -277,6 +278,18 @@ export default function AssignRole() {
     }
   };
 
+  /**
+   * Context-specific empty-state message for the right (menus) panel:
+   * - View Access for a user with no roles → no role assigned
+   * - A selected role with no menus → no menus assigned
+   * - Nothing selected yet → prompt to pick a role
+   */
+  const emptyMenusMessage = !activeRole
+    ? 'Select a role to view menus'
+    : activeRole.isViewAll
+    ? 'No role has been assigned to this user.'
+    : 'No menus have been assigned to this role.';
+
   return (
     <section className="assign-role">
       {/* LEFT PANEL */}
@@ -383,17 +396,19 @@ export default function AssignRole() {
           padding: 16,
         }}
       >
-        <div className="menus-header">
-          <div className="title">Menus {activeRole ? `– ${activeRole.name}` : ''}</div>
-          <div className="sub-text">You don’t have permission to edit this here. Update it in Role Settings.</div>
-        </div>
+        {modules.length > 0 && (
+          <div className="menus-header">
+            <div className="title">Menus {activeRole ? `– ${activeRole.name}` : ''}</div>
+            <div className="sub-text">You don’t have permission to edit this here. Update it in Role Settings.</div>
+          </div>
+        )}
 
         <div className="menus-content">
           {loadingMenus ? (
             <Skeleton active paragraph={{ rows: 6 }} />
           ) : modules.length === 0 ? (
             <div className="empty-state">
-              <Empty description="Select a role to view menus" />
+              <Empty description={emptyMenusMessage} />
             </div>
           ) : (
             <MenuTree menus={modules} selectedMenus={selectedMenus} toggleMenu={toggleMenu} showCheckbox={false} />

package/core/modules/steps/narration.js

@@ -0,0 +1,192 @@
+/**
+ * Narration helpers for ProcessStepsPage.
+ *
+ * Owns the per-step "guest guide" copy plus the credential lookup, audio
+ * decoding, and seed-based content picking used by the TTS providers. The
+ * step component imports from here so that file can stay focused on
+ * component lifecycle and layout.
+ */
+
+const STEP_WELCOME_LINES = [
+  'Welcome to your AI Automated Consultation process.',
+  'You are in the right place for a smooth and guided health journey.',
+  'This experience is designed to keep your consultation easy and stress-free.',
+];
+
+const STEP_INTRO_LINES = [
+  'In this process, we will walk you through a seamless and friendly AI interaction experience.',
+  'Each step is simple, guided, and focused on helping you feel prepared.',
+  'We will guide you through each stage so you always know what happens next.',
+];
+
+const STEP_EXPECTATION_LINES = [
+  'A care specialist may ask quick clarification questions to ensure your details are accurate.',
+  'This step focuses on collecting clear inputs so the care team can support you faster.',
+  'You can expect a guided workflow with minimal waiting and clear instructions.',
+  'The goal in this step is to keep your consultation organized and easy to follow.',
+];
+
+const STEP_COMFORT_LINES = [
+  'Take your time. There is no rush and assistance is always available nearby.',
+  'If anything feels unclear, the next prompt will guide you before you continue.',
+  'You can pause and review information before moving to the next stage.',
+  'Your responses here help personalize the rest of your consultation flow.',
+];
+
+const STEP_TIP_LINES = [
+  'Tip: Keep your previous reports or test details ready for quicker progress.',
+  'Tip: Follow on-screen prompts one at a time for the smoothest experience.',
+  'Tip: If you are unsure about a question, answer what you know and continue.',
+  'Tip: Stay relaxed; this process is built to be simple and patient-friendly.',
+];
+
+function getFromStorage(storageKey) {
+  if (typeof window === 'undefined' || !window.localStorage) {
+    return null;
+  }
+
+  try {
+    return window.localStorage.getItem(storageKey);
+  } catch (error) {
+    return null;
+  }
+}
+
+export function getElevenLabsApiKey() {
+  return (
+    process.env.ELEVEN_LABS_KEY ||
+    process.env.ELEVENLABS_API_KEY ||
+    process.env.REACT_APP_ELEVEN_LABS_KEY ||
+    process.env.REACT_APP_ELEVENLABS_API_KEY ||
+    getFromStorage('eleven_labs_key') ||
+    getFromStorage('elevenlabs_api_key') ||
+    getFromStorage('ELEVEN_LABS_KEY') ||
+    getFromStorage('REACT_APP_ELEVEN_LABS_KEY') ||
+    getFromStorage('REACT_APP_ELEVENLABS_API_KEY')
+  );
+}
+
+export function getGeminiApiKey() {
+  return (
+    process.env.GEMINI_API_KEY ||
+    process.env.REACT_APP_GEMINI_API_KEY ||
+    getFromStorage('gemini_api_key') ||
+    getFromStorage('GEMINI_API_KEY') ||
+    getFromStorage('REACT_APP_GEMINI_API_KEY')
+  );
+}
+
+export function getOpenAIApiKey() {
+  return (
+    process.env.OPEN_AI_KEY ||
+    process.env.OPENAI_API_KEY ||
+    process.env.REACT_APP_OPEN_AI_KEY ||
+    process.env.REACT_APP_OPENAI_API_KEY ||
+    getFromStorage('open_ai_key') ||
+    getFromStorage('openai_api_key') ||
+    getFromStorage('OPEN_AI_KEY') ||
+    getFromStorage('OPENAI_API_KEY') ||
+    getFromStorage('REACT_APP_OPEN_AI_KEY') ||
+    getFromStorage('REACT_APP_OPENAI_API_KEY')
+  );
+}
+
+export function getSarvamApiKey() {
+  return (
+    process.env.SARVAM_API_KEY ||
+    process.env.REACT_APP_SARVAM_API_KEY ||
+    getFromStorage('sarvam_api_key') ||
+    getFromStorage('REACT_APP_SARVAM_API_KEY')
+  );
+}
+
+export function base64AudioToBlob(base64Audio = '', mimeType = 'audio/wav') {
+  const cleanedBase64 = base64Audio.includes(',') ? base64Audio.split(',').pop() : base64Audio;
+  const binaryString = typeof window !== 'undefined' && window.atob ? window.atob(cleanedBase64) : atob(cleanedBase64);
+  const bytes = new Uint8Array(binaryString.length);
+
+  for (let index = 0; index < binaryString.length; index += 1) {
+    bytes[index] = binaryString.charCodeAt(index);
+  }
+
+  return new Blob([bytes], { type: mimeType });
+}
+
+export function extractGeminiAudio(payload) {
+  const candidates = payload && payload.candidates ? payload.candidates : [];
+
+  for (const candidate of candidates) {
+    const parts = candidate && candidate.content && candidate.content.parts ? candidate.content.parts : [];
+
+    for (const part of parts) {
+      const inlineData = part.inlineData || part.inline_data || part.audio;
+
+      if (inlineData && inlineData.data) {
+        return {
+          mimeType: inlineData.mimeType || inlineData.mime_type || 'audio/wav',
+          data: inlineData.data,
+        };
+      }
+    }
+  }
+
+  return null;
+}
+
+function hashText(value = '') {
+  let hash = 0;
+
+  for (let index = 0; index < value.length; index += 1) {
+    hash = (hash << 5) - hash + value.charCodeAt(index);
+    hash |= 0;
+  }
+
+  return Math.abs(hash);
+}
+
+function pickBySeed(items = [], seed = 0) {
+  if (!items.length) {
+    return '';
+  }
+
+  return items[seed % items.length];
+}
+
+export function buildGuestStepGuide(step, index, total) {
+  if (!step) {
+    return {
+      welcome: STEP_WELCOME_LINES[0],
+      intro: STEP_INTRO_LINES[0],
+      expectation: 'We are preparing your consultation journey.',
+      comfort: STEP_COMFORT_LINES[0],
+      tip: STEP_TIP_LINES[0],
+      narration: '',
+    };
+  }
+
+  const stepName = step.step_name || `Step ${index + 1}`;
+  const seedSource = `${step.step_id || step.id || index}-${stepName}`;
+  const seed = hashText(seedSource);
+
+  const welcome = index === 0 ? STEP_WELCOME_LINES[0] : `Now entering ${stepName}.`;
+  const intro = index === 0 ? STEP_INTRO_LINES[0] : pickBySeed(STEP_INTRO_LINES, seed + 1);
+  const expectation = step.step_description || pickBySeed(STEP_EXPECTATION_LINES, seed + 2);
+  const comfort = pickBySeed(STEP_COMFORT_LINES, seed + 3);
+  const tip = pickBySeed(STEP_TIP_LINES, seed + 4);
+
+  return {
+    welcome,
+    intro,
+    expectation,
+    comfort,
+    tip,
+    narration: [
+      `Step ${index + 1} of ${total}. ${stepName}.`,
+      welcome,
+      intro,
+      `What to expect: ${expectation}`,
+      `Comfort note: ${comfort}`,
+      `Helpful tip: ${tip}`,
+    ].join(' '),
+  };
+}

package/core/modules/steps/progress-storage.js

@@ -0,0 +1,140 @@
+/**
+ * Per-guest progress persistence helpers for ProcessStepsPage.
+ *
+ * Storage shape:
+ *   key   = `processTimings_<processId>_<guestRef>` or
+ *           `processActiveStep_<processId>_<guestRef>`
+ *   value = `{ savedAt: <ms>, value: { guestRef, ... } }`
+ *
+ * The key scopes by guest AND the inner value carries the guest reference,
+ * so reads can reject any entry that does not belong to the current guest —
+ * guest A's progress can never be applied to guest B even if a key collision
+ * somehow occurred.
+ *
+ * The TTL covers a working shift: a guest who walks away in the morning is
+ * not coming back the same evening to resume. The sweep on mount drops any
+ * entry past the TTL or stored in the legacy unwrapped shape.
+ */
+
+export const PROGRESS_STORAGE_TTL_MS = 12 * 60 * 60 * 1000;
+export const PROGRESS_STORAGE_PREFIXES = ['processTimings_', 'processActiveStep_'];
+
+function hasLocalStorage() {
+  return typeof window !== 'undefined' && !!window.localStorage;
+}
+
+/**
+ * Drop progress keys that are past their TTL or stored in the legacy shape
+ * (which has no `savedAt` and therefore an unknowable age). Safe to call
+ * during mount and again after a quota error to free room for a retry.
+ */
+export function sweepStaleProgressKeys() {
+  if (!hasLocalStorage()) {
+    return;
+  }
+
+  try {
+    const cutoff = Date.now() - PROGRESS_STORAGE_TTL_MS;
+    const toRemove = [];
+
+    for (let index = 0; index < window.localStorage.length; index += 1) {
+      const key = window.localStorage.key(index);
+      if (!key) {
+        continue;
+      }
+      if (!PROGRESS_STORAGE_PREFIXES.some((prefix) => key.startsWith(prefix))) {
+        continue;
+      }
+
+      try {
+        const raw = window.localStorage.getItem(key);
+        if (!raw) {
+          continue;
+        }
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || typeof parsed.savedAt !== 'number' || parsed.savedAt < cutoff) {
+          toRemove.push(key);
+        }
+      } catch (parseError) {
+        toRemove.push(key);
+      }
+    }
+
+    toRemove.forEach((key) => window.localStorage.removeItem(key));
+  } catch (error) {
+    console.warn('Unable to sweep stale progress keys from local storage.', error);
+  }
+}
+
+/**
+ * Read a stored progress entry. Returns the unwrapped inner `value` only
+ * when the entry is present, well-formed, and within TTL; otherwise returns
+ * `null` and removes the bad key as a side effect.
+ *
+ * Callers must additionally verify `value.guestRef === currentGuestRef`
+ * before applying the result — the helper does not know the current guest.
+ */
+export function readProgressEntry(key) {
+  if (!hasLocalStorage()) {
+    return null;
+  }
+
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) {
+      return null;
+    }
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || typeof parsed.savedAt !== 'number') {
+      window.localStorage.removeItem(key);
+      return null;
+    }
+    if (Date.now() - parsed.savedAt > PROGRESS_STORAGE_TTL_MS) {
+      window.localStorage.removeItem(key);
+      return null;
+    }
+    return parsed.value;
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Write a stored progress entry with the current timestamp. On
+ * `QuotaExceededError`, sweep stale keys once and retry — that keeps the
+ * write path resilient on long-running kiosks without surfacing the error
+ * to the user.
+ */
+export function writeProgressEntry(key, value) {
+  if (!hasLocalStorage()) {
+    return;
+  }
+
+  const payload = JSON.stringify({ savedAt: Date.now(), value });
+
+  try {
+    window.localStorage.setItem(key, payload);
+  } catch (error) {
+    sweepStaleProgressKeys();
+    try {
+      window.localStorage.setItem(key, payload);
+    } catch (retryError) {
+      console.warn('Unable to persist progress to local storage.', retryError);
+    }
+  }
+}
+
+/**
+ * Remove a progress entry. Safe to call when the entry does not exist.
+ */
+export function clearProgressEntry(key) {
+  if (!hasLocalStorage()) {
+    return;
+  }
+
+  try {
+    window.localStorage.removeItem(key);
+  } catch (error) {
+    console.warn('Unable to clear progress entry from local storage.', error);
+  }
+}