saafe-redirection-flow 2.0.0

package/src/services/api/consent.service.ts

@@ -0,0 +1,142 @@
+import axiosInstance from './axios';
+
+export interface LinkedAccount {
+  fiType: string;
+  fiGroup: string | null;
+  fipHandle: string;
+  accountRefNumber: string;
+  linkRefNumber: string;
+  fipName: string;
+  maskedAccNumber: string;
+  txnId: string;
+  accountType: string;
+  isSelfConsent: boolean;
+  fiuName: string | null;
+  consentId: string | null;
+  amcName: string | null;
+  logoUrl: string;
+  state: string | null;
+}
+
+export interface ConsentDetails {
+  consentStart: string;
+  consentExpiry: string;
+  consentMode: string;
+  fetchType: string;
+  consentTypes: string[];
+  fiTypes: string[];
+  DataConsumer: {
+    name: string;
+    id: string;
+  };
+  Customer: {
+    id: string;
+  };
+  Purpose: {
+    code: string;
+    refUri: string;
+    text: string;
+    Category: {
+      type: string;
+    };
+  };
+  FIDataRange: {
+    from: string;
+    to: string;
+  };
+  DataLife: {
+    unit: string;
+    value: number;
+  };
+  Frequency: {
+    unit: string;
+    value: number;
+  };
+  DataFilter: Array<{
+    type: string;
+    operator: string;
+    value: string;
+  }>;
+  Account: null;
+  ConsentHandle: string;
+}
+
+export interface ApprovalRequest {
+  consentHandle: string[];
+  constentApprovalStatus: 'APPROVED' | 'REJECTED';
+  accounts: {
+    linkRefNumber: string;
+    fipHandle: string;
+  }[];
+}
+
+export interface ConsentResponse {
+  success: boolean;
+  message: string;
+  data?: {
+    consentHandle: string;
+    status: string;
+    timestamp: string;
+  };
+}
+
+export interface MandatoryConsentResponse {
+  [key: string]: {
+    enabled: boolean;
+    mandatory: boolean;
+  };
+}
+
+/**
+ * Service for managing consent-related operations
+ */
+export const consentService = {
+  /**
+   * Fetch linked accounts for a consent handle
+   */
+  getLinkedAccounts: async (consentHandle: string, fipId?: string): Promise<LinkedAccount[]> => {
+    const params: Record<string, string> = { consentHandle };
+    if (fipId) {
+      params.fipId = fipId
+    }
+    const response = await axiosInstance.get(`/User/linkedaccount`, {
+      params
+    });
+    return response.data;
+  },
+
+  /**
+   * Fetch consent details for a consent handle
+   */
+  getConsentDetails: async (consentHandle: string): Promise<ConsentDetails[]> => {
+    const response = await axiosInstance.get(`/User/Consent/handle?consentHandle=${consentHandle}`);
+    return response.data;
+  },
+
+  /**
+   * Fetch mandatory consent settings for a FIU ID
+   */
+  getMandatoryConsent: async (fiuId: string): Promise<MandatoryConsentResponse> => {
+    try {
+      const response = await axiosInstance.get(`/User/mandatoryConsent?fiu_id=${fiuId}`, {
+        headers: {
+          'Content-Type': 'application/json',
+          'Accept': 'application/json',
+        }
+      });
+      return response.data;
+    }
+    catch (error) {
+      //   console.error('Error fetching mandatory consent data:', error);
+      // throw error;
+    }
+  },
+
+  /**
+   * Send approval or rejection for consents
+   */
+  submitConsentVerification: async (data: ApprovalRequest): Promise<ConsentResponse> => {
+    const response = await axiosInstance.post('/User/Consents/Approval/Verification', data);
+    return response.data;
+  }
+}; 

package/src/services/api/decode.service.ts

@@ -0,0 +1,53 @@
+import axiosInstance from './axios'
+
+export interface DecodeUrlParams {
+  fi: string
+  ecreq: string
+  reqdate: string
+  profile?: string
+  platform?: string
+  theme?: string
+}
+
+export interface DecodedInfo {
+  isAutoDiscoveryEnabled: boolean
+  requestorType: string
+  autoDiscoveryEnabled: boolean
+  isUserPresent: boolean
+  txnid: string
+  sessionid: string
+  userid: string
+  redirect: string
+  srcref: string
+  phoneNumber: string
+  pan: string
+  dob: string | null
+  fiuId: string
+  fiuName: string
+  redirectionVersion: string
+  fipId: string
+  platform?: string
+  theme?: string
+  customization: {
+    fiu_custom_styles: string
+    otherAppCustomization: string
+  }
+  fiTypesRequiredForConsent: string[]
+}
+
+/**
+ * Service for decoding URL parameters
+ */
+export const decodeService = {
+  /**
+   * Decode URL parameters from the redirection URL
+   */
+  decodeUrlParams: async (params: DecodeUrlParams): Promise<DecodedInfo> => {
+    const response = await axiosInstance.post('/public/decode', params, {
+      headers: {
+        trackingid: ''
+      }
+    })
+    return response.data
+  }
+}

