@dashadmin/dash-admin 1.3.24 → 1.3.26

package/src/contexts/auth/WindowContext.tsx

@@ -0,0 +1,15 @@
+import React from 'react';
+
+export type IWindowContext = {
+	isMobile: boolean;
+	width: number;
+	height: number;
+	mq: string;
+};
+
+export const WindowContext = React.createContext<IWindowContext>({
+	isMobile: false,
+	width: 0,
+	height: 0,
+	mq: 'all',
+});

package/src/contexts/auth/index.tsx

@@ -0,0 +1,3 @@
+//export * from './AuthProvider'
+export * from './AuthContext';
+export * from './WindowContext';

package/src/contexts/com/FCMContext.tsx

@@ -0,0 +1,415 @@
+//import { Capacitor } from '@capacitor/core';
+import React, { FC, useEffect, useMemo, useRef } from 'react';
+import {createAxiosInstance} from 'dash-axios-hook'
+import { useSelector } from 'react-redux';
+import { IDASHAppState } from 'dash-admin-state';
+import { IDashAutoAdminResourceConfig } from 'dash-auto-admin';
+import  { getEnv } from 'dash-constants/src/DASHAdminSystemConstants';
+
+
+
+
+export type IFCMContext = {
+  notifications: any[];
+  lastNotification: any;
+  clear: () => void;
+  initializePushNotifications: () => Promise<void>;
+  permissionStatus: 'unknown' | 'granted' | 'denied' | 'not_supported';
+  isSupported: boolean;
+  platform: string;
+};
+
+export interface IFCMProvider {
+  children: React.ReactNode;
+  manager?: () => {
+    notifications: any[];
+    lastNotification: any;
+    clear: () => void;
+    initializePushNotifications: () => Promise<void>;
+    permissionStatus: 'unknown' | 'granted' | 'denied' | 'not_supported';
+    isSupported: boolean;
+    platform: string;
+  };
+}
+
+// Helper functions similar to voiceAgent approach
+const isPushNotificationsAvailable = (): boolean => {
+    return !!(window as any)?.Capacitor?.Plugins?.PushNotifications;
+};
+
+const getPushNotifications = () => {
+    return (window as any)?.Capacitor?.Plugins?.PushNotifications;
+};
+
+const getCapacitor = () => {
+    return (window as any)?.Capacitor;
+};
+
+export class FCMService {
+  private notifications: any[] = [];
+  private lastNotification: any = null;
+  private axiosInstance = createAxiosInstance();
+  private permissionStatus: 'unknown' | 'granted' | 'denied' | 'not_supported' = 'unknown';
+
+  constructor() {
+    // Initialize permission status based on platform support
+    if (!this.isSupported()) {
+      this.permissionStatus = 'not_supported';
+    }
+  }
+
+  isSupported(): boolean {
+    const capacitor = getCapacitor();
+    const hasPlugin = isPushNotificationsAvailable();
+    const isNativePlatform = capacitor?.isNativePlatform?.() || false;
+    
+    console.log('🔍 FCM Support check:', {
+      hasCapacitor: !!capacitor,
+      hasPlugin,
+      isNativePlatform,
+      platform: capacitor?.getPlatform?.() || 'web'
+    });
+
+    return hasPlugin && isNativePlatform;
+  }
+
+  getPlatform(): string {
+    const capacitor = getCapacitor();
+    return capacitor?.getPlatform?.() || 'web';
+  }
+
+  async checkPermissions(): Promise<boolean> {
+    if (!this.isSupported()) {
+      console.log('📱 Push notifications not supported on this platform');
+      this.permissionStatus = 'not_supported';
+      return false;
+    }
+
+    try {
+      const PushNotifications = getPushNotifications();
+      console.log('🔍 Checking push notification permissions...');
+
+      const permStatus = await PushNotifications.checkPermissions();
+      console.log('🔐 Permission status:', permStatus);
+
+      if (permStatus.receive === 'granted') {
+        this.permissionStatus = 'granted';
+        return true;
+      } else if (permStatus.receive === 'denied') {
+        this.permissionStatus = 'denied';
+        return false;
+      } else {
+        this.permissionStatus = 'unknown';
+        return false;
+      }
+    } catch (error: any) {
+      console.error('❌ Error checking permissions:', error);
+      this.permissionStatus = 'denied';
+      return false;
+    }
+  }
+
+  async requestPermissions(): Promise<boolean> {
+    if (!this.isSupported()) {
+      console.log('📱 Push notifications not supported, skipping permission request');
+      return false;
+    }
+
+    try {
+      const PushNotifications = getPushNotifications();
+      console.log('🔐 Requesting push notification permissions...');
+
+      const permStatus = await PushNotifications.requestPermissions();
+      console.log('🔐 Permission request result:', permStatus);
+
+      if (permStatus.receive === 'granted') {
+        this.permissionStatus = 'granted';
+        console.log('✅ Push notification permissions granted');
+        return true;
+      } else {
+        this.permissionStatus = 'denied';
+        console.log('❌ Push notification permissions denied');
+        return false;
+      }
+    } catch (error: any) {
+      console.error('❌ Error requesting permissions:', error);
+      this.permissionStatus = 'denied';
+      return false;
+    }
+  }
+
+  async initializePushNotifications(): Promise<void> {
+    console.log('🚀 Initializing push notifications...');
+
+    if (!this.isSupported()) {
+      console.log('📱 Push notifications not supported on this platform, skipping initialization');
+      return;
+    }
+
+    try {
+      // Check current permissions
+      const hasPermission = await this.checkPermissions();
+      
+      if (!hasPermission) {
+        // Request permissions if not granted
+        const granted = await this.requestPermissions();
+        if (!granted) {
+          console.log('❌ Cannot initialize push notifications without permissions');
+          return;
+        }
+      }
+
+      // Register for notifications
+      await this.registerNotifications();
+      
+      // Add listeners
+      await this.addListeners();
+      
+      console.log('✅ Push notifications initialized successfully');
+    } catch (error: any) {
+      console.error('❌ Failed to initialize push notifications:', error);
+      throw error;
+    }
+  }
+
+  private async registerNotifications(): Promise<void> {
+    if (!this.isSupported()) {
+      throw new Error('Push notifications not supported on this platform');
+    }
+
+    try {
+      const PushNotifications = getPushNotifications();
+      console.log('📝 Registering for push notifications...');
+      
+      await PushNotifications.register();
+      console.log('✅ Successfully registered for push notifications');
+    } catch (error: any) {
+      console.error('❌ Error registering for push notifications:', error);
+      throw new Error(`Registration failed: ${error.message}`);
+    }
+  }
+
+  private async addListeners(): Promise<void> {
+    if (!this.isSupported()) {
+      return;
+    }
+
+    try {
+      const PushNotifications = getPushNotifications();
+      console.log('👂 Adding push notification listeners...');
+
+      // Registration token listener
+      await PushNotifications.addListener('registration', (token: any) => {
+        console.log('📝 Registration token received:', token.value);
+        this.sendTokenToBackend(token.value);
+      });
+
+      // Registration error listener
+      await PushNotifications.addListener('registrationError', (err: any) => {
+        console.error('❌ Registration error:', err.error);
+      });
+
+      // Notification received listener
+      await PushNotifications.addListener('pushNotificationReceived', (notification: any) => {
+        console.log('📨 Push notification received:', notification);
+        this.notifications.push(notification);
+        this.lastNotification = notification;
+      });
+
+      // Notification action performed listener
+      await PushNotifications.addListener('pushNotificationActionPerformed', (notification: any) => {
+        console.log('👆 Push notification action performed:', notification.actionId, notification.inputValue);
+        // This package is app-agnostic and has no router context, so it cannot navigate
+        // itself - it dispatches the raw payload for an app-level listener to act on.
+        window.dispatchEvent(new CustomEvent('fcm-notification-tapped', { detail: notification }));
+      });
+
+      console.log('✅ Push notification listeners added successfully');
+    } catch (error: any) {
+      console.error('❌ Error adding listeners:', error);
+      throw new Error(`Failed to add listeners: ${error.message}`);
+    }
+  }
+
+  private async sendTokenToBackend(token: string): Promise<void> {
+    try {
+      console.log('📤 Sending FCM token to backend...');
+      await this.axiosInstance.post('/system/fcm/token', { fcm_token: token });
+      console.log('✅ FCM token sent to backend successfully');
+    } catch (error: any) {
+      console.error('❌ Error sending token to backend:', error);
+    }
+  }
+
+  clear(): void {
+    console.log('🧹 Clearing notifications...');
+    this.notifications = [];
+    this.lastNotification = null;
+  }
+
+  cleanup(): void {
+    console.log('🧹 Cleaning up FCM service...');
+    this.clear();
+    // Note: Capacitor doesn't provide a way to remove listeners easily
+    // They are automatically cleaned up when the app is destroyed
+  }
+
+  getState() {
+    return {
+      notifications: this.notifications,
+      lastNotification: this.lastNotification,
+      clear: this.clear.bind(this),
+      initializePushNotifications: this.initializePushNotifications.bind(this),
+      permissionStatus: this.permissionStatus,
+      isSupported: this.isSupported(),
+      platform: this.getPlatform()
+    };
+  }
+
+  // Debug utility similar to voiceAgent
+  getDebugInfo() {
+    const capacitor = getCapacitor();
+    const hasPlugin = isPushNotificationsAvailable();
+
+    return {
+      windowCapacitor: !!capacitor,
+      hasPushNotificationsPlugin: hasPlugin,
+      availablePlugins: capacitor?.Plugins ? Object.keys(capacitor.Plugins) : [],
+      platform: this.getPlatform(),
+      isNativePlatform: capacitor?.isNativePlatform?.() || false,
+      isSupported: this.isSupported(),
+      permissionStatus: this.permissionStatus,
+      notificationsCount: this.notifications.length,
+      hasLastNotification: !!this.lastNotification
+    };
+  }
+}
+
+export const FCMContext = React.createContext<IFCMContext>({
+  notifications: [],
+  lastNotification: null,
+  clear: () => {},
+  initializePushNotifications: async () => {},
+  permissionStatus: 'unknown',
+  isSupported: false,
+  platform: 'web'
+});
+
+const FCMProvider: FC<IFCMProvider> = ({
+  manager,
+  children,
+  ...props
+}) => {
+  const debug = false;
+  const fcmService = useRef(new FCMService()).current;
+  
+  const { 
+    notifications, 
+    lastNotification, 
+    clear, 
+    initializePushNotifications,
+    permissionStatus,
+    isSupported,
+    platform
+  } = manager ? manager() : fcmService.getState();
+  
+  const auth = useSelector((store: IDASHAppState<any, any, IDashAutoAdminResourceConfig>) => store.auth);
+  const prevAuthRef = useRef<boolean>(false);
+   
+  const envVars = useMemo(() => ({
+    APP_VERSION: getEnv('APP_VERSION') || '1.0.0',
+    BUILD_TIME: getEnv('BUILD_TIME') || new Date().toISOString(),
+    IS_ELECTRON: JSON.parse(getEnv('IS_ELECTRON') || 'false'),
+    PLATFORM: getEnv('PLATFORM') || "unknown",
+    IS_WINDOWS: JSON.parse(getEnv('IS_WINDOWS') || 'false'),
+    IS_MAC: JSON.parse(getEnv('IS_MAC') || 'false'),
+    IS_LINUX: JSON.parse(getEnv('IS_LINUX') || 'false'),
+    PLATFORM_TYPE: getEnv('PLATFORM_TYPE') || "desktop",
+
+    // Mobile/Capacitor platform detection
+    IS_ANDROID: JSON.parse(getEnv('IS_ANDROID') || 'false'),
+    IS_IOS: JSON.parse(getEnv('IS_IOS') || 'false'),
+    IS_CAPACITOR: JSON.parse(getEnv('IS_CAPACITOR') || 'false'),
+    IS_MOBILE: JSON.parse(getEnv('IS_MOBILE') || 'false'),
+    CAPACITOR_PLATFORM: getEnv('CAPACITOR_PLATFORM') || 'web',
+    ANDROID_AVAILABLE: JSON.parse(getEnv('ANDROID_AVAILABLE') || 'false'),
+    IOS_AVAILABLE: JSON.parse(getEnv('IOS_AVAILABLE') || 'false'),
+  }), []);
+
+   const Capacitor = getCapacitor();
+  useEffect(() => {
+    if (auth.authenticated && !prevAuthRef.current) {
+      const capacitorPlatform = Capacitor?.getPlatform?.() || 'web';
+      const isNativePlatform = Capacitor?.isNativePlatform?.() || false;
+      
+      console.log('🔐 User authenticated, checking if should initialize FCM...', {
+        debug,
+        isSupported,
+        platform,
+        capacitorPlatform,
+        isNativePlatform,
+        envVars: {
+          IS_ANDROID: envVars.IS_ANDROID,
+          IS_IOS: envVars.IS_IOS,
+          IS_CAPACITOR: envVars.IS_CAPACITOR,
+          CAPACITOR_PLATFORM: envVars.CAPACITOR_PLATFORM
+        }
+      });
+
+      // Only initialize if supported and on appropriate platforms
+      if (isSupported) {
+        if (debug) {
+          console.log('🐛 Debug mode: initializing FCM');
+          initializePushNotifications().catch(error => {
+            console.error('❌ FCM initialization failed in debug mode:', error);
+          });
+        } else if (isNativePlatform || capacitorPlatform === 'android' || capacitorPlatform === 'ios') {
+          // Use runtime Capacitor detection instead of build-time env vars
+          console.log('📱 Native platform detected: initializing FCM', { capacitorPlatform, isNativePlatform });
+          initializePushNotifications().catch(error => {
+            console.error('❌ FCM initialization failed:', error);
+          });
+        } else {
+          console.log('🌐 Web platform or unsupported: skipping FCM initialization', { capacitorPlatform, isNativePlatform });
+        }
+      } else {
+        console.log('❌ FCM not supported on this platform');
+      }
+    }
+    
+    prevAuthRef.current = auth.authenticated;
+  }, [auth, debug, isSupported, platform, envVars, initializePushNotifications]);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      fcmService.cleanup();
+    };
+  }, [fcmService]);
+
+  const contextValue = useMemo(() => ({
+    notifications,
+    lastNotification,
+    clear,
+    initializePushNotifications,
+    permissionStatus,
+    isSupported,
+    platform
+  }), [
+    notifications,
+    lastNotification,
+    clear,
+    initializePushNotifications,
+    permissionStatus,
+    isSupported,
+    platform
+  ]);
+
+  return (
+    <FCMContext.Provider value={contextValue}>
+      {children}
+    </FCMContext.Provider>
+  );
+};
+
+export { FCMContext as default, FCMProvider };

