@onairos/react-native 3.0.49 → 3.0.51

package/src/services/platformAuthService.ts

@@ -1,5 +1,5 @@
 import { Platform, Linking } from 'react-native';
-import { DEEP_LINK_CONFIG } from '../constants';
+import AsyncStorage from '@react-native-async-storage/async-storage';
 
 // Define types for platform auth configuration
 interface PlatformAuthConfig {
@@ -7,20 +7,28 @@ interface PlatformAuthConfig {
   nativeSDKPackage?: string;
   authEndpoint: string;
   color: string;
+  clientId?: string;
+  redirectUri?: string;
+  scope?: string;
+  responseType?: string;
 }
 
 // Configuration for each platform's authentication
-const PLATFORM_AUTH_CONFIG: Record<string, PlatformAuthConfig> = {
+let PLATFORM_AUTH_CONFIG: Record<string, PlatformAuthConfig> = {
   instagram: {
     hasNativeSDK: false, // Instagram uses OAuth WebView flow
     authEndpoint: 'https://api2.onairos.uk/instagram/authorize',
     color: '#E1306C',
   },
   youtube: {
-    hasNativeSDK: false, // Native Google Sign-In SDK enabled
+    hasNativeSDK: true, // Native Google Sign-In SDK enabled
     nativeSDKPackage: '@react-native-google-signin/google-signin',
     authEndpoint: 'https://api2.onairos.uk/youtube/authorize',
     color: '#FF0000',
+    clientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com',
+    redirectUri: 'onairosevents://auth/callback',
+    scope: 'https://www.googleapis.com/auth/youtube.readonly',
+    responseType: 'code',
   },
   reddit: {
     hasNativeSDK: false,
@@ -197,68 +205,190 @@ export const initiateOAuth = async (platform: string, username: string, appName?
  * @param platform The platform to authenticate with
  * @returns A Promise that resolves to the authentication result
  */
-export const initiateNativeAuth = async (platform: string): Promise<boolean> => {
-  try {
-    // Currently only YouTube (Google Sign-In) is supported
-    if (platform === 'youtube') {
-      console.log('Initiating native Google Sign-In for YouTube');
+export const initiateNativeAuth = async (platform: string, username?: string): Promise<boolean> => {
+  if (platform === 'youtube') {
+    console.log('🔗 Initiating native Google Sign-In for YouTube');
+    try {
+      // Import Google Sign-In dynamically to avoid errors if not installed
+      const { GoogleSignin, statusCodes } = require('@react-native-google-signin/google-signin');
+      
+      // Configure Google Sign-In
+      await GoogleSignin.configure({
+        webClientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com', // Replace with your web client ID
+        iosClientId: '1030678346906-lovkuds2ouqmoc8eu5qpo98spa6edv4o.apps.googleusercontent.com', // Replace with your iOS client ID
+        scopes: ['https://www.googleapis.com/auth/youtube.readonly'],
+        offlineAccess: true, // CRITICAL: This ensures we get refresh tokens
+        hostedDomain: '',
+        forceCodeForRefreshToken: true, // CRITICAL: Force refresh token on first sign-in
+        accountName: '', // Clear to avoid conflicts
+      });
+      
+      // Check if Google Play Services are available
+      await GoogleSignin.hasPlayServices();
+      
+      // Sign in with Google
+      const userInfo = await GoogleSignin.signIn();
+      console.log('✅ Google Sign-In successful:', userInfo.user?.email);
+      
+      // Get access token for API calls
+      const tokens = await GoogleSignin.getTokens();
+      console.log('🔑 Got Google tokens');
       
+      // Get current user info with refresh token
+      const currentUser = await GoogleSignin.getCurrentUser();
+      console.log('👤 Current user info:', currentUser?.user?.email);
+      
+      // Extract refresh token from server auth code
+      let refreshToken = null;
+      if (currentUser?.serverAuthCode) {
+        console.log('🔄 Server auth code available for refresh token');
+        refreshToken = currentUser.serverAuthCode;
+      }
+      
+      if (!refreshToken) {
+        console.warn('⚠️ No refresh token available - token refresh may fail later');
+      } else {
+        console.log('✅ Refresh token available for YouTube connection');
+      }
+      
+      // Fetch YouTube channel information
+      let channelName = 'Unknown Channel';
+      let channelId = null;
       try {
-        // Import Google Sign-In dynamically to avoid errors if not installed
-        const { GoogleSignin, statusCodes } = require('@react-native-google-signin/google-signin');
-        
-        // Configure Google Sign-In
-        await GoogleSignin.configure({
-          scopes: [
-            'https://www.googleapis.com/auth/youtube.readonly',
-            'https://www.googleapis.com/auth/youtube.force-ssl'
-          ],
-          webClientId: 'YOUR_WEB_CLIENT_ID.apps.googleusercontent.com', // Replace with your Web Client ID from Google Cloud Console
-          iosClientId: 'YOUR_IOS_CLIENT_ID.apps.googleusercontent.com', // Replace with your iOS Client ID (iOS only)
-          offlineAccess: true,
-          hostedDomain: '',
-          forceCodeForRefreshToken: true,
+        console.log('📺 Fetching YouTube channel information...');
+        const channelResponse = await fetch('https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true', {
+          headers: {
+            'Authorization': `Bearer ${tokens.accessToken}`,
+            'Accept': 'application/json'
+          }
         });
         
-        // Check if device supports Google Play Services
-        await GoogleSignin.hasPlayServices();
-        
-        // Sign in
-        const userInfo = await GoogleSignin.signIn();
-        console.log('Google Sign-In successful:', userInfo);
-        
-        // Get access token
-        const tokens = await GoogleSignin.getTokens();
-        console.log('Google tokens:', tokens);
-        
-        // Here you would typically send the tokens to your backend
-        // to associate the YouTube account with the user
-        
-        return true;
-      } catch (error: any) {
-        console.error('Google Sign-In error:', error);
-        
-        const { statusCodes: StatusCodes } = require('@react-native-google-signin/google-signin');
-        
-        if (error.code === StatusCodes.SIGN_IN_CANCELLED) {
-          console.log('User cancelled the sign-in flow');
-        } else if (error.code === StatusCodes.IN_PROGRESS) {
-          console.log('Sign-in is in progress already');
-        } else if (error.code === StatusCodes.PLAY_SERVICES_NOT_AVAILABLE) {
-          console.log('Play services not available or outdated');
-        } else {
-          console.log('Some other error happened');
+        if (channelResponse.ok) {
+          const channelData = await channelResponse.json();
+          if (channelData.items && channelData.items.length > 0) {
+            channelName = channelData.items[0].snippet.title;
+            channelId = channelData.items[0].id;
+            console.log('✅ YouTube channel found:', channelName);
+          }
         }
+      } catch (channelError) {
+        console.log('⚠️ Error fetching YouTube channel info:', channelError);
+        channelName = userInfo.user?.name || userInfo.user?.email || 'Unknown Channel';
+      }
+      
+      // Get authentication info
+      let authToken = await AsyncStorage.getItem('onairos_jwt_token') || 
+                     await AsyncStorage.getItem('enoch_token') || 
+                     await AsyncStorage.getItem('auth_token');
+      const storedUsername = await AsyncStorage.getItem('onairos_username');
+      const finalUsername = storedUsername || username || userInfo.user?.email || 'youtube_user';
+      
+      // Create auth token if needed
+      if (!authToken || authToken.trim().length < 20) {
+        console.log('🔐 Creating authentication token for YouTube...');
         
+        try {
+          const fallbackEmail = userInfo.user?.email || `${finalUsername}@youtube.temp`;
+          
+          // Create user accounts and get JWT token
+          const onairosSignupResponse = await fetch('https://api2.onairos.uk/register/enoch', {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+              email: fallbackEmail,
+              username: finalUsername,
+              name: finalUsername
+            })
+          });
+          
+          if (onairosSignupResponse.ok) {
+            const onairosResponseData = await onairosSignupResponse.json();
+            
+            // Extract token from response
+            authToken = onairosResponseData.token || onairosResponseData.data?.token || onairosResponseData.jwt;
+            
+            if (authToken) {
+              // Store tokens
+              await AsyncStorage.setItem('onairos_jwt_token', authToken);
+              await AsyncStorage.setItem('enoch_token', authToken);
+              await AsyncStorage.setItem('auth_token', authToken);
+              await AsyncStorage.setItem('onairos_username', onairosResponseData.username || finalUsername);
+              
+              console.log('✅ Successfully created and stored authentication token');
+            }
+          }
+        } catch (tokenError) {
+          console.warn('⚠️ Error creating auth token:', tokenError);
+        }
+      }
+      
+      console.log('🔗 Linking YouTube data to user:', finalUsername);
+      console.log('📺 YouTube channel name:', channelName);
+      
+      // Send tokens to backend for YouTube data processing
+      const backendResponse = await fetch('https://api2.onairos.uk/youtube/native-auth', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          ...(authToken && { 'Authorization': `Bearer ${authToken}` })
+        },
+        body: JSON.stringify({
+          session: {
+            username: finalUsername,
+            platform: 'youtube',
+            timestamp: new Date().toISOString(),
+            channelName: channelName,
+            channelId: channelId
+          },
+          googleUser: userInfo.user,
+          accessToken: tokens.accessToken,
+          idToken: tokens.idToken,
+          refreshToken: refreshToken, // CRITICAL: Include refresh token
+          serverAuthCode: currentUser?.serverAuthCode,
+          userAccountInfo: {
+            username: finalUsername,
+            email: userInfo.user?.email,
+            authToken: authToken,
+            channelName: channelName,
+            channelId: channelId,
+            userIdentifier: authToken ? `user-${authToken.substring(0, 10)}` : `youtube-${userInfo.user?.email}`,
+            googleId: userInfo.user?.id,
+          },
+          tokenExpiry: new Date(Date.now() + 3600 * 1000).toISOString(), // 1 hour from now
+          requestRefreshToken: true
+        })
+      });
+      
+      if (backendResponse.ok) {
+        const responseData = await backendResponse.json();
+        console.log('✅ YouTube connection processed by backend:', responseData);
+        return true;
+      } else {
+        const errorData = await backendResponse.text();
+        console.error('❌ Backend processing failed:', backendResponse.status, errorData);
         return false;
       }
+      
+    } catch (error: any) {
+      console.error('❌ Google Sign-In error:', error);
+      
+      const { statusCodes: StatusCodes } = require('@react-native-google-signin/google-signin');
+      
+      if (error.code === StatusCodes.SIGN_IN_CANCELLED) {
+        console.log('User cancelled Google Sign-In');
+      } else if (error.code === StatusCodes.IN_PROGRESS) {
+        console.log('Google Sign-In already in progress');
+      } else if (error.code === StatusCodes.PLAY_SERVICES_NOT_AVAILABLE) {
+        console.log('Google Play Services not available');
+      }
+      
+      return false;
     }
-    
-    throw new Error(`Native authentication not supported for ${platform}`);
-  } catch (error) {
-    console.error(`Error initiating native auth for ${platform}:`, error);
-    throw error;
   }
+
+  return false;
 };
 
 /**
@@ -317,3 +447,345 @@ export const testApiConnectivity = async (): Promise<{ success: boolean; error?:
     return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
   }
 };
+
+/**
+ * 🔄 REFRESH GOOGLE TOKENS
+ */
+export const refreshGoogleTokens = async (): Promise<{ accessToken: string; idToken?: string } | null> => {
+  try {
+    console.log('🔄 Attempting to refresh Google tokens...');
+    
+    const { GoogleSignin } = require('@react-native-google-signin/google-signin');
+    
+    const currentUser = await GoogleSignin.getCurrentUser();
+    if (!currentUser) {
+      console.log('❌ User not signed in to Google, cannot refresh tokens');
+      return null;
+    }
+    
+    const tokens = await GoogleSignin.getTokens();
+    console.log('✅ Successfully refreshed Google tokens');
+    
+    return {
+      accessToken: tokens.accessToken,
+      idToken: tokens.idToken
+    };
+  } catch (error) {
+    console.error('❌ Failed to refresh Google tokens:', error);
+    
+    // If refresh fails, try to sign in again
+    try {
+      console.log('🔄 Refresh failed, attempting re-authentication...');
+      const { GoogleSignin } = require('@react-native-google-signin/google-signin');
+      const userInfo = await GoogleSignin.signIn();
+      const tokens = await GoogleSignin.getTokens();
+      
+      console.log('✅ Re-authentication successful');
+      return {
+        accessToken: tokens.accessToken,
+        idToken: tokens.idToken
+      };
+    } catch (signInError) {
+      console.error('❌ Re-authentication also failed:', signInError);
+      return null;
+    }
+  }
+};
+
+/**
+ * 🔄 REFRESH YOUTUBE TOKENS
+ */
+export const refreshYouTubeTokens = async (): Promise<boolean> => {
+  try {
+    console.log('🔄 Refreshing YouTube tokens...');
+    
+    // Get fresh tokens from Google SDK
+    const freshTokens = await refreshGoogleTokens();
+    if (!freshTokens) {
+      console.error('❌ Failed to get fresh tokens from Google SDK');
+      return false;
+    }
+    
+    // Get current user info
+    const { GoogleSignin } = require('@react-native-google-signin/google-signin');
+    const currentUser = await GoogleSignin.getCurrentUser();
+    if (!currentUser) {
+      console.error('❌ No current Google user found');
+      return false;
+    }
+    
+    // Get stored auth token
+    const authToken = await AsyncStorage.getItem('onairos_jwt_token') || 
+                     await AsyncStorage.getItem('enoch_token') || 
+                     await AsyncStorage.getItem('auth_token');
+    
+    if (!authToken) {
+      console.error('❌ No auth token found for YouTube refresh');
+      return false;
+    }
+    
+    // Send refreshed tokens to backend
+    const refreshResponse = await fetch('https://api2.onairos.uk/youtube/refresh-token', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${authToken}`
+      },
+      body: JSON.stringify({
+        accessToken: freshTokens.accessToken,
+        idToken: freshTokens.idToken,
+        refreshToken: currentUser.serverAuthCode,
+        userEmail: currentUser.user?.email,
+        tokenExpiry: new Date(Date.now() + 3600 * 1000).toISOString(),
+        timestamp: new Date().toISOString()
+      })
+    });
+    
+    if (refreshResponse.ok) {
+      const responseData = await refreshResponse.json();
+      console.log('✅ YouTube tokens refreshed successfully:', responseData);
+      return true;
+    } else {
+      const errorData = await refreshResponse.text();
+      console.error('❌ YouTube token refresh failed:', refreshResponse.status, errorData);
+      return false;
+    }
+  } catch (error) {
+    console.error('❌ Error refreshing YouTube tokens:', error);
+    return false;
+  }
+};
+
+/**
+ * 🎯 ENHANCED OAUTH CALLBACK HANDLER
+ */
+export const handleOAuthCallbackUrl = (url: string): { platform?: string; code?: string; success: boolean } => {
+  try {
+    console.log('🔍 Processing OAuth callback URL:', url);
+    
+    // Parse the URL
+    const parsedUrl = new URL(url);
+    
+    // Extract platform and code
+    const platform = parsedUrl.searchParams.get('platform') || 
+                    parsedUrl.pathname.split('/').find(segment => 
+                      ['instagram', 'youtube', 'reddit', 'pinterest', 'email'].includes(segment)
+                    );
+    
+    const code = parsedUrl.searchParams.get('code');
+    const error = parsedUrl.searchParams.get('error');
+    
+    if (error) {
+      console.error('❌ OAuth error in callback:', error);
+      return { success: false };
+    }
+    
+    if (code && platform) {
+      console.log(`✅ OAuth callback processed: ${platform} with code: ${code.substring(0, 10)}...`);
+      return { platform, code, success: true };
+    }
+    
+    console.warn('⚠️ OAuth callback missing platform or code');
+    return { success: false };
+  } catch (error) {
+    console.error('❌ Error processing OAuth callback:', error);
+    return { success: false };
+  }
+};
+
+/**
+ * 🔧 UPDATE GOOGLE CLIENT IDS
+ * Allows apps to configure their own Google client IDs
+ */
+export const updateGoogleClientIds = (config: {
+  webClientId?: string;
+  iosClientId?: string;
+}) => {
+  console.log('🔧 Updating Google client IDs configuration');
+  
+  if (config.webClientId || config.iosClientId) {
+    // Update the YouTube configuration
+    PLATFORM_AUTH_CONFIG.youtube = {
+      ...PLATFORM_AUTH_CONFIG.youtube,
+      clientId: config.webClientId || PLATFORM_AUTH_CONFIG.youtube.clientId,
+    };
+    
+    console.log('✅ Google client IDs updated successfully');
+  }
+};
+
+/**
+ * 📧 EMAIL VERIFICATION FUNCTIONS
+ * Using the correct Onairos email verification endpoints
+ */
+export const requestEmailVerification = async (email: string): Promise<{
+  success: boolean;
+  message?: string;
+  error?: string;
+}> => {
+  try {
+    console.log('📧 Requesting email verification for:', email);
+    
+    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');
+      console.log('🔍 Testing mode: Code logged to server console, but accepts any code');
+      return {
+        success: true,
+        message: result.message || 'Verification code sent to your email (testing mode: any code accepted)',
+      };
+    } else {
+      console.error('❌ Email verification request failed:', result.error);
+      return {
+        success: false,
+        error: result.error || 'Failed to send verification code',
+      };
+    }
+  } catch (error) {
+    console.error('❌ Email verification request error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Network error',
+    };
+  }
+};
+
+export const verifyEmailCode = async (email: string, code: string): Promise<{
+  success: boolean;
+  message?: string;
+  error?: string;
+}> => {
+  try {
+    console.log('🔍 Verifying email code for:', email);
+    
+    const response = await fetch('https://api2.onairos.uk/email/verify/confirm', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ email, code }),
+    });
+    
+    const result = await response.json();
+    
+    if (response.ok && result.success) {
+      console.log('✅ Email verification successful');
+      console.log('🔍 Testing mode: Any code accepted for verification');
+      return {
+        success: true,
+        message: result.message || 'Email verified successfully',
+      };
+    } else {
+      console.error('❌ Email verification failed:', result.error);
+      return {
+        success: false,
+        error: result.error || 'Invalid verification code',
+      };
+    }
+  } catch (error) {
+    console.error('❌ Email verification error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Network error',
+    };
+  }
+};
+
+export const checkEmailVerificationStatus = async (email: string): Promise<{
+  success: boolean;
+  isPending?: boolean;
+  message?: string;
+  error?: string;
+}> => {
+  try {
+    console.log('🔍 Checking email verification status for:', email);
+    
+    const response = await fetch(`https://api2.onairos.uk/email/verify/status/${encodeURIComponent(email)}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+    
+    const result = await response.json();
+    
+    if (response.ok) {
+      console.log('✅ Email verification status retrieved');
+      return {
+        success: true,
+        isPending: result.isPending || false,
+        message: result.message || 'Status retrieved successfully',
+      };
+    } else {
+      console.error('❌ Email verification status check failed:', result.error);
+      return {
+        success: false,
+        error: result.error || 'Failed to check verification status',
+      };
+    }
+  } catch (error) {
+    console.error('❌ Email verification status error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Network error',
+    };
+  }
+};
+
+/**
+ * 🔌 UNIVERSAL PLATFORM DISCONNECTION
+ * Backend confirmed this endpoint is fully implemented
+ */
+export const disconnectPlatform = async (platform: string, username: string): Promise<{
+  success: boolean;
+  message?: string;
+  error?: string;
+}> => {
+  try {
+    console.log(`🔌 Disconnecting ${platform} for user:`, username);
+    
+    const response = await fetch('https://api2.onairos.uk/revoke', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        Info: {
+          connection: platform.charAt(0).toUpperCase() + platform.slice(1), // Capitalize platform name
+          username: username,
+        },
+      }),
+    });
+    
+    const result = await response.json();
+    
+    if (response.ok && result.success) {
+      console.log(`✅ ${platform} disconnected successfully`);
+      return {
+        success: true,
+        message: result.message || `${platform} disconnected successfully`,
+      };
+    } else {
+      console.error(`❌ ${platform} disconnection failed:`, result.error);
+      return {
+        success: false,
+        error: result.error || `Failed to disconnect ${platform}`,
+      };
+    }
+  } catch (error) {
+    console.error(`❌ ${platform} disconnection error:`, error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Network error',
+    };
+  }
+};