@argusoft/medplat-app-shell 1.0.6 → 1.0.8

package/src/hooks/useRefreshToken.js

@@ -0,0 +1,87 @@
+import { useState, useCallback, useRef } from 'react';
+import { useDispatch } from 'react-redux';
+import { setLoggedIn, setToken } from '@/store/reducers/AuthenticationReducer';
+import { refreshAccessToken } from '@/common/services/AuthenticateService';
+import { navigate } from '@/common/services/InterceptorNavigationService';
+import { clearAllExceptPinned } from '@/utils/localStorageHelper';
+
+const useRefreshToken = (initialToken) => {
+  const [accessToken] = useState(initialToken);
+  const dispatch = useDispatch();
+  const refreshPromiseRef = useRef(null);
+
+  const executeActualRefresh = useCallback(async (token) => {
+    // 1. If a refresh is already in progress, return the existing promise
+    if (refreshPromiseRef.current) {
+      return refreshPromiseRef.current;
+    }
+
+    // 2. Check if the token has already been refreshed by someone else
+    const tokenString = localStorage.getItem('token');
+    const storedToken = tokenString ? JSON.parse(tokenString) : null;
+    if (storedToken && token && storedToken.access_token !== token.access_token) {
+      // Token was already refreshed, no need to do it again
+      return storedToken;
+    }
+
+    // 3. Start the refresh process and store the promise
+    refreshPromiseRef.current = (async () => {
+      try {
+        const response = await refreshAccessToken(token);
+
+        if (response) {
+          const loginTime = new Date();
+          localStorage.setItem('loginTime', JSON.stringify(loginTime));
+          dispatch(setToken(response));
+          dispatch(setLoggedIn());
+          return response;
+        }
+        return null;
+      } catch (error) {
+        console.error('DEBUG: executeActualRefresh - ERROR', error);
+        clearAllExceptPinned();
+        const isTecho = sessionStorage.getItem('isTecho');
+        if (isTecho === null || isTecho === undefined || isTecho === 'true') {
+          sessionStorage.clear();
+          navigate('/ui/login');
+        } else {
+          sessionStorage.clear();
+          navigate('/ui/medplat/manage/members/verify-otp');
+        }
+        throw error;
+      } finally {
+        // Clear the promise ref when done
+        refreshPromiseRef.current = null;
+      }
+    })();
+
+    return refreshPromiseRef.current;
+  }, [dispatch]);
+
+  const manualRefresh = useCallback(async (token) => {
+    if (!token || !token.access_token) return;
+
+    const loginTimeString = localStorage.getItem('loginTime');
+    const loginTime = loginTimeString ? new Date(JSON.parse(loginTimeString)) : new Date();
+    const currentTime = new Date();
+    const timeDifferenceMillis = currentTime - loginTime;
+
+    const expiresIn = token.expires_in || 900;
+
+    if (timeDifferenceMillis > (expiresIn - 1) * 1000) {
+      await executeActualRefresh(token);
+    } else {
+      dispatch(setLoggedIn());
+    }
+  }, [executeActualRefresh, dispatch]);
+
+  const refreshToken = useCallback(async (token) => {
+    await executeActualRefresh(token);
+  }, [executeActualRefresh]);
+
+  const newToken = refreshToken;
+
+  return { accessToken, manualRefresh, refreshToken, newToken };
+};
+
+export default useRefreshToken;

package/src/hooks/useScript.js

@@ -0,0 +1,25 @@
+import { useEffect } from "react";
+
+const useScript = (src, id, disabled = false, persist = false) => {
+  useEffect(() => {
+    if (disabled) return;
+    if (document.getElementById(id)) return;
+
+    const script = document.createElement("script");
+    script.src = src;
+    script.async = true;
+    script.id = id;
+
+    document.body.appendChild(script);
+    if (persist) return;
+
+    return () => {
+      const existingScript = document.getElementById(id);
+      if (existingScript) {
+        existingScript.remove();
+      }
+    };
+  }, [src, id, disabled, persist]);
+};
+
+export default useScript;

package/src/hooks/useStopwatch.js

