@onairos/react-native 3.1.16 → 3.1.18

package/src/hooks/useConnectedAccounts.ts

@@ -1,139 +1,139 @@
-import { useState, useEffect, useCallback } from 'react';
-import { 
-  ConnectedAccount, 
-  getConnectedAccountsSmart,
-  // Keep legacy imports for any edge cases
-  getConnectedAccountsByUsername, 
-  getConnectedAccountsByEmail, 
-  getConnectedAccountsByUserId 
-} from '../services/connectedAccountsService';
-import { useAuth } from '../context/AuthContext';
-
-export interface UseConnectedAccountsReturn {
-  connectedAccounts: ConnectedAccount[];
-  isLoading: boolean;
-  error: string | null;
-  refreshAccounts: () => Promise<void>;
-  addAccount: (platform: string, username: string) => void;
-  removeAccount: (platform: string) => void;
-}
-
-export const useConnectedAccounts = (): UseConnectedAccountsReturn => {
-  const { user } = useAuth();
-  const [connectedAccounts, setConnectedAccounts] = useState<ConnectedAccount[]>([]);
-  const [isLoading, setIsLoading] = useState<boolean>(true);
-  const [error, setError] = useState<string | null>(null);
-
-  const fetchConnectedAccounts = useCallback(async () => {
-    if (!user) {
-      console.log('🔍 No user available for fetching connected accounts');
-      setIsLoading(false);
-      return;
-    }
-
-    try {
-      setIsLoading(true);
-      setError(null);
-      
-      console.log('🚀 [HOOK] Starting connected accounts fetch with new smart API...');
-      console.log('🚀 [HOOK] User info available:', {
-        email: user.email,
-        id: user.id,
-        name: user.name
-      });
-      
-      // Use the new smart API function - makes only ONE request with intelligent fallbacks
-      const accounts = await getConnectedAccountsSmart(
-        user.email,    // Primary identifier (email)
-        user.id,       // Secondary identifier (user ID)
-        user.name      // Tertiary identifier (username)
-      );
-      
-      console.log(`✅ [HOOK] Connected accounts loaded via smart API: ${accounts.length} accounts`);
-      setConnectedAccounts(accounts);
-      
-    } catch (err) {
-      console.error('❌ [HOOK] Error fetching connected accounts:', err);
-      setError('Failed to load connected accounts');
-    } finally {
-      setIsLoading(false);
-    }
-  }, [user]);
-
-  const refreshAccounts = useCallback(async () => {
-    console.log('🔄 [HOOK] Refreshing connected accounts...');
-    await fetchConnectedAccounts();
-  }, [fetchConnectedAccounts]);
-
-  const addAccount = useCallback((platform: string, username: string) => {
-    // Create a temporary URL for the account
-    const tempUrl = `https://${platform.toLowerCase()}.com/${username}`;
-    
-    const newAccount: ConnectedAccount = {
-      platform,
-      username,
-      url: tempUrl,
-    };
-    
-    setConnectedAccounts(prev => {
-      // Check if account already exists
-      const exists = prev.some(acc => 
-        acc.platform.toLowerCase() === platform.toLowerCase()
-      );
-      
-      if (exists) {
-        // Update existing account
-        return prev.map(acc => 
-          acc.platform.toLowerCase() === platform.toLowerCase() 
-            ? newAccount 
-            : acc
-        );
-      } else {
-        // Add new account
-        return [...prev, newAccount];
-      }
-    });
-    
-    console.log('✅ [HOOK] Account added locally:', newAccount);
-    
-    // TODO: In a real implementation, you would also send this to your backend
-    // Example:
-    // try {
-    //   await saveConnectedAccount(user.id, platform, username);
-    // } catch (error) {
-    //   console.error('Failed to save account to backend:', error);
-    //   // Optionally revert the local change
-    // }
-  }, []);
-
-  const removeAccount = useCallback((platform: string) => {
-    setConnectedAccounts(prev => 
-      prev.filter(acc => acc.platform.toLowerCase() !== platform.toLowerCase())
-    );
-    
-    console.log('✅ [HOOK] Account removed locally:', platform);
-    
-    // TODO: In a real implementation, you would also remove this from your backend
-    // Example:
-    // try {
-    //   await removeConnectedAccount(user.id, platform);
-    // } catch (error) {
-    //   console.error('Failed to remove account from backend:', error);
-    //   // Optionally revert the local change
-    // }
-  }, []);
-
-  // Fetch accounts when component mounts or user changes
-  useEffect(() => {
-    fetchConnectedAccounts();
-  }, [fetchConnectedAccounts]);
-
-  return {
-    connectedAccounts,
-    isLoading,
-    error,
-    refreshAccounts,
-    addAccount,
-    removeAccount,
-  };
+import { useState, useEffect, useCallback } from 'react';
+import { 
+  ConnectedAccount, 
+  getConnectedAccountsSmart,
+  // Keep legacy imports for any edge cases
+  getConnectedAccountsByUsername, 
+  getConnectedAccountsByEmail, 
+  getConnectedAccountsByUserId 
+} from '../services/connectedAccountsService';
+import { useAuth } from '../context/AuthContext';
+
+export interface UseConnectedAccountsReturn {
+  connectedAccounts: ConnectedAccount[];
+  isLoading: boolean;
+  error: string | null;
+  refreshAccounts: () => Promise<void>;
+  addAccount: (platform: string, username: string) => void;
+  removeAccount: (platform: string) => void;
+}
+
+export const useConnectedAccounts = (): UseConnectedAccountsReturn => {
+  const { user } = useAuth();
+  const [connectedAccounts, setConnectedAccounts] = useState<ConnectedAccount[]>([]);
+  const [isLoading, setIsLoading] = useState<boolean>(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchConnectedAccounts = useCallback(async () => {
+    if (!user) {
+      console.log('🔍 No user available for fetching connected accounts');
+      setIsLoading(false);
+      return;
+    }
+
+    try {
+      setIsLoading(true);
+      setError(null);
+      
+      console.log('🚀 [HOOK] Starting connected accounts fetch with new smart API...');
+      console.log('🚀 [HOOK] User info available:', {
+        email: user.email,
+        id: user.id,
+        name: user.name
+      });
+      
+      // Use the new smart API function - makes only ONE request with intelligent fallbacks
+      const accounts = await getConnectedAccountsSmart(
+        user.email,    // Primary identifier (email)
+        user.id,       // Secondary identifier (user ID)
+        user.name      // Tertiary identifier (username)
+      );
+      
+      console.log(`✅ [HOOK] Connected accounts loaded via smart API: ${accounts.length} accounts`);
+      setConnectedAccounts(accounts);
+      
+    } catch (err) {
+      console.error('❌ [HOOK] Error fetching connected accounts:', err);
+      setError('Failed to load connected accounts');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [user]);
+
+  const refreshAccounts = useCallback(async () => {
+    console.log('🔄 [HOOK] Refreshing connected accounts...');
+    await fetchConnectedAccounts();
+  }, [fetchConnectedAccounts]);
+
+  const addAccount = useCallback((platform: string, username: string) => {
+    // Create a temporary URL for the account
+    const tempUrl = `https://${platform.toLowerCase()}.com/${username}`;
+    
+    const newAccount: ConnectedAccount = {
+      platform,
+      username,
+      url: tempUrl,
+    };
+    
+    setConnectedAccounts(prev => {
+      // Check if account already exists
+      const exists = prev.some(acc => 
+        acc.platform.toLowerCase() === platform.toLowerCase()
+      );
+      
+      if (exists) {
+        // Update existing account
+        return prev.map(acc => 
+          acc.platform.toLowerCase() === platform.toLowerCase() 
+            ? newAccount 
+            : acc
+        );
+      } else {
+        // Add new account
+        return [...prev, newAccount];
+      }
+    });
+    
+    console.log('✅ [HOOK] Account added locally:', newAccount);
+    
+    // TODO: In a real implementation, you would also send this to your backend
+    // Example:
+    // try {
+    //   await saveConnectedAccount(user.id, platform, username);
+    // } catch (error) {
+    //   console.error('Failed to save account to backend:', error);
+    //   // Optionally revert the local change
+    // }
+  }, []);
+
+  const removeAccount = useCallback((platform: string) => {
+    setConnectedAccounts(prev => 
+      prev.filter(acc => acc.platform.toLowerCase() !== platform.toLowerCase())
+    );
+    
+    console.log('✅ [HOOK] Account removed locally:', platform);
+    
+    // TODO: In a real implementation, you would also remove this from your backend
+    // Example:
+    // try {
+    //   await removeConnectedAccount(user.id, platform);
+    // } catch (error) {
+    //   console.error('Failed to remove account from backend:', error);
+    //   // Optionally revert the local change
+    // }
+  }, []);
+
+  // Fetch accounts when component mounts or user changes
+  useEffect(() => {
+    fetchConnectedAccounts();
+  }, [fetchConnectedAccounts]);
+
+  return {
+    connectedAccounts,
+    isLoading,
+    error,
+    refreshAccounts,
+    addAccount,
+    removeAccount,
+  };
 }; 

package/src/hooks/useConnections.ts

@@ -1,161 +1,161 @@
-import { useState, useCallback } from 'react';
-import { initiateOAuth, initiateNativeAuth, exchangeCodeForToken } from '../services/platformAuthService';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { getOnairosUsername } from '../services/authService';
-
-export interface ConnectionStatus {
-  [key: string]: {
-    userName: string;
-    connected: boolean;
-  };
-}
-
-export const useConnections = () => {
-  const [connections, setConnections] = useState<ConnectionStatus>({});
-  const [isConnecting, setIsConnecting] = useState(false);
-
-  /**
-   * Connect a platform using OAuth or native SDK
-   */
-  const connectPlatform = useCallback(async (platform: string, username: string): Promise<boolean> => {
-    try {
-      setIsConnecting(true);
-
-      // Determine if we should use native SDK or OAuth
-      const useNativeSDK = platform === 'youtube' || platform === 'instagram';
-
-      let success = false;
-      
-      if (useNativeSDK) {
-        // Use native SDK
-        success = await initiateNativeAuth(platform, username);
-      } else {
-        // For demo purposes, we'll simulate a successful connection
-        await new Promise(resolve => setTimeout(() => resolve(undefined), 1000));
-        success = true;
-      }
-      
-      if (success) {
-        // Update connections state locally
-        setConnections(prev => ({
-          ...prev,
-          [platform]: { userName: username, connected: true }
-        }));
-        
-        // Update user account info via API
-        try {
-          const token = await AsyncStorage.getItem('auth_token');
-          // Get the stored Onairos username for API calls
-          const storedUsername = await getOnairosUsername();
-          const apiUsername = storedUsername || username;
-          
-          console.log(`🔗 Using username for ${platform} API call:`, {
-            providedUsername: username,
-            storedUsername,
-            finalApiUsername: apiUsername
-          });
-          
-          if (token) {
-            const response = await fetch('https://api2.onairos.uk/enoch/users/update', {
-              method: 'POST',
-              headers: {
-                'Content-Type': 'application/json',
-                'Authorization': token
-              },
-              body: JSON.stringify({
-                UpdateType: 'connection',
-                updateType: 'Add',
-                connection: platform,
-                username: apiUsername // Use stored Onairos username
-              })
-            });
-            
-            console.log(`Platform connection update response for ${platform}:`, response.status);
-          }
-        } catch (apiError) {
-          console.warn(`Error updating user connections for ${platform}, but continuing:`, apiError);
-          // Continue even if the API call fails
-        }
-        
-        return true;
-      }
-      
-      return false;
-    } catch (error) {
-      console.error(`Error connecting platform ${platform}:`, error);
-      return false;
-    } finally {
-      setIsConnecting(false);
-    }
-  }, []);
-
-  /**
-   * Disconnect a platform
-   */
-  const disconnectPlatform = useCallback(async (platform: string, username?: string): Promise<boolean> => {
-    try {
-      // Update local state
-      setConnections(prev => {
-        const newConnections = { ...prev };
-        delete newConnections[platform];
-        return newConnections;
-      });
-      
-      // Update user account info via API
-      try {
-        const token = await AsyncStorage.getItem('auth_token');
-        // Get the stored Onairos username for API calls
-        const storedUsername = await getOnairosUsername();
-        const apiUsername = storedUsername || username || 'user';
-        
-        console.log(`🔗 Using username for ${platform} disconnect API call:`, {
-          providedUsername: username,
-          storedUsername,
-          finalApiUsername: apiUsername
-        });
-        
-        if (token) {
-          const response = await fetch('https://api2.onairos.uk/enoch/users/update', {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'Authorization': token
-            },
-            body: JSON.stringify({
-              UpdateType: 'connection',
-              updateType: 'Remove',
-              connection: platform,
-              username: apiUsername // Use stored Onairos username
-            })
-          });
-          
-          console.log(`Platform disconnection update response for ${platform}:`, response.status);
-        }
-      } catch (apiError) {
-        console.warn(`Error updating user connections for ${platform}, but continuing:`, apiError);
-        // Continue even if the API call fails
-      }
-      
-      return true;
-    } catch (error) {
-      console.error(`Error disconnecting platform ${platform}:`, error);
-      return false;
-    }
-  }, []);
-
-  /**
-   * Get current connection status
-   */
-  const getConnectionStatus = useCallback(async (): Promise<ConnectionStatus> => {
-    // In a real app, you might fetch this from storage or API
-    return connections;
-  }, [connections]);
-
-  return {
-    connections,
-    connectPlatform,
-    disconnectPlatform,
-    getConnectionStatus,
-    isConnecting
-  };
-};
+import { useState, useCallback } from 'react';
+import { initiateOAuth, initiateNativeAuth, exchangeCodeForToken } from '../services/platformAuthService';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { getOnairosUsername } from '../services/authService';
+
+export interface ConnectionStatus {
+  [key: string]: {
+    userName: string;
+    connected: boolean;
+  };
+}
+
+export const useConnections = () => {
+  const [connections, setConnections] = useState<ConnectionStatus>({});
+  const [isConnecting, setIsConnecting] = useState(false);
+
+  /**
+   * Connect a platform using OAuth or native SDK
+   */
+  const connectPlatform = useCallback(async (platform: string, username: string): Promise<boolean> => {
+    try {
+      setIsConnecting(true);
+
+      // Determine if we should use native SDK or OAuth
+      const useNativeSDK = platform === 'youtube' || platform === 'instagram';
+
+      let success = false;
+      
+      if (useNativeSDK) {
+        // Use native SDK
+        success = await initiateNativeAuth(platform, username);
+      } else {
+        // For demo purposes, we'll simulate a successful connection
+        await new Promise(resolve => setTimeout(() => resolve(undefined), 1000));
+        success = true;
+      }
+      
+      if (success) {
+        // Update connections state locally
+        setConnections(prev => ({
+          ...prev,
+          [platform]: { userName: username, connected: true }
+        }));
+        
+        // Update user account info via API
+        try {
+          const token = await AsyncStorage.getItem('auth_token');
+          // Get the stored Onairos username for API calls
+          const storedUsername = await getOnairosUsername();
+          const apiUsername = storedUsername || username;
+          
+          console.log(`🔗 Using username for ${platform} API call:`, {
+            providedUsername: username,
+            storedUsername,
+            finalApiUsername: apiUsername
+          });
+          
+          if (token) {
+            const response = await fetch('https://api2.onairos.uk/enoch/users/update', {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'Authorization': token
+              },
+              body: JSON.stringify({
+                UpdateType: 'connection',
+                updateType: 'Add',
+                connection: platform,
+                username: apiUsername // Use stored Onairos username
+              })
+            });
+            
+            console.log(`Platform connection update response for ${platform}:`, response.status);
+          }
+        } catch (apiError) {
+          console.warn(`Error updating user connections for ${platform}, but continuing:`, apiError);
+          // Continue even if the API call fails
+        }
+        
+        return true;
+      }
+      
+      return false;
+    } catch (error) {
+      console.error(`Error connecting platform ${platform}:`, error);
+      return false;
+    } finally {
+      setIsConnecting(false);
+    }
+  }, []);
+
+  /**
+   * Disconnect a platform
+   */
+  const disconnectPlatform = useCallback(async (platform: string, username?: string): Promise<boolean> => {
+    try {
+      // Update local state
+      setConnections(prev => {
+        const newConnections = { ...prev };
+        delete newConnections[platform];
+        return newConnections;
+      });
+      
+      // Update user account info via API
+      try {
+        const token = await AsyncStorage.getItem('auth_token');
+        // Get the stored Onairos username for API calls
+        const storedUsername = await getOnairosUsername();
+        const apiUsername = storedUsername || username || 'user';
+        
+        console.log(`🔗 Using username for ${platform} disconnect API call:`, {
+          providedUsername: username,
+          storedUsername,
+          finalApiUsername: apiUsername
+        });
+        
+        if (token) {
+          const response = await fetch('https://api2.onairos.uk/enoch/users/update', {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Authorization': token
+            },
+            body: JSON.stringify({
+              UpdateType: 'connection',
+              updateType: 'Remove',
+              connection: platform,
+              username: apiUsername // Use stored Onairos username
+            })
+          });
+          
+          console.log(`Platform disconnection update response for ${platform}:`, response.status);
+        }
+      } catch (apiError) {
+        console.warn(`Error updating user connections for ${platform}, but continuing:`, apiError);
+        // Continue even if the API call fails
+      }
+      
+      return true;
+    } catch (error) {
+      console.error(`Error disconnecting platform ${platform}:`, error);
+      return false;
+    }
+  }, []);
+
+  /**
+   * Get current connection status
+   */
+  const getConnectionStatus = useCallback(async (): Promise<ConnectionStatus> => {
+    // In a real app, you might fetch this from storage or API
+    return connections;
+  }, [connections]);
+
+  return {
+    connections,
+    connectPlatform,
+    disconnectPlatform,
+    getConnectionStatus,
+    isConnecting
+  };
+};