@onairos/react-native 3.0.71 → 3.0.73

package/lib/module/services/platformAuthService.js

@@ -1,20 +1,64 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { makeAuthenticatedRequest } from './apiKeyService';
 
-// Define types for platform auth configuration
+// 🔑 CRITICAL: Initialize API key service for authentication
+let isApiKeyInitialized = false;
+
+/**
+ * Initialize the API key service with the admin key for testing
+ * This ensures all API requests include proper authentication headers
+ */
+export const initializePlatformAuthService = async () => {
+  if (isApiKeyInitialized) {
+    console.log('🔑 API key service already initialized');
+    return;
+  }
+  try {
+    // Import the initialization function
+    const {
+      initializeApiKey,
+      ADMIN_API_KEY
+    } = await import('./apiKeyService');
+
+    // Initialize with admin key for testing/development
+    await initializeApiKey({
+      apiKey: ADMIN_API_KEY,
+      // 'OnairosIsAUnicorn2025'
+      environment: 'development',
+      enableLogging: true,
+      timeout: 30000
+    });
+    isApiKeyInitialized = true;
+    console.log('✅ Platform auth service initialized with admin key');
+  } catch (error) {
+    console.error('❌ Failed to initialize platform auth service:', error);
+    throw error;
+  }
+};
+
+/**
+ * Ensure API key is initialized before making authenticated requests
+ */
+const ensureApiKeyInitialized = async () => {
+  if (!isApiKeyInitialized) {
+    console.log('🔑 API key not initialized, initializing now...');
+    await initializePlatformAuthService();
+  }
+};
 
 // Configuration for each platform's authentication
 let PLATFORM_AUTH_CONFIG = {
   instagram: {
     hasNativeSDK: false,
     // Instagram uses OAuth WebView flow
-    authEndpoint: 'https://api2.onairos.uk/instagram/authorize',
+    authEndpoint: '/instagram/authorize',
     color: '#E1306C'
   },
   youtube: {
     hasNativeSDK: true,
     // Native Google Sign-In SDK enabled
     nativeSDKPackage: '@react-native-google-signin/google-signin',
-    authEndpoint: 'https://api2.onairos.uk/youtube/authorize',
+    authEndpoint: '/youtube/authorize',
     color: '#FF0000',
     clientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com',
     redirectUri: 'onairosevents://auth/callback',
@@ -23,17 +67,17 @@ let PLATFORM_AUTH_CONFIG = {
   },
   reddit: {
     hasNativeSDK: false,
-    authEndpoint: 'https://api2.onairos.uk/reddit/authorize',
+    authEndpoint: '/reddit/authorize',
     color: '#FF4500'
   },
   pinterest: {
     hasNativeSDK: false,
-    authEndpoint: 'https://api2.onairos.uk/pinterest/authorize',
+    authEndpoint: '/pinterest/authorize',
     color: '#E60023'
   },
   email: {
     hasNativeSDK: false,
-    authEndpoint: 'https://api2.onairos.uk/gmail/authorize',
+    authEndpoint: '/gmail/authorize',
     color: '#4285F4'
   }
 };
@@ -109,30 +153,11 @@ export const initiateOAuth = async (platform, username, appName) => {
         }
       };
       console.log('📤 Sending Instagram OAuth request:', jsonData);
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
-
-      let response;
-      try {
-        response = await fetch('https://api2.onairos.uk/instagram/authorize', {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'User-Agent': 'OnairosReactNative/1.0'
-          },
-          body: JSON.stringify(jsonData),
-          signal: controller.signal
-        });
-      } catch (fetchError) {
-        clearTimeout(timeoutId);
-        if (fetchError.name === 'AbortError') {
-          throw new Error(`Request timeout: Instagram OAuth server took too long to respond`);
-        }
-        throw new Error(`Network error: ${fetchError.message || 'Failed to connect to Instagram OAuth server'}`);
-      }
-      clearTimeout(timeoutId);
+      const response = await makeAuthenticatedRequest(PLATFORM_AUTH_CONFIG[platform].authEndpoint, {
+        method: 'POST',
+        body: JSON.stringify(jsonData)
+      });
       console.log('📡 Instagram OAuth response status:', response.status);