@@ -0,0 +1,75 @@
+import { useState, useRef, useEffect } from 'react';
+
+const useStopwatch = () => {
+    const [elapsedTime, setElapsedTime] = useState(0);
+    const [isRunning, setIsRunning] = useState(false);
+    const timerIntervalRef = useRef(null);
+    const startTimeRef = useRef(null);
+    const accumulatedTimeRef = useRef(0);
+
+    const start = () => {
+        if (isRunning) return;
+
+        setIsRunning(true);
+        startTimeRef.current = Date.now();
+
+        timerIntervalRef.current = setInterval(() => {
+            const now = Date.now();
+            const currentRunTime = now - startTimeRef.current;
+            setElapsedTime(accumulatedTimeRef.current + currentRunTime);
+        }, 100);
+    };
+
+    const stop = () => {
+        if (!isRunning) return;
+
+        if (timerIntervalRef.current) {
+            clearInterval(timerIntervalRef.current);
+            timerIntervalRef.current = null;
+        }
+
+        // Final update to ensure precision
+        const now = Date.now();
+        accumulatedTimeRef.current += (now - startTimeRef.current);
+        setElapsedTime(accumulatedTimeRef.current);
+        setIsRunning(false);
+    };
+
+    const pause = () => {
+        stop();
+    };
+
+    const reset = () => {
+        stop();
+        setElapsedTime(0);
+        accumulatedTimeRef.current = 0;
+    };
+
+    const formatTime = (ms) => {
+        const totalSeconds = Math.floor(ms / 1000);
+        const h = Math.floor(totalSeconds / 3600);
+        const m = Math.floor((totalSeconds % 3600) / 60);
+        const s = totalSeconds % 60;
+        return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
+    };
+
+    useEffect(() => {
+        return () => {
+            if (timerIntervalRef.current) {
+                clearInterval(timerIntervalRef.current);
+            }
+        };
+    }, []);
+
+    return {
+        elapsedTime,
+        isRunning,
+        start,
+        stop,
+        pause,
+        reset,
+        formatTime
+    };
+};
+
+export default useStopwatch;

package/src/hooks/useTrackEvent.js

@@ -0,0 +1,22 @@
+// hooks/useTrackEvent.js
+import GeneralUtil from '@/common/services/util/GeneralUtil';
+import { useTracking } from 'useranalytics';
+
+const useTrackEvent = () => {
+ const { trackEvent } = GeneralUtil.isEkavach ? useTracking() :{trackEvent:()=>{}} ;
+
+  const trackEvent2 = async (event, data) => {
+    // const { trackEvent } = useTracking();
+    if (event === 'button_click') {
+      await trackEvent(event, data);
+    }
+    //
+  };
+  if (GeneralUtil.isEkavach){
+    return trackEvent2;
+  }
+    else{ return ()=>{}
+  } 
+};
+
+export default useTrackEvent;

package/src/hooks/useWebAudioRecorder.js