package/src/contexts/com/LaravelEchoContext.tsx

@@ -0,0 +1,41 @@
+import LaravelEchoMgr from './LaravelEchoMgr';
+import { IDashNotificationPayloadBase } from '../../interfaces/communication/INotification';
+import React, { FC, useEffect } from 'react';
+
+export type ILaravelEchoContext = {
+  events: IDashNotificationPayloadBase[];
+  lastEvent: IDashNotificationPayloadBase;
+  clear: () => void;
+};
+
+export interface ILaravelEchoProvider {
+  children: React.ReactNode;
+  manager?: () => {
+    events: IDashNotificationPayloadBase[];
+    lastEvent: IDashNotificationPayloadBase;
+    clear: () => void;
+  };
+}
+
+export const LaravelEchoContext = React.createContext<ILaravelEchoContext>({
+  events: [],
+  lastEvent: null,
+  clear: null,
+});
+
+const LaravelEchoProvider: FC<ILaravelEchoProvider> = ({
+  manager,
+  children,
+  ...props
+}) => {
+
+  const { events, lastEvent, clear } = manager ? manager() : LaravelEchoMgr();
+
+  return <LaravelEchoContext.Provider
+    value={{ events: events, lastEvent: lastEvent, clear: clear }}
+  >
+    {children}
+  </LaravelEchoContext.Provider>
+};
+
+export { LaravelEchoContext as default, LaravelEchoProvider };