-      console.log('📡 Instagram OAuth response headers:', response.headers);
       if (!response.ok) {
         const errorText = await response.text();
         console.error('❌ Instagram OAuth API error:', errorText);
@@ -165,31 +190,12 @@ export const initiateOAuth = async (platform, username, appName) => {
     };
     console.log(`📤 Sending ${platform} OAuth request:`, jsonData);
 
-    // Make the request to get the OAuth URL with enhanced error handling
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), 30000); // 30 second timeout
-
-    let response;
-    try {
-      response = await fetch(PLATFORM_AUTH_CONFIG[platform].authEndpoint, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'User-Agent': 'OnairosReactNative/1.0'
-        },
-        body: JSON.stringify(jsonData),
-        signal: controller.signal
-      });
-    } catch (fetchError) {
-      clearTimeout(timeoutId);
-      if (fetchError.name === 'AbortError') {
-        throw new Error(`Request timeout: ${platform} OAuth server took too long to respond`);
-      }
-      throw new Error(`Network error: ${fetchError.message || 'Failed to connect to OAuth server'}`);
-    }
-    clearTimeout(timeoutId);
+    // Make the authenticated request to get the OAuth URL
+    const response = await makeAuthenticatedRequest(PLATFORM_AUTH_CONFIG[platform].authEndpoint, {
+      method: 'POST',
+      body: JSON.stringify(jsonData)
+    });
     console.log(`📡 ${platform} OAuth response status:`, response.status);