@@ -0,0 +1,115 @@
+import { useState, useRef } from 'react';
+import { showToast } from '@/common/toaster/toaster';
+
+const useWebAudioRecorder = () => {
+    const [isRecording, setIsRecording] = useState(false);
+    const mediaRecorderRef = useRef(null);
+    const audioChunksRef = useRef([]);
+    const streamRef = useRef(null); // Added streamRef
+
+    const startRecording = async () => {
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            streamRef.current = stream; // Store the stream
+            mediaRecorderRef.current = new MediaRecorder(stream);
+            audioChunksRef.current = [];
+
+            mediaRecorderRef.current.ondataavailable = (event) => {
+                if (event.data.size > 0) {
+                    audioChunksRef.current.push(event.data);
+                }
+            };
+
+            mediaRecorderRef.current.start();
+            setIsRecording(true);
+            return true;
+        } catch (err) {
+            console.error('Web Recording Error:', err);
+            showToast({ type: 'error', message: 'Microphone access denied or error occurred.' });
+            return false;
+        }
+    };
+
+    const stopRecording = () => {
+        return new Promise((resolve, reject) => {
+            // Safety check: if not recording or not initialized
+            if (!mediaRecorderRef.current || mediaRecorderRef.current.state === 'inactive') {
+                // Try to cleanup anyway if stream exists
+                if (streamRef.current) {
+                    streamRef.current.getTracks().forEach(track => track.stop());
+                    streamRef.current = null;
+                }
+                setIsRecording(false);
+                resolve(null);
+                return;
+            }
+
+            mediaRecorderRef.current.onstop = () => {
+                try {
+                    const audioBlob = new Blob(audioChunksRef.current, { type: 'audio/wav' });
+                    const reader = new FileReader();
+                    reader.readAsDataURL(audioBlob);
+
+                    reader.onloadend = () => {
+                        const base64String = reader.result;
+
+                        // Stop all tracks from the stored stream reference
+                        if (streamRef.current) {
+                            streamRef.current.getTracks().forEach(track => track.stop());
+                            streamRef.current = null;
+                        }
+
+                        setIsRecording(false);
+                        resolve({ blob: audioBlob, base64: base64String });
+                    };
+
+                    reader.onerror = (error) => {
+                        console.error("FileReader error", error);
+
+                        // Ensure we cleanup even on error
+                        if (streamRef.current) {
+                            streamRef.current.getTracks().forEach(track => track.stop());
+                            streamRef.current = null;
+                        }
+                        setIsRecording(false);
+                        reject(error);
+                    };
+                } catch (e) {
+                    // Catch potential Blob/Reader errors
+                    reject(e);
+                }
+            };
+
+            try {
+                mediaRecorderRef.current.stop();
+            } catch (e) {
+                console.error("MediaRecorder stop error", e);
+                reject(e);
+            }
+        });
+    };
+
+    const pauseRecording = () => {
+        if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'recording') {
+            mediaRecorderRef.current.pause();
+            setIsRecording(false); // Visually paused
+        }
+    };
+
+    const resumeRecording = () => {
+        if (mediaRecorderRef.current && mediaRecorderRef.current.state === 'paused') {
+            mediaRecorderRef.current.resume();
+            setIsRecording(true);
+        }
+    };
+
+    return {
+        isRecording,
+        startRecording,
+        stopRecording,
+        pauseRecording,
+        resumeRecording
+    };
+};
+
+export default useWebAudioRecorder;

package/src/layout/LoaderComponet.jsx

@@ -0,0 +1,22 @@
+import React from 'react';
+import { useLoader } from '@/layout/LoaderContext';
+
+import MEDplatLoader from '@/assets/img/medplat-loader.gif';
+
+import { useSelector } from 'react-redux';
+import { getUseSkeleton } from '@/store/reducers/SkeletonReducer';
+const LoaderComponent = () => {
+  const { loading } = useLoader();
+  const useSkeleton = useSelector(getUseSkeleton);
+  if (useSkeleton) {
+    return null;
+  }
+  return loading ? (
+    <div className="loader-overlay">
+      {/* <div className="loader-spinner"></div> */}
+      <img src={MEDplatLoader} alt="Loading..." className="loader" />
+    </div>
+  ) : null;
+};
+
+export default LoaderComponent;

package/src/layout/LoaderContext.jsx

@@ -0,0 +1,29 @@
+import React, { createContext, useContext, useState } from 'react';
+import PropTypes from 'prop-types';
+import { startLoading, stopLoading } from '@/store/reducers/LoadingReducer';
+
+const LoaderContext = createContext();
+
+export const LoaderProvider = ({ children }) => {
+  const [loading, setLoading] = useState(false);
+
+  const showLoader = () => {
+    startLoading();
+    setLoading(true);
+  };
+  const hideLoader = () => {
+    stopLoading();
+    setLoading(false);
+  };
+
+  const contextValue = React.useMemo(() => ({ loading, showLoader, hideLoader }), [loading]);
+
+  return <LoaderContext.Provider value={contextValue}>{children}</LoaderContext.Provider>;
+};
+
+export const useLoader = () =>
+  useContext(LoaderContext) || { loading: false, showLoader: () => {}, hideLoader: () => {} };
+
+LoaderProvider.propTypes = {
+  children: PropTypes.any,
+};

package/src/layout/mainLayout/AdaptiveZoom.jsx