package/src/contexts/com/LaravelEchoMgr.tsx

@@ -0,0 +1,155 @@
+import { useContext, useEffect, useState } from 'react';
+//import { useDispatch } from 'react-redux';
+import { toast } from 'react-toastify';
+// Direct imports to avoid circular barrel imports
+import type { IAuthContext } from '../auth/AuthContext';
+import type { IDashNotificationPayloadBase } from '../../interfaces/communication/INotification';
+import { NotificationComponent } from './components/NotificationRenderer';
+import { AuthContext } from '../auth/AuthContext';
+import { NotificationWrapper } from './components/NotificationsWidget';
+import useLaravelEcho from './useLaravelEcho';
+
+export type ILaravelEchoManager = {
+  events: IDashNotificationPayloadBase[];
+  lastEvent: IDashNotificationPayloadBase;
+  clear: () => void;
+};
+
+const popPrivateMessage = (notification: IDashNotificationPayloadBase) => {
+
+  toast(
+    <NotificationWrapper notification={notification as any} key={0}>
+      {' '}
+      <NotificationComponent notification={notification as any} />{' '}
+    </NotificationWrapper>,
+    {
+      position: 'top-right',
+      autoClose: 8000,
+      hideProgressBar: false,
+      closeOnClick: true,
+      pauseOnHover: true,
+      draggable: true,
+      progress: undefined,
+    },
+  );
+
+};
+
+const popStickyMessage = (notification: IDashNotificationPayloadBase) => {
+  //if (!appearance) appearance = constants.toastAppearances[0];
+  //addToast(<>{message}</>, { appearance, autoDismiss: false });
+  toast(
+    <NotificationWrapper notification={notification as any} key={0}>
+      {' '}
+      <NotificationComponent notification={notification as any} />{' '}
+    </NotificationWrapper>,
+    {
+      position: 'top-right',
+      autoClose: false,
+      hideProgressBar: false,
+      closeOnClick: true,
+      pauseOnHover: true,
+      draggable: true,
+      progress: undefined,
+    },
+  );
+};
+
+const LaravelEchoMgr = (): ILaravelEchoManager => {
+  const [events, setEvents] = useState<IDashNotificationPayloadBase[]>([]);
+  const [lastEvent, setLastEvent] = useState<IDashNotificationPayloadBase>(null);
+  //const dispatch = useDispatch();
+  const authContext: IAuthContext = useContext(AuthContext);
+
+  console.log('🔍 LaravelEchoMgr: Initializing with authContext:', {
+    hasUser: !!authContext?.user,
+    userId: authContext?.user?.id,
+    authenticated: authContext?.authenticated
+  });
+
+  const clear = () => {
+    setLastEvent(null);
+  };
+
+  useEffect(() => {
+    console.log("Echo manager listener for private and public messages initialized")
+  }, []);
+
+  console.log('🔍 LaravelEchoMgr: Setting up public channel listener...');
+  const publicHook = useLaravelEcho({
+    type: 'public',
+    channel: 'public',
+    events: {
+      'public': (notification: IDashNotificationPayloadBase) => {
+
+        console.log('📡 LaravelEchoMgr: Received public notification:', notification);
+        setEvents([...events, notification]);
+        setLastEvent(notification);
+        //dispatch(apiRequest(ACTIONS.GET_NOTIFICATIONS, {}));
+        //popMessage(notification)
+        //alert(notification)
+        popStickyMessage(notification)
+      }
+    },
+    userId: null,
+    enabled: true, // Enable public channel
+  });
+
+  console.log('🔍 LaravelEchoMgr: Setting up private channel listener...');
+  const privateHook = useLaravelEcho({
+    type: 'private',
+    channel: `user.${authContext.user?.id}`,
+    events: {
+      // Try all these variations to see which one works
+      'notification': (notification: IDashNotificationPayloadBase) => {
+
+        console.log('📡 LaravelEchoMgr: Received private notification:', notification);
+
+        popPrivateMessage(notification);
+      }
+    },
+    userId: authContext.user?.id,
+    enabled: !!authContext?.user?.id, // Enable only when user is authenticated
+  });
+
+  // Capture lastEvent from the private hook's global event handler
+  // This picks up ALL events including import.progress, import.started, etc.
+  useEffect(() => {
+    if (privateHook?.lastEvent) {
+      console.log('📡 LaravelEchoMgr: Global event captured from private channel:', privateHook.lastEvent);
+      // Convert the hook's event format to the expected notification format
+      const eventData = privateHook.lastEvent.data;
+      if (eventData) {
+        setLastEvent(eventData as IDashNotificationPayloadBase);
+        setEvents(prev => [...prev, eventData as IDashNotificationPayloadBase]);
+      }
+    }
+  }, [privateHook?.lastEvent]);
+
+  // Also capture from public hook
+  useEffect(() => {
+    if (publicHook?.lastEvent) {
+      console.log('📡 LaravelEchoMgr: Global event captured from public channel:', publicHook.lastEvent);
+      const eventData = publicHook.lastEvent.data;
+      if (eventData) {
+        setLastEvent(eventData as IDashNotificationPayloadBase);
+        setEvents(prev => [...prev, eventData as IDashNotificationPayloadBase]);
+      }
+    }
+  }, [publicHook?.lastEvent]);
+
+  // Auto-clear lastEvent shortly after it's delivered. Currently-mounted consumers
+  // already captured the value in their effect closures by the time this runs, but
+  // any component that mounts later (e.g. after switching resources) sees null
+  // instead of replaying a stale notification. This ensures every event is acted on
+  // at most once, regardless of how many components observe lastEvent or when they mount.
+  useEffect(() => {
+    if (lastEvent === null) return;
+    const timeoutId = window.setTimeout(() => setLastEvent(null), 0);
+    return () => window.clearTimeout(timeoutId);
+  }, [lastEvent]);
+
+  return { events, lastEvent, clear };
+};
+
+export default LaravelEchoMgr;

package/src/contexts/com/components/DefaultNotificationComponent.tsx

@@ -0,0 +1,20 @@
+import MUISimpleJsonTable from '../../../components/misc/MuiSimpleJsonTable';
+import { IDashNotificationBase } from '../../../interfaces/communication/INotification';
+
+export interface IDefaultNotificationComponent {
+	notification: IDashNotificationBase<any>;
+}
+
+const ValidateProductsToImportNotificationComponent: React.FC<IDefaultNotificationComponent> =
+	({ notification, ...props }) => {
+		return (
+			<>
+				<MUISimpleJsonTable
+					tableData={notification.notificationPayload}
+					vertical={true}
+				/>
+			</>
+		);
+	};
+
+export default ValidateProductsToImportNotificationComponent;