@onairos/react-native 3.1.11 → 3.1.13

package/src/services/userConnectionsService.ts

@@ -0,0 +1,557 @@
+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'
+    };
+  }
+};