@@ -0,0 +1,27 @@
+import { useEffect, useState } from "react";
+
+const useAdaptiveZoom = () => {
+  const [zoom, setZoom] = useState(1);
+
+  const calculateZoom = () => {
+    const width = window.innerWidth;
+
+    if (width <= 1500) {
+      const scale = Math.max(0.88, width / 1520);
+      setZoom(scale);
+    } else {
+      setZoom(1);
+    }
+  };
+
+  useEffect(() => {
+    calculateZoom();
+
+    window.addEventListener("resize", calculateZoom);
+    return () => window.removeEventListener("resize", calculateZoom);
+  }, []);
+
+  return zoom;
+};
+
+export default useAdaptiveZoom;

package/src/layout/mainLayout/Chatbot.jsx

@@ -0,0 +1,243 @@
+import React, { useState } from 'react';
+import { Fab, Tooltip } from '@mui/material';
+import ChatIcon from '@mui/icons-material/Chat';
+
+const Chatbot = () => {
+  const [isLoaded, setIsLoaded] = useState(false);
+
+  const loadChatbot = () => {
+    if (isLoaded || window.__ANYTHINGLLM_EMBED_LOADED__) return;
+    window.__ANYTHINGLLM_EMBED_LOADED__ = true;
+
+    /* Load AnythingLLM Script */
+    const script = document.createElement("script");
+    script.src = "https://aiservices.duckdns.org/embed/anythingllm-chat-widget.min.js";
+    script.async = true;
+
+    /* Required Core Params */
+    script.setAttribute("data-embed-id", "f8adc5e8-9143-4b9b-8e29-07db2fbf80d7");
+    script.setAttribute("data-base-api-url", "https://aiservices.duckdns.org/api/embed");
+
+    /* Position & Behavior */
+    script.setAttribute("data-position", "bottom-right");
+    script.setAttribute("data-open-on-load", "on");
+    script.setAttribute("data-chat-icon", "support");
+
+    /* Identity */
+    script.setAttribute("data-assistant-name", "AI Assistant");
+    script.setAttribute(
+      "data-assistant-icon",
+      "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcS7tJKQ1KOQvWJQdx57kzZjdtTlkBvzSOXs2A&s"
+    );
+    script.setAttribute(
+      "data-brand-image-url",
+      "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcS7tJKQ1KOQvWJQdx57kzZjdtTlkBvzSOXs2A&s"
+    );
+
+    /* Text */
+    script.setAttribute("data-greeting", "👋 Hi! How can I help you today?");
+    script.setAttribute("data-send-message-text", "Type your message…");
+    script.setAttribute("data-reset-chat-text", "New / Reset chat");
+
+    /* Disclaimer */
+    script.setAttribute(
+      "data-sponsor-text",
+      "This is an AI chatbot. Responses may vary based on available data. Though all efforts have been made to ensure the accuracy and currency of the content on this website, the same should not be construed as a statement of law or used for any legal purposes. Kindly contact office in case of any discrepancy and/or clarification."
+    );
+    script.setAttribute("data-sponsor-link", "#");
+
+    /* Styling */
+    script.setAttribute("data-button-color", "#2563EB");
+    script.setAttribute("data-user-bg-color", "#2563EB");
+    script.setAttribute("data-assistant-bg-color", "#F1F5F9");
+
+    /* Size */
+    script.setAttribute("data-window-width", "440px");
+    script.setAttribute("data-window-height", "580px");
+    script.setAttribute("data-text-size", "15px");
+
+    document.body.appendChild(script);
+
+    /* Custom Styles */
+    const style = document.createElement("style");
+    style.id = "anythingllm-custom-style";
+    style.textContent = `
+            /* Always on top */
+            #anythingllm-chat-widget,
+            #anythingllm-chat-widget-launcher {
+                z-index: 2147483647 !important;
+            }
+            #anything-llm-embed-chat-container {
+                z-index: 2147483647;
+            }
+            #anythingllm-chat-widget {
+                background: #ffffff !important;
+                color: #0f172a !important;
+                border-radius: 16px !important;
+                box-shadow: 0 18px 40px rgba(0,0,0,0.18) !important;
+                font-family: Inter, Segoe UI, system-ui, sans-serif !important;
+            }
+
+            #anythingllm-chat-widget .chat-header {
+                background: linear-gradient(135deg, #2563eb, #1d4ed8) !important;
+                color: #ffffff !important;
+                position: relative !important;
+            }
+
+            /* Header controls */
+            .anythingllm-window-controls {
+                position: absolute;
+                right: 14px;
+                top: 50%;
+                transform: translateY(-50%);
+                display: flex;
+                gap: 8px;
+            }
+
+            .anythingllm-window-controls button {
+                background: rgba(255,255,255,0.2);
+                border: none;
+                color: #ffffff;
+                width: 26px;
+                height: 26px;
+                border-radius: 6px;
+                cursor: pointer;
+                font-size: 13px;
+                line-height: 1;
+            }
+
+            .anythingllm-window-controls button:hover {
+                background: rgba(255,255,255,0.3);
+            }
+
+            /* Maximized state */
+            #anythingllm-chat-widget.anythingllm-maximized {
+                top: 0 !important;
+                left: 0 !important;
+                right: 0 !important;
+                bottom: 0 !important;
+                width: 100% !important;
+                height: 100% !important;
+                border-radius: 0 !important;
+            }
+
+            #anythingllm-chat-widget .chat-body {
+                background: #f8fafc !important;
+            }
+
+            #anythingllm-chat-widget .chat-message.assistant {
+                background: #f1f5f9 !important;
+                color: #0f172a !important;
+                border-radius: 14px !important;
+            }
+
+            #anythingllm-chat-widget .chat-message.user {
+                background: linear-gradient(135deg, #2563eb, #1d4ed8) !important;
+                color: #ffffff !important;
+                border-radius: 14px !important;
+                margin-left: auto !important;
+            }
+
+            #anythingllm-chat-widget .branding,
+            #anythingllm-chat-widget .powered-by {
+                display: none !important;
+            }
+
+            .allm-text-xs {
+                margin: 0 5px !important;
+                display: inline-block !important;
+            }
+
+            #anythingllm-chat-widget .chat-footer::after {
+                content: "Secure • Private • AI Assistant";
+                font-size: 12px;
+                color: #64748b;
+                display: block;
+                text-align: center;
+                margin-top: 6px;
+            }
+
+            @media (max-width: 480px) {
+                #anythingllm-chat-widget {
+                    width: 100% !important;
+                    height: 100% !important;
+                    border-radius: 0 !important;
+                    left: 0 !important;
+                    bottom: 0 !important;
+                }
+            }
+        `;
+    document.head.appendChild(style);
+
+    /* Inject Maximize / Minimize Controls */
+    function injectControls() {
+      const widget = document.getElementById("anythingllm-chat-widget");
+      if (!widget) return false;
+
+      const header = widget.querySelector(".chat-header");
+      if (!header || header.querySelector(".anythingllm-window-controls")) {
+        return true;
+      }
+
+      const controls = document.createElement("div");
+      controls.className = "anythingllm-window-controls";
+
+      const maximizeBtn = document.createElement("button");
+      maximizeBtn.innerHTML = "⛶";
+      maximizeBtn.title = "Maximize";
+
+      const minimizeBtn = document.createElement("button");
+      minimizeBtn.innerHTML = "🗗";
+      minimizeBtn.title = "Restore";
+
+      maximizeBtn.onclick = () => {
+        widget.classList.add("anythingllm-maximized");
+      };
+
+      minimizeBtn.onclick = () => {
+        widget.classList.remove("anythingllm-maximized");
+      };
+
+      controls.appendChild(maximizeBtn);
+      controls.appendChild(minimizeBtn);
+      header.appendChild(controls);
+
+      return true;
+    }
+
+    const controlInterval = setInterval(() => {
+      if (injectControls()) {
+        clearInterval(controlInterval);
+      }
+    }, 300);
+
+    setIsLoaded(true);
+  };
+
+  if (isLoaded) return null; // Hide our icon once loaded, the widget has its own.
+
+  return (
+    <Tooltip title="TeCHO AI Assistant" placement="left">
+      <Fab
+        color="primary"
+        aria-label="chat"
+        onClick={loadChatbot}
+        sx={{
+          position: 'fixed',
+          bottom: 100,
+          right: 20,
+          zIndex: 1000,
+          boxShadow: '0 4px 12px rgba(0,0,0,0.15)',
+          transition: 'transform 0.2s',
+          '&:hover': {
+            transform: 'scale(1.1)',
+          }
+        }}
+      >
+        <ChatIcon />
+      </Fab>
+    </Tooltip>
+  );
+};
+
+export default Chatbot;