@onairos/react-native 3.1.12 → 3.1.13

package/src/services/biometricPinService.ts

@@ -0,0 +1,193 @@
+import * as Keychain from 'react-native-keychain';
+import { Platform } from 'react-native';
+
+// Service key for PIN storage
+const PIN_SERVICE_KEY = 'OnairosEventsPIN';
+const PIN_USERNAME = 'user_pin';
+
+export interface BiometricPinService {
+  storePinWithBiometric: (pin: string) => Promise<boolean>;
+  retrievePinWithBiometric: () => Promise<string | null>;
+  isPinStored: () => Promise<boolean>;
+  removePinFromStorage: () => Promise<boolean>;
+  isBiometricAvailable: () => Promise<boolean>;
+}
+
+/**
+ * Check if biometric authentication is available on the device
+ */
+export const isBiometricAvailable = async (): Promise<boolean> => {
+  try {
+    const biometryType = await Keychain.getSupportedBiometryType();
+    console.log('📱 Biometric support:', biometryType);
+    
+    // Check for Face ID on iOS or any biometric on Android
+    return biometryType === Keychain.BIOMETRY_TYPE.FACE_ID || 
+           biometryType === Keychain.BIOMETRY_TYPE.TOUCH_ID ||
+           biometryType === Keychain.BIOMETRY_TYPE.FINGERPRINT ||
+           biometryType === Keychain.BIOMETRY_TYPE.FACE ||
+           biometryType === Keychain.BIOMETRY_TYPE.IRIS;
+  } catch (error) {
+    console.error('❌ Error checking biometric availability:', error);
+    return false;
+  }
+};
+
+/**
+ * Store PIN with biometric authentication
+ */
+export const storePinWithBiometric = async (pin: string): Promise<boolean> => {
+  try {
+    console.log('🔐 Starting Face ID authentication for PIN storage...');
+    
+    // Check if biometric is available - REQUIRED for this implementation
+    const biometricAvailable = await isBiometricAvailable();
+    if (!biometricAvailable) {
+      console.error('❌ Face ID/Touch ID not available on this device');
+      return false;
+    }
+    
+    console.log('📱 Face ID available, showing authentication prompt...');
+    
+    // Configure keychain options for MANDATORY biometric authentication
+    const keychainOptions = {
+      accessControl: Keychain.ACCESS_CONTROL.BIOMETRY_CURRENT_SET,
+      authenticationType: Keychain.AUTHENTICATION_TYPE.BIOMETRICS,
+      touchID: true,
+      showModal: true,
+      kLocalizedFallbackTitle: '', // Disable fallback to prevent passcode option
+      // Add explicit prompts for better UX
+      ...(Platform.OS === 'ios' && {
+        localizedPrompt: 'Authenticate with Face ID to secure your PIN',
+        localizedCancel: 'Cancel',
+      }),
+      ...(Platform.OS === 'android' && {
+        promptMessage: 'Authenticate with biometric to secure your PIN',
+        cancelButtonText: 'Cancel',
+      })
+    } as const;
+    
+    // Store the PIN - this will trigger the Face ID prompt
+    console.log('👤 Requesting Face ID authentication...');
+    const result = await Keychain.setInternetCredentials(
+      PIN_SERVICE_KEY,
+      PIN_USERNAME,
+      pin,
+      keychainOptions
+    );
+    
+    console.log('✅ Face ID authentication successful - PIN stored securely');
+    console.log('🔍 Keychain storage result:', result);
+    return true;
+    
+  } catch (error: any) {
+    console.error('❌ Face ID authentication failed:', error);
+    console.error('❌ Error details:', {
+      message: error.message,
+      code: error.code,
+      domain: error.domain,
+      userInfo: error.userInfo
+    });
+    
+    // Handle specific error cases
+    if (error?.message?.includes('UserCancel') || error?.code === -128) {
+      console.log('👤 User cancelled Face ID authentication');
+      return false;
+    } else if (error?.message?.includes('BiometryNotAvailable') || error?.code === -6) {
+      console.log('📱 Face ID/Touch ID not available');
+      return false;
+    } else if (error?.message?.includes('AuthenticationFailed') || error?.code === -1) {
+      console.log('🚫 Face ID authentication failed');
+      return false;
+    } else if (error?.message?.includes('BiometryLockout') || error?.code === -8) {
+      console.log('🔒 Face ID locked out - too many failed attempts');
+      return false;
+    }
+    
+    console.error('❌ Unknown Face ID error:', error.message);
+    return false;
+  }
+};
+
+/**
+ * Retrieve PIN with biometric authentication
+ */
+export const retrievePinWithBiometric = async (): Promise<string | null> => {
+  try {
+    console.log('🔓 Retrieving PIN with biometric authentication...');
+    
+    // Retrieve the PIN (will prompt for biometric if configured)
+    const credentials = await Keychain.getInternetCredentials(PIN_SERVICE_KEY);
+    
+    if (credentials && credentials.password) {
+      console.log('✅ PIN retrieved successfully');
+      return credentials.password;
+    } else {
+      console.log('⚠️ No PIN found in secure storage');
+      return null;
+    }
+    
+  } catch (error: any) {
+    console.error('❌ Error retrieving PIN with biometric:', error);
+    
+    // Handle specific error cases
+    if (error?.message?.includes('UserCancel')) {
+      console.log('👤 User cancelled biometric authentication');
+      return null;
+    } else if (error?.message?.includes('BiometryNotAvailable')) {
+      console.log('📱 Biometric not available');
+      return null;
+    }
+    
+    return null;
+  }
+};
+
+/**
+ * Check if PIN is stored in secure storage
+ */
+export const isPinStored = async (): Promise<boolean> => {
+  try {
+    const credentials = await Keychain.getInternetCredentials(PIN_SERVICE_KEY);
+    return !!(credentials && credentials.password);
+  } catch (error: any) {
+    console.error('❌ Error checking PIN storage:', error);
+    return false;
+  }
+};
+
+/**
+ * Remove PIN from secure storage
+ */
+export const removePinFromStorage = async (): Promise<boolean> => {
+  try {
+    console.log('🗑️ Removing PIN from secure storage...');
+    
+    // For v10.0.0, we need to use resetGenericPassword instead of resetInternetCredentials
+    // or handle the API difference properly
+    try {
+      await Keychain.resetGenericPassword({ service: PIN_SERVICE_KEY });
+      console.log('✅ PIN removed successfully');
+      return true;
+    } catch (resetError) {
+      // Fallback: try the old API
+      console.log('🔄 Trying alternative reset method...');
+      const result = await (Keychain as any).resetInternetCredentials(PIN_SERVICE_KEY);
+      console.log('✅ PIN removed successfully with fallback method');
+      return true;
+    }
+    
+  } catch (error: any) {
+    console.error('❌ Error removing PIN from storage:', error);
+    return false;
+  }
+};
+
+// Export the service object
+export const biometricPinService: BiometricPinService = {
+  storePinWithBiometric,
+  retrievePinWithBiometric,
+  isPinStored,
+  removePinFromStorage,
+  isBiometricAvailable,
+}; 