-    console.log(`📡 ${platform} OAuth response headers:`, response.headers);
     if (!response.ok) {
       const errorText = await response.text();
       console.error(`❌ ${platform} OAuth API error:`, errorText);
@@ -792,91 +798,159 @@ export const updateGoogleClientIds = config => {
 export const requestEmailVerification = async (email, testMode = false) => {
   try {
     console.log('📧 Requesting email verification for:', email);
-    console.log('🔍 Test mode:', testMode);
+    console.log('🧪 Test mode:', testMode);
+    if (!email || !email.includes('@')) {
+      return {
+        success: false,
+        error: 'Valid email address is required'
+      };
+    }
 
-    // Use the correct endpoint: /email/verify
-    const response = await fetch('https://api2.onairos.uk/email/verify', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify({
-        email
-      })
-    });
-    const result = await response.json();
-    if (response.ok && result.success) {
-      console.log('✅ Email verification requested successfully');
-      const message = testMode ? 'Verification code sent to your email (testing mode: any code accepted)' : result.message || 'Verification code sent to your email';
+    // In test mode, always return success with mock request ID
+    if (testMode) {
+      console.log('🧪 Test mode: Always returning success with mock request ID');
+      const mockRequestId = 'test-request-' + Date.now();
+
+      // Store request info for tracking
+      await AsyncStorage.setItem('email_verification_request_id', mockRequestId);
+      await AsyncStorage.setItem('email_verification_request_email', email);
       return {
         success: true,
-        message
+        message: 'Email verification sent successfully (test mode)',
+        requestId: mockRequestId
       };
-    } else {
-      console.error('❌ Email verification request failed:', result.error);
+    }
+
+    // Production mode: Make real API call with API key authentication
+    try {
+      // 🔑 Ensure API key is initialized before making authenticated requests
+      await ensureApiKeyInitialized();
+      const response = await makeAuthenticatedRequest('/email/verification', {
+        method: 'POST',
+        body: JSON.stringify({
+          email,
+          action: 'request'
+        })
+      });
+      const result = await response.json();
+      console.log('📡 Email verification API response:', result);
+      if (response.ok && result.success) {
+        console.log('✅ Email verification request sent');
+
+        // Store request info for tracking
+        const requestId = result.requestId || result.id || 'req-' + Date.now();
+        await AsyncStorage.setItem('email_verification_request_id', requestId);
+        await AsyncStorage.setItem('email_verification_request_email', email);
+        return {
+          success: true,
+          message: result.message || 'Email verification sent successfully',
+          requestId: requestId
+        };
+      } else {
+        console.error('❌ Email verification request failed:', result.error);
+        return {
+          success: false,
+          error: result.error || 'Failed to send verification email'
+        };
+      }
+    } catch (apiError) {
+      console.error('❌ Email verification API call failed:', apiError);
       return {
         success: false,
-        error: result.error || 'Failed to send verification code'
+        error: 'Network error while sending verification email'
       };
     }
   } catch (error) {
     console.error('❌ Email verification request error:', error);
     return {
       success: false,
-      error: error instanceof Error ? error.message : 'Network error'
+      error: error instanceof Error ? error.message : 'Unknown error'
     };
   }
 };
 export const verifyEmailCode = async (email, code, testMode = false) => {
   try {
     console.log('🔍 Verifying email code for:', email);
-    console.log('🔍 Test mode:', testMode);
+    console.log('🔑 Code length:', code.length);
+    console.log('🧪 Test mode:', testMode);
+    if (!email || !email.includes('@')) {
+      return {
+        success: false,
+        error: 'Valid email address is required'
+      };
+    }
+    if (!code || code.length < 4) {
+      return {
+        success: false,
+        error: 'Valid verification code is required'
+      };
+    }
 
-    // In test mode, accept any code
+    // In test mode, always return success with mock JWT token
     if (testMode) {
-      console.log('🧪 Test mode: All codes will pass through');
-      // Simulate 30% chance of existing user in test mode
-      const simulateExistingUser = Math.random() < 0.3;
+      console.log('🧪 Test mode: Always returning success with mock JWT token');
+      const mockToken = 'test-jwt-token-' + Date.now();
+
+      // Store mock token for API requests
+      await AsyncStorage.setItem('email_verification_token', mockToken);
+      await AsyncStorage.setItem('onairos_jwt_token', mockToken);
+      await AsyncStorage.setItem('email_verification_email', email);
       return {
         success: true,
-        message: 'Email verified successfully (test mode: all codes accepted)',
-        existingUser: simulateExistingUser
+        message: 'Email verification successful (test mode)',
+        existingUser: false,
+        jwtToken: mockToken
       };
     }
 
-    // Production mode: Make real API call with proper validation
+    // Production mode: Make real API call with API key authentication
     try {
-      const response = await fetch('https://api2.onairos.uk/email/verify/confirm', {
+      // 🔑 Ensure API key is initialized before making authenticated requests
+      await ensureApiKeyInitialized();
+      const response = await makeAuthenticatedRequest('/email/verification', {
         method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
         body: JSON.stringify({
           email,
-          code
+          code,
+          action: 'verify'
         })
       });
       const result = await response.json();
       console.log('📡 Email verification API response:', result);
       if (response.ok && result.success) {
         console.log('✅ Email verification successful');
+
+        // 🎫 CRITICAL: Store JWT token from email verification response
+        const jwtToken = result.token || result.jwtToken || result.jwt || result.authToken;
+        if (jwtToken) {
+          console.log('🎫 Storing JWT token from email verification response');
+          await AsyncStorage.setItem('email_verification_token', jwtToken);
+          await AsyncStorage.setItem('onairos_jwt_token', jwtToken);
+          await AsyncStorage.setItem('enoch_token', jwtToken);
+          await AsyncStorage.setItem('auth_token', jwtToken);
+          await AsyncStorage.setItem('email_verification_email', email);
+          await AsyncStorage.setItem('token_timestamp', Date.now().toString());
+        } else {
+          console.warn('⚠️ No JWT token received from email verification API');
+        }
         return {
           success: true,
-          message: result.message || 'Email verified successfully',
-          existingUser: result.existingUser || false // Backend should return this flag
+          message: result.message || 'Email verification successful',
+          existingUser: result.existingUser || false,
+          jwtToken: jwtToken
         };
       } else {
         console.error('❌ Email verification failed:', result.error);
         return {
           success: false,
-          error: result.error || 'Invalid verification code'
+          error: result.error || 'Email verification failed'
         };
       }
     } catch (apiError) {
       console.error('❌ Email verification API call failed:', apiError);
       return {
         success: false,
-        error: 'Network error during verification'
+        error: 'Network error during email verification'
       };
     }
   } catch (error) {
@@ -902,13 +976,12 @@ export const checkEmailVerificationStatus = async (email, testMode = false) => {
       };
     }
 
-    // Production mode: Make real API call
+    // Production mode: Make real API call with API key authentication
     try {
-      const response = await fetch(`https://api2.onairos.uk/email/verify/status/${encodeURIComponent(email)}`, {
-        method: 'GET',
-        headers: {
-          'Content-Type': 'application/json'
-        }
+      // 🔑 Ensure API key is initialized before making authenticated requests
+      await ensureApiKeyInitialized();
+      const response = await makeAuthenticatedRequest(`/email/verify/status/${encodeURIComponent(email)}`, {
+        method: 'GET'
       });
       const result = await response.json();
       console.log('📡 Email verification status API response:', result);
@@ -948,40 +1021,167 @@ export const checkEmailVerificationStatus = async (email, testMode = false) => {
  */
 export const disconnectPlatform = async (platform, username) => {
   try {
-    console.log(`🔌 Disconnecting ${platform} for user:`, username);
-    const response = await fetch('https://api2.onairos.uk/revoke', {
+    console.log('🔌 Disconnecting platform:', platform, 'for user:', username);
+    if (!platform || !username) {
+      return {
+        success: false,
+        error: 'Platform and username are required'
+      };
+    }
+
+    // Make authenticated API call to disconnect platform
+    const response = await makeAuthenticatedRequest('/revoke', {
+      method: 'POST',
+      body: JSON.stringify({
+        platform,
+        username
+      })
+    });
+    const result = await response.json();
+    console.log('📡 Platform disconnect API response:', result);
+    if (response.ok && result.success) {
+      console.log('✅ Platform disconnected successfully');
+      return {
+        success: true,
+        message: result.message || 'Platform disconnected successfully'
+      };
+    } else {
+      console.error('❌ Platform disconnect failed:', result.error);
+      return {
+        success: false,
+        error: result.error || 'Failed to disconnect platform'
+      };
+    }
+  } catch (error) {
+    console.error('❌ Platform disconnect error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Platform disconnect failed'
+    };
+  }
+};
+
+/**
+ * 🔐 STORE PIN AFTER BIOMETRIC AUTHENTICATION
+ * Send PIN separately to /store-pin/web endpoint after biometric Face ID verification
+ */
+export const storePinAfterBiometric = async (username, pin, jwtToken) => {
+  try {
+    console.log('🔐 Storing PIN after biometric authentication for user:', username);
+    console.log('🔑 PIN length:', pin.length);
+    console.log('🎫 JWT token provided:', !!jwtToken);
+    if (!username || !pin) {
+      return {
+        success: false,
+        error: 'Username and PIN are required'
+      };
+    }
+    if (pin.length < 4) {
+      return {
+        success: false,
+        error: 'PIN must be at least 4 digits'
+      };
+    }
+
+    // Get JWT token from storage if not provided
+    let authToken = jwtToken;
+    if (!authToken) {
+      authToken = (await AsyncStorage.getItem('onairos_jwt_token')) || (await AsyncStorage.getItem('enoch_token')) || (await AsyncStorage.getItem('auth_token')) || (await AsyncStorage.getItem('email_verification_token'));
+    }
+    if (!authToken) {
+      console.warn('⚠️ No JWT token available for PIN storage');
+      return {
+        success: false,
+        error: 'No authentication token available'
+      };
+    }
+    console.log('📤 Sending PIN to /store-pin/web endpoint');
+
+    // Make authenticated request to store PIN
+    const response = await makeAuthenticatedRequest('/store-pin/web', {
       method: 'POST',
       headers: {
-        'Content-Type': 'application/json'
+        'Authorization': `Bearer ${authToken}`
       },
       body: JSON.stringify({
-        Info: {
-          connection: platform.charAt(0).toUpperCase() + platform.slice(1),
-          // Capitalize platform name
-          username: username
-        }
+        username,
+        pin
       })
     });
+    console.log('📡 PIN storage response status:', response.status);
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error('❌ PIN storage failed:', errorText);
+      return {
+        success: false,
+        error: `PIN storage failed: ${response.status} - ${errorText}`
+      };
+    }
     const result = await response.json();
-    if (response.ok && result.success) {
-      console.log(`✅ ${platform} disconnected successfully`);
+    console.log('📥 PIN storage response:', result);
+    if (result.success) {
+      console.log('✅ PIN stored successfully after biometric authentication');
+
+      // Store PIN locally for future use
+      await AsyncStorage.setItem('user_pin_stored', 'true');
+      await AsyncStorage.setItem('pin_storage_timestamp', Date.now().toString());
       return {
         success: true,
-        message: result.message || `${platform} disconnected successfully`
+        message: result.message || 'PIN stored successfully'
       };
     } else {
-      console.error(`❌ ${platform} disconnection failed:`, result.error);
+      console.error('❌ PIN storage API returned error:', result.error);
       return {
         success: false,
-        error: result.error || `Failed to disconnect ${platform}`
+        error: result.error || 'PIN storage failed'
       };
     }
   } catch (error) {
-    console.error(`❌ ${platform} disconnection error:`, error);
+    console.error('❌ Error storing PIN after biometric authentication:', error);
     return {
       success: false,
-      error: error instanceof Error ? error.message : 'Network error'
+      error: error instanceof Error ? error.message : 'PIN storage failed'
     };
   }
 };
+
+/**
+ * 🎫 GET STORED JWT TOKEN
+ * Helper function to retrieve stored JWT token from email verification or other sources
+ */
+export const getStoredJwtToken = async () => {
+  try {
+    console.log('🎫 Retrieving stored JWT token...');
+
+    // Try different storage keys in order of preference
+    const tokenSources = ['email_verification_token', 'onairos_jwt_token', 'enoch_token', 'auth_token'];
+    for (const source of tokenSources) {
+      const token = await AsyncStorage.getItem(source);
+      if (token && token.length > 20) {
+        console.log(`✅ JWT token found in ${source}:`, token.substring(0, 20) + '...');
+        return token;
+      }
+    }
+    console.warn('⚠️ No JWT token found in storage');
+    return null;
+  } catch (error) {
+    console.error('❌ Error retrieving JWT token:', error);
+    return null;
+  }
+};
+
+/**
+ * 🎫 CLEAR STORED TOKENS
+ * Helper function to clear all stored tokens (useful for logout)
+ */
+export const clearStoredTokens = async () => {
+  try {
+    console.log('🧹 Clearing all stored tokens...');
+    const tokenKeys = ['email_verification_token', 'onairos_jwt_token', 'enoch_token', 'auth_token', 'email_verification_email', 'email_verification_request_id', 'email_verification_request_email', 'token_timestamp', 'user_pin_stored', 'pin_storage_timestamp'];
+    await Promise.all(tokenKeys.map(key => AsyncStorage.removeItem(key)));
+    console.log('✅ All tokens cleared successfully');
+  } catch (error) {
+    console.error('❌ Error clearing tokens:', error);
+  }
+};
 //# sourceMappingURL=platformAuthService.js.map