saafe-redirection-flow 2.0.0 → 2.1.0

package/src/pages/accounts/AccountsToProceed.tsx

@@ -22,10 +22,13 @@ import { useSetPageTitle } from '@/hooks/use-page-title'
 import DummyFooter from '@/components/dummyFooter'
 import { useRedirectStore } from '@/store/redirect.store'
 import { fiTypeCategoryMap } from '@/const/fiTypeCategoryMap'
+import { useAutoDiscovery } from '@/hooks/use-auto-discovery'
+import { parseAutoDiscoveryConfig } from '@/utils/auto-discovery'
 interface AccountsToProceedProps {
   state?: {
     category: string
     selectedFips: string[]
+    isAutoDiscovery?: boolean
   }
   currentCategory?: string | null
 }
@@ -42,7 +45,6 @@ const AccountsToProceed = ({
     groupedFips,
     activeCategory,
     setSelectedAccountToLink,
-    setSignature,
     setOriginalAccounts,
     originalAccounts
   } = useFipStore()
@@ -56,6 +58,7 @@ const AccountsToProceed = ({
 
   // Account discovery with enhanced error handling
   const { mutate, errorMessage, clearError } = useAccountDiscovery()
+  const autoDiscovery = useAutoDiscovery()
 
   // Format category name for display
   const formatCategoryName = (name: string) => {
@@ -75,11 +78,141 @@ const AccountsToProceed = ({
 
   const requiredCategory = activeCategory ? fiTypeCategoryMap[activeCategory]?.filter((fiType: string) => decodedInfo?.fiTypesRequiredForConsent?.includes(fiType)) || [] : [];
 
+  // Check if "Discover More" should be shown based on auto discovery configuration
+  const autoDiscoveryConfig = parseAutoDiscoveryConfig(decodedInfo?.customization?.otherAppCustomization)
+  const shouldShowDiscoverMore = state?.isAutoDiscovery 
+    ? autoDiscoveryConfig[activeCategory?.toUpperCase() as keyof typeof autoDiscoveryConfig]?.showDiscoverMore
+    : true // Always show for manual discovery
+
+  console.log('AccountsToProceed Debug:', {
+    state,
+    isAutoDiscovery: state?.isAutoDiscovery,
+    category,
+    activeCategory,
+    fipIds,
+    shouldShowDiscoverMore,
+    autoDiscoveryConfig: autoDiscoveryConfig[activeCategory?.toUpperCase() as keyof typeof autoDiscoveryConfig]
+  });
+
   // Discover accounts when component loads
   useEffect(() => {
+    console.log('AccountsToProceed useEffect:', {
+      isAutoDiscovery: state?.isAutoDiscovery,
+      category,
+      fipIds: fipIds.length,
+      groupedFipsKeys: Object.keys(groupedFips || {})
+    });
+    
     let mounted = true
 
-    if (fipIds.length > 0) {
+    if (state?.isAutoDiscovery) {
+      console.log('Using AUTO DISCOVERY for category:', category);
+      
+      // First validate identifiers before proceeding with auto discovery
+      const { fips, identifiers: storeIdentifiers } = useFipStore.getState();
+      const identifiersList: Array<{
+        type: string;
+        value: string | undefined;
+        category: string;
+      }> = [];
+      
+      // For auto discovery, we need to check identifiers across all FIPs in the category
+      const categoryFips = fips.filter(fip => 
+        fip.fiTypeList.some(fiType => 
+          fiTypeCategoryMap[category]?.includes(fiType)
+        ) && fip.isEnabled && fip.isOnBoarded
+      );
+      
+      // Collect required identifiers from category FIPs
+      categoryFips.forEach(fip => {
+        fip.Identifiers?.forEach(identifier => {
+          if (!identifiersList.find(i => i.type === identifier.type)) {
+            // First check if we already have this identifier in store
+            const storeIdentifier = storeIdentifiers.find(i => i.type === identifier.type);
+            let value: string | undefined = undefined;
+            if (storeIdentifier?.value !== undefined) {
+              value = storeIdentifier.value;
+            }
+            
+            // If not in store, fall back to decodedInfo
+            if (!value) {
+              value = identifier.type === 'PAN'
+                ? (decodedInfo?.pan || undefined)
+                : identifier.type === 'MOBILE'
+                  ? (decodedInfo?.phoneNumber || undefined)
+                  : identifier.type === 'DOB'
+                  ? (decodedInfo?.dob || undefined)
+                  : undefined;
+            }
+            
+            identifiersList.push({ 
+              type: identifier.type,
+              value, 
+              category: identifier.category 
+            });
+          }
+        });
+      });
+
+      console.log('Auto Discovery - Checking identifiers:', identifiersList);
+      console.log('Auto Discovery - Store identifiers:', storeIdentifiers);
+
+      // Check if any required identifiers are missing
+      const missingIdentifiers = identifiersList.filter(identifier => 
+        !identifier.value || identifier.value.trim() === ''
+      );
+
+      if (missingIdentifiers.length > 0) {
+        console.log('Auto Discovery - Missing identifiers found, redirecting to collect:', missingIdentifiers);
+        // Redirect to DiscoverAccount to collect missing identifiers
+        navigate(`/link-accounts/discover-account`, {
+          state: {
+            category,
+            selectedFips: fipIds, // Use the auto discovery FIP IDs
+            fromAutoDiscovery: true
+          }
+        });
+        return; // Don't proceed with auto discovery
+      }
+
+      console.log('Auto Discovery - All identifiers available, proceeding with discovery');
+      // All identifiers are available, set them in store and proceed with auto discovery
+      const { setIdentifiers } = useFipStore.getState();
+      setIdentifiers(identifiersList);
+      
+      // Use auto discovery
+      setIsLoading(true)
+      autoDiscovery.clearError()
+
+      autoDiscovery.mutate(category, {
+        onSuccess: result => {
+          if (!mounted) return
+          console.log('Auto discovery success:', result);
+          const groupedAccounts = result.accounts.reduce(
+            (acc: Record<string, typeof result.accounts>, account) => {
+              const key = account.type
+              if (!acc[key]) {
+                acc[key] = []
+              }
+              acc[key].push(account)
+              return acc
+            },
+            {}
+          )
+          setDiscoveryResult({ ...result, groupedAccounts })
+          setOriginalAccounts(result.originalAccounts)
+
+          setIsLoading(false)
+        },
+        onError: (error) => {
+          if (!mounted) return
+          console.log('Auto discovery error:', error);
+          setIsLoading(false)
+        }
+      })
+    } else if (fipIds.length > 0) {
+      console.log('Using MANUAL DISCOVERY for FIPs:', fipIds);
+      // Use manual discovery
       setIsLoading(true)
       clearError()
 
@@ -98,7 +231,6 @@ const AccountsToProceed = ({
             {}
           )
           setDiscoveryResult({ ...result, groupedAccounts })
-          setSignature(result.signature)
           setOriginalAccounts(result.originalAccounts)
 
           setIsLoading(false)
@@ -108,24 +240,65 @@ const AccountsToProceed = ({
           setIsLoading(false)
         }
       })
+    } else {
+      console.log('No discovery triggered - no FIPs and not auto discovery');
     }
 
     // Cleanup function to handle unmounting
     return () => {
       mounted = false
     }
-  }, [fipIds]) // Only depend on fipIds changing
+  }, [fipIds, state?.isAutoDiscovery, category]) // Depend on auto discovery flag and category
 
   const handleProceed = () => {
-    const result: typeof originalAccounts = []
+    console.log('handleProceed called with:', { selectedAccounts, originalAccounts })
+    
+    const result: Array<{
+      id: string;
+      fipId: string;
+      fipName: string;
+      signature: string;
+      type: string;
+      maskedAccountNumber: string;
+      bankName: string;
+      logoUrl?: string;
+      isNew?: boolean;
+             DiscoveredAccounts: Array<{
+         FIType: string;
+         accType: string;
+         accRefNumber: string;
+         maskedAccNumber: string;
+         state: string | null;
+         amcName: string | null;
+         logoUrl: string | null;
+       }>;
+    }> = []
+    
     originalAccounts.forEach((item, index) => {
-      const data = item?.["DiscoveredAccounts"].filter(account => selectedAccounts.includes(account.accRefNumber))
+      const data = item?.["DiscoveredAccounts"].filter(account => 
+        selectedAccounts.includes(account.accRefNumber)
+      )
       if (data.length > 0) {
-        result.push({ ...item, DiscoveredAccounts: data, id: `${index} - ${item.fipName}` })
+        // For each FIP with selected accounts, create one entry
+        result.push({ 
+          id: `${index} - ${item.fipName}`,
+          fipId: item.fipId,
+          fipName: item.fipName,
+          signature: (item as { signature?: string }).signature || '', // Use signature from the specific FIP
+          type: data[0]?.FIType || 'DEFAULT',
+          maskedAccountNumber: data[0]?.maskedAccNumber || '',
+          bankName: item.fipName,
+          logoUrl: data[0]?.logoUrl || undefined,
+          isNew: false,
+          DiscoveredAccounts: data
+        })
       }
     })
 
+    console.log('handleProceed result:', result)
+    console.log('Setting selectedAccountToLink with result length:', result.length)
     setSelectedAccountToLink(result)
+    
     // Navigate to account linking screen with selected accounts and signature
     navigate('/link-accounts/link', {
       state: {
@@ -188,7 +361,28 @@ const AccountsToProceed = ({
 
 
   const retryDiscovery = () => {
-    if (fipIds.length > 0) {
+    if (state?.isAutoDiscovery) {
+      // Retry auto discovery
+      setIsLoading(true)
+      autoDiscovery.clearError()
+
+      autoDiscovery.mutate(category, {
+        onSuccess: result => {
+          setDiscoveryResult(result)
+
+          // Auto-select all accounts by default
+          if (result.accounts.length > 0) {
+            setSelectedAccounts(result.accounts.map(account => account.id))
+          }
+
+          setIsLoading(false)
+        },
+        onError: () => {
+          setIsLoading(false)
+        }
+      })
+    } else if (fipIds.length > 0) {
+      // Retry manual discovery
       setIsLoading(true)
       clearError()
 
@@ -210,6 +404,82 @@ const AccountsToProceed = ({
     }
   }
 
+  // Function to validate identifiers before showing discover more
+  const validateIdentifiersBeforeDiscoverMore = () => {
+    // Get the FIP store state to access fips data
+    const { fips } = useFipStore.getState();
+    
+    if (!fipIds || fipIds.length === 0) {
+      return true; // No FIPs selected, can't validate
+    }
+    
+    const identifiersList: Array<{
+      type: string;
+      value: string | null | undefined;
+      categoryType: string;
+    }> = [];
+    
+    // Collect required identifiers from selected FIPs
+    fips
+      .filter(fip => fipIds.includes(fip.id))
+      .forEach(fip => {
+        fip.Identifiers?.forEach(identifier => {
+          if (!identifiersList.find(i => i.type === identifier.type)) {
+            const value =
+              identifier.type === 'PAN'
+                ? decodedInfo?.pan
+                : identifier.type === 'MOBILE'
+                  ? decodedInfo?.phoneNumber
+                  : identifier.type === 'DOB'
+                  ? decodedInfo?.dob
+                  : null;
+            identifiersList.push({ 
+              type: identifier.type,
+              value, 
+              categoryType: identifier.category 
+            });
+          }
+        });
+      });
+
+    console.log('AccountsToProceed - Checking identifiers for discover more:', identifiersList);
+
+    // Check if any required identifiers are missing
+    const missingIdentifiers = identifiersList.filter(identifier => 
+      !identifier.value || identifier.value.trim() === ''
+    );
+
+    if (missingIdentifiers.length > 0) {
+      console.log('AccountsToProceed - Missing identifiers found, redirecting to collect:', missingIdentifiers);
+      // Redirect to DiscoverAccount to collect missing identifiers
+      navigate(`/link-accounts/discover-account`, {
+        state: {
+          category,
+          selectedFips: fipIds,
+          fromDiscoverMore: true
+        }
+      });
+      return false; // Don't show discover more button
+    }
+
+    return true; // All identifiers available, can show discover more
+  };
+
+  const handleDiscoverMore = () => {
+    // Validate identifiers first
+    if (!validateIdentifiersBeforeDiscoverMore()) {
+      return; // Don't proceed if identifiers are missing
+    }
+
+    // Proceed with original navigation
+    navigate(`/link-accounts/${category.toLowerCase()}`, {
+      state: {
+        category,
+        selectedFips: fipIds
+      }
+    });
+  };
+
   const renderAccountGroups = () => {
     if (isLoading) {
       return Array(3)
@@ -263,7 +533,7 @@ const AccountsToProceed = ({
 
     return (
       <div className='text-center p-4 text-gray-500'>
-        {errorMessage
+        {(errorMessage || autoDiscovery.errorMessage)
           ? 'Failed to discover accounts'
           : 'No accounts found for the selected banks'}
       </div>
@@ -301,11 +571,11 @@ const AccountsToProceed = ({
           }
         />
 
-        {errorMessage && (
+        {(errorMessage || autoDiscovery.errorMessage) && (
           <Alert variant='destructive' className='flex items-center'>
             <AlertCircle className='w-4 h-4' />
             <AlertDescription className='flex items-center justify-between'>
-              {errorMessage}
+              {errorMessage || autoDiscovery.errorMessage}
               <Button
                 variant='outline'
                 size='sm'
@@ -324,18 +594,11 @@ const AccountsToProceed = ({
               {renderAccountGroups()}
             </div>
           </div>
-          {requiredCategory?.every(fiType => totalCategory?.includes(fiType)) ? null :
+          {(requiredCategory?.every(fiType => totalCategory?.includes(fiType)) || !shouldShowDiscoverMore) ? null :
             <Button
               variant={'outline'}
               className='bg-primary-foreground text-primary border-primary hover:bg-primary/10 h-[50px] dark:bg-ring'
-              onClick={() =>
-                navigate(`/link-accounts/${category.toLowerCase()}`, {
-                  state: {
-                    category,
-                    selectedFips: fipIds
-                  }
-                })
-              }
+              onClick={handleDiscoverMore}
               size={'lg'}
             >
               <div className='flex items-center gap-2 text-md text-primary font-[600] dark:text-muted-secondary'>

package/src/pages/accounts/Discover.tsx

@@ -6,14 +6,20 @@ import { useLocation, useParams } from "react-router-dom";
 import AccountsToProceed from "./AccountsToProceed";
 import LinkSelectedAccounts from "./LinkSelectedAccounts";
 import DiscoverAccount from "./DiscoverAccount";
+
 import { useFipStore } from "@/store/fip.store";
+import { useRedirectStore } from "@/store/redirect.store";
 import { useEffect } from "react";
+import { useNavigate } from "react-router-dom";
+import { isAutoDiscoveryEnabled, getAutoDiscoveryFipIds } from "@/utils/auto-discovery";
 
 const Discover = () => {
   const { category } = useParams();
   const location = useLocation();
   const path = location.pathname.split('/').pop() || '';
-  const { activeCategory, setActiveCategory, categories } = useFipStore();
+  const navigate = useNavigate();
+  const { activeCategory, setActiveCategory, categories, groupedFips, setSelectedFips } = useFipStore();
+  const { decodedInfo } = useRedirectStore();
 
   // For step navigation in the sidebar - detect category from path
   useEffect(() => {
@@ -37,19 +43,131 @@ const Discover = () => {
     }
   }, [path, category, categories, setActiveCategory, location.state]);
 
+  // Handle auto discovery logic
+  useEffect(() => {
+    // Only run auto discovery logic on category pages (not flow pages)
+    const flowPaths = ['discovery', 'link', 'discover-account'];
+    const isFlowPath = flowPaths.includes(path);
+    
+    console.log('Auto Discovery Debug:', {
+      path,
+      isFlowPath,
+      activeCategory,
+      hasDecodedInfo: !!decodedInfo,
+      otherAppCustomization: decodedInfo?.customization?.otherAppCustomization,
+      fipId: decodedInfo?.fipId,
+      locationPathname: location.pathname,
+      groupedFipsKeys: Object.keys(groupedFips || {}),
+      groupedFipsEmpty: !groupedFips || Object.keys(groupedFips).length === 0,
+      categoriesLoaded: categories.length > 0
+    });
+    
+    // Guard clauses to prevent unnecessary execution
+    if (isFlowPath || !activeCategory || !decodedInfo) {
+      console.log('Auto Discovery: Early return due to guard clauses', {
+        isFlowPath,
+        activeCategory,
+        hasDecodedInfo: !!decodedInfo
+      });
+      return;
+    }
+
+    // Check if groupedFips is loaded
+    if (!groupedFips || Object.keys(groupedFips).length === 0) {
+      console.log('Auto Discovery: groupedFips not loaded yet, waiting...');
+      return;
+    }
+
+    // Additional guard: only run for supported auto discovery categories
+    const supportedCategories = ['INVESTMENTS', 'GST', 'INSURANCE'];
+    if (!supportedCategories.includes(activeCategory.toUpperCase())) {
+      console.log('Auto Discovery: Category not supported:', activeCategory);
+      return;
+    }
+
+    const autoDiscoveryEnabled = isAutoDiscoveryEnabled(
+      activeCategory,
+      decodedInfo?.customization?.otherAppCustomization
+    );
+
+    console.log('Auto Discovery: Enabled?', autoDiscoveryEnabled, 'for category:', activeCategory);
+
+    if (autoDiscoveryEnabled) {
+      // Get FIP IDs for auto discovery
+      const fipIds = getAutoDiscoveryFipIds(
+        activeCategory,
+        decodedInfo?.fipId,
+        groupedFips
+      );
+      
+      console.log('Auto Discovery: FIP IDs:', fipIds, 'groupedFips keys:', Object.keys(groupedFips || {}));
+      
+      if (fipIds.length > 0) {
+        // Additional guard: check if we're already navigating or have navigated
+        if (location.pathname === '/link-accounts/discovery') {
+          console.log('Auto Discovery: Already on discovery page, skipping navigation');
+          return;
+        }
+        
+        console.log('Auto Discovery: Navigating to discovery with FIPs:', fipIds);
+        
+        // Set selected FIPs in the store
+        setSelectedFips(activeCategory, fipIds);
+        
+        // IMPORTANT: Also populate identifiers in the store for manual discovery hooks to use
+        // This mirrors the logic from link-accounts.tsx handleNext function
+        const { fips, setIdentifiers, selectedMobileNumber } = useFipStore.getState();
+        const identifiersList: { type: string; value: string | null; category: string }[] = [];
+        
+        fips
+          .filter(fip => fipIds.includes(fip.id))
+          .forEach(fip => {
+            fip.Identifiers?.forEach(identifier => {
+              if (!identifiersList.find(i => i.type === identifier.type)) {
+                const value =
+                  identifier.type === 'PAN'
+                    ? decodedInfo?.pan
+                    : identifier.type === 'MOBILE'
+                      ? selectedMobileNumber || decodedInfo?.phoneNumber
+                      : identifier.type === 'DOB'
+                      ? decodedInfo?.dob
+                      : null;
+                identifiersList.push({ type: identifier.type, value, category: identifier.category });
+              }
+            });
+          });
+        
+        console.log('Auto Discovery: Setting identifiers in store:', identifiersList);
+        setIdentifiers(identifiersList);
+        
+        // Navigate to discovery page
+        navigate('/link-accounts/discovery', {
+          state: {
+            category: activeCategory,
+            selectedFips: fipIds,
+            isAutoDiscovery: true
+          },
+          replace: true // Use replace to avoid back button issues
+        });
+      } else {
+        console.log('Auto Discovery: No FIP IDs found, staying on FIP listing');
+      }
+    }
+  }, [activeCategory, path, decodedInfo?.customization?.otherAppCustomization, decodedInfo?.fipId, location.pathname, groupedFips, categories]);
+
   const getCurrentStep = (newPath: string) => {
     // Flow paths
     switch (newPath || path) {
       case 'discovery':
       case 'proceed':
         return <AccountsToProceed
-          state={location.state as { category: string; selectedFips: string[] }}
+          state={location.state as { category: string; selectedFips: string[]; isAutoDiscovery?: boolean }}
           currentCategory={activeCategory}
-        />;
-
-      case 'link':
+                  />;
+        
+        case 'link':
         return <LinkSelectedAccounts
-          state={location.state as { category: string; selectedFips: string[] }}
+          state={location.state as { category: string; selectedFips: string[]; selectedAccounts: string[]; signature?: string }}
           currentCategory={activeCategory}
         />;
 
@@ -60,15 +178,15 @@ const Discover = () => {
         />;
 
       default:
-        // If we're on a category path or any other path, show FIP listing
-        // This handles all category paths like /link-accounts/banks, /link-accounts/investment etc.
+        // Default: show FIP listing (manual flow)
+        // Auto discovery logic is now handled in useEffect above
         return <LinkAccounts />;
     }
   }
 
   return (
     <FrostedLayout>
-      {getCurrentStep()}
+      {getCurrentStep(path)}
     </FrostedLayout>
   )
 }