@onairos/react-native 3.1.18 → 3.2.1

package/src/services/userConnectionsService.ts

@@ -1,557 +0,0 @@
-import { getAuthToken, getUserProfile, ensureAuthentication } from './authService';
-import AsyncStorage from '@react-native-async-storage/async-storage';
-import { compressProfilePicture } from './imageCompressionService';
-import { API_CONFIG, getApiHeaders, getAuthHeaders } from '../config/api';
-
-/**
- * Get user identifier (ID or username) using multiple fallback methods
- * Backend now supports both user IDs and usernames for profile picture uploads
- * @returns Promise<string | null>
- */
-const getUserIdWithFallbacks = async (): Promise<string | null> => {
-  try {
-    console.log('🔍 [USER ID] Attempting to get user identifier with multiple methods...');
-    
-    // Method 1: Try getUserProfile first
-    try {
-      const userProfile = await getUserProfile();
-      if (userProfile?.id && userProfile.id !== 'fallback_user') {
-        console.log('✅ [USER ID] Got user ID from getUserProfile:', userProfile.id);
-        return userProfile.id;
-      } else {
-        console.warn('⚠️ [USER ID] getUserProfile returned invalid/fallback ID:', userProfile?.id);
-      }
-    } catch (error) {
-      console.warn('⚠️ [USER ID] getUserProfile failed:', error);
-    }
-    
-    // Method 2: Check AsyncStorage for stored user ID (but validate it)
-    const storedUserId = await AsyncStorage.getItem('user_id');
-    if (storedUserId && storedUserId !== 'marker' && storedUserId !== 'fallback_user' && storedUserId.length > 10) {
-      console.log('✅ [USER ID] Got user ID from AsyncStorage:', storedUserId);
-      return storedUserId;
-    } else if (storedUserId) {
-      console.warn('⚠️ [USER ID] Invalid stored user ID found:', storedUserId);
-    }
-    
-    // Method 3: Try stored username (backend now supports usernames!)
-    const storedUsername = await AsyncStorage.getItem('onairos_username');
-    if (storedUsername && storedUsername.length > 2 && storedUsername !== 'marker') {
-      console.log('✅ [USER ID] Got username from AsyncStorage (backend supports usernames):', storedUsername);
-      return storedUsername;
-    } else if (storedUsername) {
-      console.warn('⚠️ [USER ID] Invalid stored username found:', storedUsername);
-    }
-    
-    // Method 4: Try stored email as username fallback
-    const storedEmail = await AsyncStorage.getItem('user_email');
-    if (storedEmail && storedEmail.includes('@') && storedEmail.length > 5) {
-      console.log('✅ [USER ID] Got email from AsyncStorage (backend supports usernames):', storedEmail);
-      return storedEmail;
-    } else if (storedEmail) {
-      console.warn('⚠️ [USER ID] Invalid stored email found:', storedEmail);
-    }
-    
-    // Method 5: Check JWT token for user info (but don't decode, just log)
-    try {
-      const token = await getAuthToken();
-      if (token && token.split('.').length === 3) {
-        console.log('🔍 [USER ID] JWT token found but no local user identifier - backend should handle via token');
-        // Don't try to decode JWT here - let the backend handle it
-      }
-    } catch (error) {
-      console.warn('⚠️ [USER ID] JWT token access failed:', error);
-    }
-    
-    console.error('❌ [USER ID] No valid user identifier found');
-    return null;
-    
-  } catch (error) {
-    console.error('❌ [USER ID] Error getting user identifier:', error);
-    return null;
-  }
-};
-
-// Import images for fallback connections
-const samImage = require('../assets/images/persona1.png');
-const anandImage = require('../assets/images/persona2.png');
-const chrisImage = require('../assets/images/persona3.png');
-const katieImage = require('../assets/images/persona4.png');
-const yanniImage = require('../assets/images/persona5.png');
-
-const API_BASE_URL = API_CONFIG.BASE_URL;
-
-// Interface for API connection response - updated to match actual backend format
-export interface APIConnection {
-  id: string;
-  name: string;
-  description: string;
-  photo: string;
-  bio: string;
-  interests: string[];
-  mutualConnections: number;
-  compatibility: number;
-  conversationStarters: string[];
-  // UI REQUIRED FIELDS - These are actually rendered in ProfileDetailScreen
-  sharedPassions?: string[];
-  complementaryQualities?: string[];
-  meaningfulCoincidences?: Array<{
-    type: string;
-    description: string;
-    rarity: string;
-  }>;
-  mutualConnectionsList?: Array<{
-    name: string;
-    photo: string;
-    context: string;
-  }>;
-  // Optional metadata fields
-  status?: string;
-  connectionType?: string;
-  similarityScore?: number;
-  commonPreferences?: string[];
-  eventCode?: string;
-  matchedAt?: string;
-  _id?: string;
-}
-
-// Interface for API response
-export interface UserConnectionsResponse {
-  success: boolean;
-  connections: APIConnection[];
-  source: 'database' | 'samples';
-  count: number;
-}
-
-// Interface for the transformed connection used by UI
-export interface Connection {
-  id: number;
-  name: string;
-  description: string;
-  photo: any; // Image source (can be URL string or require() object)
-  bio: string;
-  interests: string[];
-  mutualConnections: number;
-  compatibility: number;
-  conversationStarters: string[];
-  sharedPassions: string[];
-  complementaryQualities: string[];
-  meaningfulCoincidences: Array<{
-    type: string;
-    description: string;
-    rarity: string;
-  }>;
-  mutualConnectionsList?: Array<{
-    name: string;
-    photo: any;
-    context: string;
-  }>;
-}
-
-/**
- * Transform API connection to UI connection format
- */
-const transformAPIConnection = (apiConnection: APIConnection): Connection => {
-  console.log('🔄 Transforming API connection:', {
-    id: apiConnection.id,
-    name: apiConnection.name,
-    description: apiConnection.description,
-    hasPhoto: !!apiConnection.photo,
-    photoLength: apiConnection.photo?.length,
-    interests: apiConnection.interests,
-    sharedPassions: apiConnection.sharedPassions,
-    complementaryQualities: apiConnection.complementaryQualities,
-    compatibility: apiConnection.compatibility
-  });
-
-  return {
-    id: parseInt(apiConnection.id) || parseInt(apiConnection._id || '') || Math.random() * 1000, // Try id first, then _id, then random
-    name: apiConnection.name || 'Unknown User',
-    description: apiConnection.description || 'Looking to connect',
-    photo: apiConnection.photo || '', // This will be a URL string from API, or empty string
-    bio: apiConnection.bio || '',
-    interests: apiConnection.interests || [],
-    mutualConnections: apiConnection.mutualConnections || 0,
-    compatibility: apiConnection.compatibility || 0,
-    conversationStarters: apiConnection.conversationStarters || ['Hi! Nice to meet you.'],
-    // UI REQUIRED FIELDS - These are actually rendered in ProfileDetailScreen
-    sharedPassions: apiConnection.sharedPassions || [], // Don't fallback to interests since we now have separate Interests section
-    complementaryQualities: apiConnection.complementaryQualities || [],
-    meaningfulCoincidences: apiConnection.meaningfulCoincidences || [],
-    mutualConnectionsList: apiConnection.mutualConnectionsList?.map(mutual => ({
-      name: mutual.name,
-      photo: mutual.photo, // URL string from API
-      context: mutual.context
-    })) || []
-  };
-};
-
-/**
- * Get user connections by username
- * @param username - Username to fetch connections for
- * @returns Promise<Connection[]>
- */
-export const getUserConnectionsByUsername = async (username: string): Promise<Connection[]> => {
-  try {
-    console.log('🔍 Fetching connections for username:', username);
-    
-    const token = await getAuthToken();
-    
-    // Enhanced token validation and warning
-    if (!token) {
-      console.warn('⚠️ [CONNECTIONS API] No authentication token available for connections request');
-      console.warn('⚠️ [CONNECTIONS API] This may result in limited or cached data from backend');
-      return []; // Return empty array instead of making unauthenticated request
-    }
-    
-    console.log('✅ [CONNECTIONS API] Using authenticated request with token:', `${token.substring(0, 20)}...`);
-    
-    // Use the same pattern as other working APIs - import and call with token
-    // const { getUserConnectionsByUsername: apiCall } = await import('../../services/api'); // Commented out - path issue
-    const response = { success: false, message: 'API function not available', connections: [], source: 'mock' };
-    
-    console.log('✅ API connections fetched by username:', {
-      success: response.success,
-      connectionsCount: response.connections?.length || 0,
-      source: response.source,
-      firstConnection: response.connections?.[0] ? {
-        id: response.connections[0].id,
-        name: response.connections[0].name,
-        description: response.connections[0].description
-      } : null
-    });
-    
-    if (response.success && response.connections && response.connections.length > 0) {
-      const transformedConnections = response.connections.map(transformAPIConnection);
-      console.log('🔄 Transformed connections by username:', transformedConnections.length);
-      return transformedConnections;
-    }
-    
-    return [];
-    
-  } catch (error) {
-    console.log('❌ Error fetching connections by username:', error);
-    console.log('❌ [NETWORK ERROR] Full error details:', JSON.stringify(error, Object.getOwnPropertyNames(error)));
-    return [];
-  }
-};
-
-/**
- * Get user connections by user ID
- * @param userId - User ID to fetch connections for
- * @returns Promise<Connection[]>
- */
-export const getUserConnectionsByUserId = async (userId: string): Promise<Connection[]> => {
-  try {
-    console.log('🔍 Fetching connections for userId:', userId);
-    
-    const token = await getAuthToken();
-    
-    if (!token) {
-      console.warn('⚠️ [CONNECTIONS API] No authentication token available for user ID connections request');
-      return []; // Return empty array instead of making unauthenticated request
-    }
-    
-    console.log('✅ [CONNECTIONS API] Using authenticated request with token:', `${token.substring(0, 20)}...`);
-    
-    // Use the same pattern as other working APIs - import and call with token
-    // const { getUserConnections: apiCall } = await import('../../services/api'); // Commented out - path issue
-    const response = { success: false, message: 'API function not available', connections: [], source: 'mock' };
-    
-    console.log('✅ API connections fetched by userId:', {
-      success: response.success,
-      connectionsCount: response.connections?.length || 0,
-      source: response.source,
-      firstConnection: response.connections?.[0] ? {
-        id: response.connections[0].id,
-        name: response.connections[0].name,
-        description: response.connections[0].description
-      } : null
-    });
-    
-    if (response.success && response.connections && response.connections.length > 0) {
-      const transformedConnections = response.connections.map(transformAPIConnection);
-      console.log('🔄 Transformed connections by userId:', transformedConnections.length);
-      return transformedConnections;
-    }
-    
-    return [];
-    
-  } catch (error) {
-    console.log('❌ Error fetching connections by userId:', error);
-    console.log('❌ [NETWORK ERROR FALLBACK] Full error details:', JSON.stringify(error, Object.getOwnPropertyNames(error)));
-    return [];
-  }
-};
-
-/**
- * Get user connections with automatic detection of user info
- * PRIORITIZES the working email/username endpoint over the failing user ID endpoint
- * @returns Promise<Connection[]>
- */
-export const getUserConnections = async (): Promise<Connection[]> => {
-  try {
-    // ENHANCED DEBUG: Check authentication status first
-    await ensureAuthentication('USER_CONNECTIONS');
-    
-    // ENHANCED DEBUG: Check what user data we actually have available
-    console.log('🔍 [USER DEBUG] Checking all available user data sources...');
-    
-    // Check AsyncStorage for user data
-    const storedUsername = await AsyncStorage.getItem('onairos_username');
-    const storedEmail = await AsyncStorage.getItem('user_email');
-    const storedUserId = await AsyncStorage.getItem('user_id');
-    const authToken = await AsyncStorage.getItem('auth_token');
-    
-    console.log('🔍 [USER DEBUG] AsyncStorage data:', {
-      storedUsername,
-      storedEmail,
-      storedUserId,
-      hasAuthToken: !!authToken,
-      authTokenPreview: authToken ? `${authToken.substring(0, 20)}...` : 'none'
-    });
-    
-    // First try to get user profile to determine username/userId
-    const userProfile = await getUserProfile();
-    console.log('🎯 getUserConnections - User profile:', {
-      hasId: !!userProfile?.id,
-      hasEmail: !!userProfile?.email,
-      email: userProfile?.email,
-      id: userProfile?.id
-    });
-    
-    // FALLBACK: If getUserProfile fails, try to use stored data directly
-    let userEmail = userProfile?.email;
-    let userId = userProfile?.id;
-    
-    if (!userEmail && storedUsername) {
-      console.log('🔄 [USER DEBUG] Using stored username as email fallback:', storedUsername);
-      userEmail = storedUsername;
-    }
-    
-    if (!userEmail && storedEmail) {
-      console.log('🔄 [USER DEBUG] Using stored email as fallback:', storedEmail);
-      userEmail = storedEmail;
-    }
-    
-    if (!userId && storedUserId) {
-      console.log('🔄 [USER DEBUG] Using stored user ID as fallback:', storedUserId);
-      userId = storedUserId;
-    }
-    
-    console.log('🎯 [USER DEBUG] Final user identifiers to use:', {
-      userEmail,
-      userId,
-      willTryEmail: !!userEmail,
-      willTryUserId: !!userId
-    });
-    
-    // PRIORITY 1: Try by email/username first (this endpoint is working!)
-    if (userEmail) {
-      console.log('🎯 PRIORITY: Attempting to fetch connections by email (working endpoint):', userEmail);
-      const connections = await getUserConnectionsByUsername(userEmail);
-      if (connections.length > 0) {
-        console.log('✅ Successfully got connections by email:', connections.length);
-        return connections;
-      }
-      console.log('⚠️ No connections found by email, trying user ID...');
-    }
-    
-    // PRIORITY 2: Try by user ID only if email fails (this endpoint has ObjectId issues)
-    if (userId) {
-      console.log('🎯 FALLBACK: Attempting to fetch connections by user ID:', userId);
-      const connections = await getUserConnectionsByUserId(userId);
-      if (connections.length > 0) {
-        console.log('✅ Successfully got connections by user ID:', connections.length);
-        return connections;
-      }
-      console.log('⚠️ No connections found by user ID');
-    }
-    
-    console.log('⚠️ No user identifier available or no connections found');
-    return [];
-    
-  } catch (error) {
-    console.log('❌ Error in getUserConnections:', error);
-    return [];
-  }
-};
-
-/**
- * Upload profile picture using base64 data with compression
- * The backend identifies the user from the JWT token, no need for user ID in URL
- * @param imageUri - Image URI (file:// or base64)
- * @param fileType - File type (jpg, png) - optional, will be extracted from imageUri if not provided
- * @returns Promise<{ success: boolean; photoUrl?: string; error?: string }>
- */
-export const uploadProfilePicture = async (
-  imageUri: string, 
-  fileType?: string
-): Promise<{ success: boolean; photoUrl?: string; error?: string }> => {
-  try {
-    console.log('🔍 [UPLOAD] Starting profile picture upload process...');
-    console.log('🔍 [UPLOAD] Input parameters:', {
-      imageUri: imageUri.substring(0, 100) + '...', // Show first 100 chars
-      imageUriLength: imageUri.length,
-      providedFileType: fileType,
-      isFileUri: imageUri.startsWith('file://'),
-      isHttpUri: imageUri.startsWith('http'),
-      isBase64: !imageUri.startsWith('file://') && !imageUri.startsWith('http')
-    });
-    
-    const token = await getAuthToken();
-    
-    if (!token) {
-      console.error('❌ [UPLOAD] No authentication token available');
-      throw new Error('No authentication token available');
-    }
-    
-    console.log('✅ [UPLOAD] Authentication token found:', `${token.substring(0, 20)}...`);
-
-    // Log token details for debugging
-    console.log('🔍 [UPLOAD] Token details:', {
-      tokenLength: token.length,
-      tokenPreview: `${token.substring(0, 20)}...`,
-      hasBearer: token.startsWith('eyJ'),
-      isJWT: token.split('.').length === 3
-    });
-
-    let imageData: string;
-    let finalFileType: string;
-
-    // Extract file type from imageUri if not provided
-    if (!fileType) {
-      if (imageUri.startsWith('file://') || imageUri.startsWith('http')) {
-        // Extract file extension from file path or URL
-        const urlParts = imageUri.split('.');
-        const extension = urlParts[urlParts.length - 1].toLowerCase();
-        
-        // Handle common image extensions
-        if (['jpg', 'jpeg', 'png', 'gif', 'webp'].includes(extension)) {
-          finalFileType = extension === 'jpeg' ? 'jpg' : extension;
-        } else {
-          finalFileType = 'jpg'; // Default fallback
-        }
-        
-        console.log('🔍 [UPLOAD] Extracted file type from URI:', finalFileType, 'from', imageUri.substring(0, 100));
-      } else {
-        finalFileType = 'jpg'; // Default for base64 data
-        console.log('🔍 [UPLOAD] Using default file type for base64 data:', finalFileType);
-      }
-    } else {
-      // Clean up provided file type
-      finalFileType = fileType.toLowerCase().replace('.', '');
-      console.log('🔍 [UPLOAD] Using provided file type:', finalFileType);
-    }
-
-    // Prepare image data
-    if (!imageUri.startsWith('file://') && !imageUri.startsWith('http')) {
-      // Assume it's already base64 data
-      console.log('📸 [UPLOAD] Using provided base64 data');
-      
-      // Validate that it looks like base64 image data
-      if (imageUri.length < 100 || !/^[A-Za-z0-9+/]/.test(imageUri)) {
-        console.error('❌ [UPLOAD] Invalid base64 data detected:', {
-          length: imageUri.length,
-          preview: imageUri.substring(0, 50),
-          looksLikeBase64: /^[A-Za-z0-9+/]/.test(imageUri)
-        });
-        throw new Error('Invalid image data provided - expected base64 encoded image');
-      }
-      
-      imageData = imageUri;
-    } else {
-      // It's a file URI, need to compress and convert to base64
-      console.log('📸 [UPLOAD] Converting file URI to base64...');
-      const compressedResult = await compressProfilePicture(imageUri);
-      
-      // Check if compression was successful
-      if (!compressedResult.success || !compressedResult.base64) {
-        console.error('❌ [UPLOAD] Image compression failed:', compressedResult.error);
-        throw new Error(compressedResult.error || 'Failed to compress image');
-      }
-      
-      console.log(`✅ [UPLOAD] Image compressed: ${compressedResult.sizeKB}KB (${compressedResult.compressionRatio?.toFixed(2)}x compression)`);
-      imageData = compressedResult.base64;
-    }
-
-    // Final validation of image data and file type
-    console.log('🔍 [UPLOAD] Final upload data:', {
-      imageDataLength: imageData.length,
-      imageDataPreview: imageData.substring(0, 50) + '...',
-      fileType: finalFileType,
-      isValidBase64: /^[A-Za-z0-9+/]/.test(imageData),
-      hasValidLength: imageData.length > 1000 // Should be substantial for an image
-    });
-
-    // Now try to upload using the correct backend endpoint
-    console.log('📤 [UPLOAD] Trying user-specific profile picture endpoint (backend supports usernames)...');
-    
-    // Get the user identifier (could be username or user ID - backend now supports both)
-    const userIdentifier = await getUserIdWithFallbacks();
-    if (!userIdentifier) {
-      console.error('❌ [UPLOAD] Cannot determine user identifier');
-      throw new Error('Unable to determine user identifier - please ensure you are logged in properly');
-    }
-
-    console.log('📸 [UPLOAD] Uploading profile picture for user identifier:', userIdentifier);
-    
-    const response = await fetch(`${API_BASE_URL}/enoch/users/${userIdentifier}/profile-picture/base64`, {
-      method: 'POST',
-      headers: getAuthHeaders(token),
-      body: JSON.stringify({
-        imageData,
-        fileType: finalFileType
-      })
-    });
-    
-    const responseData = await response.json();
-    console.log('📡 [UPLOAD] Backend response:', {
-      status: response.status,
-      success: responseData.success,
-      photoUrl: responseData.photoUrl,
-      error: responseData.error,
-      userIdentifier: userIdentifier
-    });
-    
-    if (response.ok && responseData.success) {
-      console.log('✅ [UPLOAD] Profile picture uploaded successfully');
-      return {
-        success: true,
-        photoUrl: responseData.photoUrl || responseData.url
-      };
-    } else {
-      console.error('❌ [UPLOAD] Profile picture upload failed:', responseData.error || 'Unknown error');
-      
-      // Enhanced error logging for debugging
-      if (response.status === 403) {
-        console.error('🚫 [UPLOAD] 403 Forbidden - Authentication issue detected');
-        console.error('🔍 [UPLOAD] Debug info:', {
-          userIdentifier: userIdentifier,
-          tokenPreview: `${token.substring(0, 20)}...`,
-          tokenLength: token.length,
-          responseError: responseData.error
-        });
-      } else if (response.status === 400) {
-        console.error('🚫 [UPLOAD] 400 Bad Request - Data format issue detected');
-        console.error('🔍 [UPLOAD] Debug info:', {
-          imageDataLength: imageData.length,
-          fileType: finalFileType,
-          responseError: responseData.error
-        });
-      }
-      
-      return {
-        success: false,
-        error: responseData.error || `HTTP ${response.status}: ${response.statusText}`
-      };
-    }
-    
-  } catch (error) {
-    console.error('❌ [UPLOAD] Error uploading profile picture:', error);
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : 'Unknown error occurred'
-    };
-  }
-};