package/src/services/api/feedback.service.ts

@@ -0,0 +1,34 @@
+import axiosInstance from './axios';
+
+export interface FeedbackRequest {
+  ratings?: number;
+  feedback?: string;
+  consentHandle: string;
+}
+
+export interface FeedbackResponse {
+  success: boolean;
+  message: string;
+  data?: any;
+}
+
+/**
+ * Service for managing user feedback and ratings
+ */
+export const feedbackService = {
+  /**
+   * Submit user feedback and ratings
+   */
+  submitRating: async (data: FeedbackRequest): Promise<FeedbackResponse> => {
+    const response = await axiosInstance.post('/User/FeedbackAndRatings', data);
+    return response.data;
+  },
+
+  /**
+   * Submit text feedback about the experience
+   */
+  submitFeedback: async (data: FeedbackRequest): Promise<FeedbackResponse> => {
+    const response = await axiosInstance.post('/User/FeedbackAndRatings', data);
+    return response.data;
+  }
+}; 

package/src/services/api/fip.service.ts

@@ -0,0 +1,187 @@
+import axios, { AxiosError } from 'axios'
+import { useAuthStore } from '@/store/auth.store'
+import { FipData } from '@/store/fip.store'
+import { authService } from './auth.service'
+import { handleApiError } from '@/utils/toast-helpers'
+
+// Define API endpoints with absolute URLs
+const API_BASE_URL =
+  import.meta.env.VITE_API_BASE_URL || 'https://sandbox.saafe.in/api/v2'
+const FIP_ENDPOINTS = {
+  GET_FIPS: `${API_BASE_URL}/User/allFip`
+}
+
+// Define response types
+export interface FipResponseData {
+  [key: string]: FipData[] | unknown
+}
+
+// Create axios instance with interceptors
+const api = axios.create({
+  headers: {
+    'Content-Type': 'application/json'
+  }
+})
+
+// Type for request with retry flag
+interface RetryableRequest {
+  _retry?: boolean
+}
+
+// Request interceptor to add the auth token
+api.interceptors.request.use(
+  config => {
+    const { accessToken } = useAuthStore.getState()
+
+    if (accessToken) {
+      config.headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    return config
+  },
+  error => Promise.reject(error)
+)
+
+// Helper function for token refresh
+const refreshAuthToken = async () => {
+  const { refreshToken } = useAuthStore.getState()
+
+  if (!refreshToken) {
+    throw new Error('No refresh token available')
+  }
+
+  const response = await authService.refreshToken(refreshToken)
+
+  useAuthStore
+    .getState()
+    .setTokens(response.access_token, response.refresh_token)
+
+  return response.access_token
+}
+
+// Response interceptor to handle API response format and token refresh
+api.interceptors.response.use(
+  response => {
+    // If the response has data property, return it directly
+    if (response.data) {
+      return response
+    }
+    return response
+  },
+  async (error: AxiosError) => {
+    const originalRequest = error.config
+
+    // Check if the error is due to an expired token
+    if (
+      error.response?.status === 401 &&
+      originalRequest &&
+      !(originalRequest as RetryableRequest)._retry
+    ) {
+      // Mark the request as retried to prevent infinite loops
+      ; (originalRequest as RetryableRequest)._retry = true
+
+      try {
+        // Try to refresh the token
+        const newToken = await refreshAuthToken()
+
+        // Update the Authorization header with the new token
+        if (originalRequest.headers) {
+          originalRequest.headers.Authorization = `Bearer ${newToken}`
+        }
+
+        // Retry the original request with the new token
+        return api(originalRequest)
+      } catch (refreshError) {
+        // Logout the user on refresh token failure
+        useAuthStore.getState().logout()
+        handleApiError(refreshError, 'Session expired. Please login again.')
+        return Promise.reject(new Error('Session expired. Please login again.'))
+      }
+    }
+
+    // Handle API error with toast notification
+    handleApiError(error)
+    return Promise.reject(error)
+  }
+)
+
+export const fipService = {
+  /**
+   * Get raw FIP response to extract category structure
+   */
+  getRawFipResponse: async (
+    consentHandle?: string
+  ): Promise<FipResponseData> => {
+    try {
+      const params = consentHandle ? { consentHandle } : {}
+      const response = await api.get<FipResponseData>(FIP_ENDPOINTS.GET_FIPS, {
+        params
+      })
+      return response.data
+    } catch (error) {
+      handleApiError(error, 'Failed to fetch financial institutions')
+      throw error
+    }
+  },
+
+  /**
+   * Process the raw FIP response into a flat array
+   */
+  processFipResponse: async (
+    responseData: FipResponseData
+  ): Promise<FipData[]> => {
+    // Handle potential nested response structures
+    let fipData: FipData[] = []
+
+    if (!responseData) return []
+
+    if (Array.isArray(responseData)) {
+      // Direct array response
+      fipData = responseData as FipData[]
+    } else if (typeof responseData === 'object') {
+      // First look for category-based structure (GST, BANK, etc.)
+      const categoryKeys = Object.keys(responseData).filter(key =>
+        Array.isArray(responseData[key])
+      )
+
+      if (categoryKeys.length > 0) {
+        // Flatten all category arrays into one
+        fipData = categoryKeys.reduce((acc, category) => {
+          const categoryData = responseData[category]
+          if (Array.isArray(categoryData)) {
+            return [...acc, ...(categoryData as FipData[])]
+          }
+          return acc
+        }, [] as FipData[])
+      } else {
+        // Might be a nested structure, look for arrays
+        const potentialArrays = Object.values(responseData).filter(val =>
+          Array.isArray(val)
+        )
+        if (potentialArrays.length > 0) {
+          // Use the first array found
+          fipData = potentialArrays[0] as FipData[]
+        } else {
+          // If it's a single object, wrap it in an array
+          fipData = [responseData as unknown as FipData]
+        }
+      }
+    }
+
+    return fipData
+  },
+
+  /**
+   * Fetch list of Financial Information Providers (FIPs)
+   * Legacy method for backward compatibility
+   */
+  getFips: async (consentHandle?: string): Promise<FipData[]> => {
+    try {
+      const rawResponse = await fipService.getRawFipResponse(consentHandle)
+      return fipService.processFipResponse(rawResponse)
+    } catch (error) {
+      handleApiError(error, 'Failed to fetch and process FIPs')
+      throw error
+    }
+  }
+}

package/src/services/api/index.ts

@@ -0,0 +1,9 @@
+import axiosInstance from './axios';
+
+export { axiosInstance };
+export * from './auth.service';
+export * from './account.service';
+export * from './decode.service';
+export * from './consent.service';
+export * from './feedback.service';
+export * from './public.service';

package/src/services/api/public.service.ts

@@ -0,0 +1,18 @@
+import axiosInstance from './axios';
+
+export interface TrustedCountResponse {
+  trustedCount: string;
+}
+
+/**
+ * Service for public API endpoints that don't require authentication
+ */
+export const publicService = {
+  /**
+   * Get the trusted user count
+   */
+  getTrustedCount: async (): Promise<TrustedCountResponse> => {
+    const response = await axiosInstance.get('/public/trusted-count');
+    return response.data;
+  }
+}; 

package/src/services/api.ts

@@ -0,0 +1,2 @@
+// Export all API services from the api directory
+export * from './api/index'; 

package/src/services/postMessage.service.ts

@@ -0,0 +1,179 @@
+export interface PostMessageData {
+  type: 'CONSENT_RESULT';
+  status: 'success' | 'rejected' | 'error';
+  data?: {
+    consentHandle?: string;
+    txnid?: string;
+    sessionid?: string;
+    userid?: string;
+    fiuId?: string;
+    fiuName?: string;
+    reason?: string;
+    errorCode?: string;
+    rating?: number;
+    feedback?: string;
+    linkedAccounts?: Array<{
+      linkRefNumber: string;
+      fipHandle: string;
+      accountType: string;
+      maskedAccNumber: string;
+    }>;
+    consentDetails?: Array<{
+      consentHandle: string;
+      dataConsumerName: string;
+      purpose: string;
+    }>;
+  };
+}
+
+/**
+ * Service for communicating with parent iframe
+ */
+export const postMessageService = {
+  /**
+   * Send a message to the parent iframe with retries and multiple formats
+   */
+  sendToParent: (messageData: PostMessageData) => {
+    try {
+      // Only send if we're in an iframe
+      if (window.parent && window.parent !== window) {
+        console.log('PostMessage being sent to parent:', messageData);
+        
+        // Send the primary message format
+        window.parent.postMessage(messageData, '*');
+        
+        // Also send alternative formats for compatibility
+        if (messageData.status === 'success') {
+          // Send AA_COMPLETED format for compatibility
+          window.parent.postMessage({
+            type: 'AA_COMPLETED',
+            status: 'success',
+            data: messageData.data
+          }, '*');
+          
+          // Send AA_SUCCESS format for compatibility
+          window.parent.postMessage({
+            type: 'AA_SUCCESS',
+            data: messageData.data
+          }, '*');
+        } else if (messageData.status === 'rejected') {
+          // Send AA_REJECTED format for compatibility
+          window.parent.postMessage({
+            type: 'AA_REJECTED',
+            status: 'rejected',
+            data: messageData.data
+          }, '*');
+        } else if (messageData.status === 'error') {
+          // Send AA_ERROR format for compatibility
+          window.parent.postMessage({
+            type: 'AA_ERROR',
+            status: 'error',
+            data: messageData.data
+          }, '*');
+          
+          // Send AA_FAILED format for compatibility
+          window.parent.postMessage({
+            type: 'AA_FAILED',
+            status: 'failed',
+            data: messageData.data
+          }, '*');
+        }
+        
+        console.log('PostMessage sent successfully to parent');
+      } else {
+        console.log('Not in iframe, message would be:', messageData);
+        console.log('Window parent check:', window.parent, window.parent === window);
+      }
+    } catch (error) {
+      console.error('Error sending postMessage:', error);
+    }
+  },
+
+  /**
+   * Send message with delay to ensure parent is ready
+   */
+  sendWithDelay: (messageData: PostMessageData, delay: number = 1000) => {
+    setTimeout(() => {
+      postMessageService.sendToParent(messageData);
+    }, delay);
+  },
+
+  /**
+   * Send message multiple times to ensure delivery
+   */
+  sendWithRetries: (messageData: PostMessageData, retries: number = 3, interval: number = 500) => {
+    // Send immediately
+    postMessageService.sendToParent(messageData);
+    
+    // Send with delays
+    for (let i = 1; i <= retries; i++) {
+      setTimeout(() => {
+        postMessageService.sendToParent(messageData);
+      }, interval * i);
+    }
+  },
+
+  /**
+   * Send success message
+   */
+  sendSuccess: (data?: PostMessageData['data']) => {
+    const messageData = {
+      type: 'CONSENT_RESULT' as const,
+      status: 'success' as const,
+      data
+    };
+    
+    // Send immediately and with retries to ensure delivery
+    postMessageService.sendWithRetries(messageData, 2, 1000);
+  },
+
+  /**
+   * Send rejection message
+   */
+  sendRejected: (data?: PostMessageData['data']) => {
+    const messageData = {
+      type: 'CONSENT_RESULT' as const,
+      status: 'rejected' as const,
+      data
+    };
+    
+    // Send immediately and with retries to ensure delivery
+    postMessageService.sendWithRetries(messageData, 2, 1000);
+  },
+
+  /**
+   * Send error message
+   */
+  sendError: (data?: PostMessageData['data']) => {
+    const messageData = {
+      type: 'CONSENT_RESULT' as const,
+      status: 'error' as const,
+      data
+    };
+    
+    // Send immediately and with retries to ensure delivery
+    postMessageService.sendWithRetries(messageData, 2, 1000);
+  },
+
+  /**
+   * Debug function to test postMessage connectivity
+   */
+  testConnection: () => {
+    console.log('Testing postMessage connection...');
+    console.log('Window parent:', window.parent);
+    console.log('Is in iframe:', window.parent !== window);
+    console.log('Window origin:', window.location.origin);
+    
+    if (window.parent && window.parent !== window) {
+      // Send a test message
+      window.parent.postMessage({
+        type: 'TEST_MESSAGE',
+        timestamp: new Date().toISOString(),
+        origin: window.location.origin
+      }, '*');
+      console.log('Test message sent to parent');
+    } else {
+      console.log('Not in iframe - cannot send test message');
+    }
+  }
+};

package/src/store/NavigationBlockContext.tsx

@@ -0,0 +1,34 @@
+import React, { createContext, useRef, useContext } from 'react';
+
+type NavigationBlockContextType = {
+  allowNextNavigation: () => void;
+  shouldAllowNavigation: () => boolean;
+};
+
+const NavigationBlockContext = createContext<NavigationBlockContextType | null>(null);
+
+export const NavigationBlockProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  const allowNavigationRef = useRef(false);
+
+  const allowNextNavigation = () => {
+    allowNavigationRef.current = true;
+  };
+
+  const shouldAllowNavigation = () => {
+    const allowed = allowNavigationRef.current;
+    allowNavigationRef.current = false; // reset after checking
+    return allowed;
+  };
+
+  return (
+    <NavigationBlockContext.Provider value={{ allowNextNavigation, shouldAllowNavigation }}>
+      {children}
+    </NavigationBlockContext.Provider>
+  );
+};
+
+export const useNavigationBlock = () => {
+  const context = useContext(NavigationBlockContext);
+  if (!context) throw new Error('useNavigationBlock must be used within NavigationBlockProvider');
+  return context;
+};