package/src/services/connectedAccountsService.ts

@@ -0,0 +1,290 @@
+import { getAuthToken } from './authService';
+import { API_CONFIG, getApiHeaders, getAuthHeaders } from '../config/api';
+
+const API_BASE_URL = API_CONFIG.BASE_URL;
+
+// Interface for connected account from API
+export interface ConnectedAccount {
+  platform: string;
+  username: string;
+  url: string;
+}
+
+// Interface for API response
+export interface ConnectedAccountsResponse {
+  success: boolean;
+  connectedAccounts: ConnectedAccount[];
+}
+
+/**
+ * NEW UNIFIED LOOKUP - Get connected accounts using the simplified lookup endpoint
+ * This is the preferred method that makes only ONE request to the backend
+ * @param userIdentifier - Can be email, username, userId, or any user identifier
+ * @returns Promise<ConnectedAccount[]>
+ */
+export const getConnectedAccountsLookup = async (userIdentifier: string): Promise<ConnectedAccount[]> => {
+  try {
+    console.log('🔍 [NEW API] Fetching connected accounts via unified lookup for:', userIdentifier);
+    
+    const token = await getAuthToken();
+    
+    // Use the new simplified endpoint format
+    const response = await fetch(`${API_BASE_URL}/connectedAccounts/lookup/${encodeURIComponent(userIdentifier)}`, {
+      method: 'GET',
+      headers: token ? getAuthHeaders(token) : getApiHeaders()
+    });
+    
+    if (response.ok) {
+      const data: ConnectedAccountsResponse = await response.json();
+      console.log('✅ [NEW API] Connected accounts fetched successfully:', data);
+      
+      if (data.success && data.connectedAccounts && data.connectedAccounts.length > 0) {
+        console.log(`✅ [NEW API] Found ${data.connectedAccounts.length} connected accounts`);
+        return data.connectedAccounts;
+      } else {
+        console.log('ℹ️ [NEW API] No connected accounts found for user');
+        return [];
+      }
+    } else {
+      console.log(`⚠️ [NEW API] Response not OK: ${response.status} ${response.statusText}`);
+      return [];
+    }
+    
+  } catch (error) {
+    console.log('❌ [NEW API] Error fetching connected accounts via lookup:', error);
+    return [];
+  }
+};
+
+/**
+ * SMART CONNECTED ACCOUNTS FETCHER - Uses new API with old API fallback
+ * This function tries the new unified lookup first, then falls back to old methods if needed
+ * @param userEmail - User's email (primary identifier)
+ * @param userId - User's ID (fallback)
+ * @param username - User's username (fallback)
+ * @returns Promise<ConnectedAccount[]>
+ */
+export const getConnectedAccountsSmart = async (
+  userEmail?: string, 
+  userId?: string, 
+  username?: string
+): Promise<ConnectedAccount[]> => {
+  console.log('🧠 [SMART API] Starting smart connected accounts fetch...');
+  console.log('🧠 [SMART API] Available identifiers:', { userEmail, userId, username });
+  
+  // Try the new unified lookup API first (preferred method)
+  if (userEmail) {
+    console.log('🧠 [SMART API] Trying new unified lookup with email:', userEmail);
+    const accounts = await getConnectedAccountsLookup(userEmail);
+    if (accounts.length > 0) {
+      console.log('✅ [SMART API] Success with new unified lookup via email');
+      return accounts;
+    }
+    console.log('🔄 [SMART API] New API returned no results, trying fallbacks...');
+  }
+  
+  // If new API didn't work or no email, try fallbacks
+  console.log('🔄 [SMART API] Falling back to old API methods...');
+  
+  // Try old API methods as fallback
+  let accounts: ConnectedAccount[] = [];
+  
+  // Prioritize email for profile views
+  if (userEmail && accounts.length === 0) {
+    console.log('🔄 [SMART API] Trying old API with email:', userEmail);
+    accounts = await getConnectedAccountsByEmail(userEmail);
+  }
+  
+  if (accounts.length === 0 && userId) {
+    console.log('🔄 [SMART API] Trying old API with userId:', userId);
+    accounts = await getConnectedAccountsByUserId(userId);
+  }
+  
+  if (accounts.length === 0 && username) {
+    console.log('🔄 [SMART API] Trying old API with username:', username);
+    accounts = await getConnectedAccountsByUsername(username);
+  }
+  
+  if (accounts.length > 0) {
+    console.log(`✅ [SMART API] Success with old API fallback: ${accounts.length} accounts`);
+  } else {
+    console.log('⚠️ [SMART API] No connected accounts found with any method');
+  }
+  
+  return accounts;
+};
+
+// =============================================================================
+// LEGACY API FUNCTIONS - Keep for backward compatibility and fallback
+// These will be used as fallbacks if the new unified lookup fails
+// =============================================================================
+
+/**
+ * Get connected accounts by username
+ * @param username - Username to fetch connected accounts for
+ * @returns Promise<ConnectedAccount[]>
+ */
+export const getConnectedAccountsByUsername = async (username: string): Promise<ConnectedAccount[]> => {
+  try {
+    console.log('🔍 [LEGACY] Fetching connected accounts for username:', username);
+    
+    const token = await getAuthToken();
+    
+    const response = await fetch(`${API_BASE_URL}/connectedAccounts?username=${encodeURIComponent(username)}`, {
+      method: 'GET',
+      headers: token ? getAuthHeaders(token) : getApiHeaders()
+    });
+    
+    if (response.ok) {
+      const data: ConnectedAccountsResponse = await response.json();
+      console.log('✅ [LEGACY] Connected accounts fetched:', data);
+      
+      if (data.success && data.connectedAccounts && data.connectedAccounts.length > 0) {
+        return data.connectedAccounts;
+      }
+    }
+    
+    console.log('⚠️ [LEGACY] API response not successful or empty');
+    return [];
+    
+  } catch (error) {
+    console.log('❌ [LEGACY] Error fetching connected accounts by username:', error);
+    return [];
+  }
+};
+
+/**
+ * Get connected accounts by email
+ * @param email - Email to fetch connected accounts for
+ * @returns Promise<ConnectedAccount[]>
+ */
+export const getConnectedAccountsByEmail = async (email: string): Promise<ConnectedAccount[]> => {
+  try {
+    console.log('🔍 [LEGACY] Fetching connected accounts for email:', email);
+    
+    const token = await getAuthToken();
+    
+    const response = await fetch(`${API_BASE_URL}/connectedAccounts?email=${encodeURIComponent(email)}`, {
+      method: 'GET',
+      headers: token ? getAuthHeaders(token) : getApiHeaders()
+    });
+    
+    if (response.ok) {
+      const data: ConnectedAccountsResponse = await response.json();
+      console.log('✅ [LEGACY] Connected accounts fetched:', data);
+      
+      if (data.success && data.connectedAccounts && data.connectedAccounts.length > 0) {
+        return data.connectedAccounts;
+      }
+    }
+    
+    console.log('⚠️ [LEGACY] API response not successful or empty');
+    return [];
+    
+  } catch (error) {
+    console.log('❌ [LEGACY] Error fetching connected accounts by email:', error);
+    return [];
+  }
+};
+
+/**
+ * Get connected accounts by user ID
+ * @param userId - User ID to fetch connected accounts for
+ * @returns Promise<ConnectedAccount[]>
+ */
+export const getConnectedAccountsByUserId = async (userId: string): Promise<ConnectedAccount[]> => {
+  try {
+    console.log('🔍 [LEGACY] Fetching connected accounts for userId:', userId);
+    
+    const token = await getAuthToken();
+    
+    const response = await fetch(`${API_BASE_URL}/connectedAccounts?userId=${encodeURIComponent(userId)}`, {
+      method: 'GET',
+      headers: token ? getAuthHeaders(token) : getApiHeaders()
+    });
+    
+    if (response.ok) {
+      const data: ConnectedAccountsResponse = await response.json();
+      console.log('✅ [LEGACY] Connected accounts fetched:', data);
+      
+      if (data.success && data.connectedAccounts && data.connectedAccounts.length > 0) {
+        return data.connectedAccounts;
+      }
+    }
+    
+    console.log('⚠️ [LEGACY] API response not successful or empty');
+    return [];
+    
+  } catch (error) {
+    console.log('❌ [LEGACY] Error fetching connected accounts by userId:', error);
+    return [];
+  }
+};
+
+/**
+ * Get platform icon based on platform name
+ * @param platform - Platform name (case insensitive)
+ * @returns Image source for the platform icon
+ */
+export const getPlatformIcon = (platform: string) => {
+  const platformLower = platform.toLowerCase();
+  
+  switch (platformLower) {
+    case 'youtube':
+      return require('../assets/icons/YouTubeicon3.png');
+    case 'reddit':
+      return require('../assets/icons/Redditicon.png');
+    case 'linkedin':
+      return require('../assets/icons/Linkedinicon.png');
+    case 'instagram':
+      return require('../assets/icons/instagram.png');
+    case 'facebook':
+      return require('../assets/icons/Facebookicon.png');
+    case 'pinterest':
+      return require('../assets/icons/pinterest.png');
+    case 'gmail':
+    case 'email':
+      return require('../assets/icons/Gmail.png');
+    case 'twitter':
+    case 'x':
+      return require('../assets/icons/twitter.jpg');
+    case 'farcaster':
+      return require('../assets/icons/farcaster.png');
+    default:
+      return require('../assets/icons/swerv_logo.png'); // Default icon
+  }
+};
+
+/**
+ * Get platform color based on platform name
+ * @param platform - Platform name (case insensitive)
+ * @returns Hex color code for the platform
+ */
+export const getPlatformColor = (platform: string): string => {
+  const platformLower = platform.toLowerCase();
+  
+  switch (platformLower) {
+    case 'youtube':
+      return '#FF0000';
+    case 'reddit':
+      return '#FF4500';
+    case 'linkedin':
+      return '#0077B5';
+    case 'instagram':
+      return '#E1306C';
+    case 'facebook':
+      return '#1877F2';
+    case 'pinterest':
+      return '#E60023';
+    case 'gmail':
+    case 'email':
+      return '#EA4335';
+    case 'twitter':
+    case 'x':
+      return '#1DA1F2';
+    case 'farcaster':
+      return '#8A63D2';
+    default:
+      return '#666666'; // Default gray
+  }
+};