feat(auth): add country and language support to user registration

Linkedin_poster_dev

@@ -1 +1 @@
-Subproject commit 556c23cdbb7a7f9f7a2fe03deb092b7efc521653
+Subproject commit 09381cacceca11c302c5d8e056a8bd7b9121a09d

backend/api/auth.py

@@ -2,6 +2,7 @@ from flask import Blueprint, request, jsonify, current_app
 from flask_jwt_extended import jwt_required, get_jwt_identity
 from backend.services.auth_service import register_user, login_user, get_user_by_id, request_password_reset, reset_user_password
 from backend.models.user import User
+from backend.utils.country_language_data import COUNTRIES, LANGUAGES
 
 auth_bp = Blueprint('auth', __name__)
 
@@ -19,44 +20,67 @@ def handle_register_options():
 def register():
     """
     Register a new user.
-    
+
     Request Body:
         email (str): User email
         password (str): User password
-        
+        country (str, optional): User country (ISO 3166-1 alpha-2 code)
+        language (str, optional): User language (ISO 639-1 code)
+
     Returns:
         JSON: Registration result
     """
     try:
         data = request.get_json()
-        
+
         # Validate required fields
         if not data or not all(k in data for k in ('email', 'password')):
             return jsonify({
                 'success': False,
                 'message': 'Email and password are required'
             }), 400
-        
+
         email = data['email']
         password = data['password']
-        
+        country = data.get('country')  # Optional: User country (ISO 3166-1 alpha-2 code)
+        language = data.get('language')  # Optional: User language (ISO 639-1 code)
+
         # Note: confirm_password validation is removed as Supabase handles password confirmation automatically
-        
+
         # Validate password length
         if len(password) < 8:
             return jsonify({
                 'success': False,
                 'message': 'Password must be at least 8 characters long'
             }), 400
-        
-        # Register user
-        result = register_user(email, password)
-        
+
+        # Optional: Validate country and language parameters if provided
+        if country:
+            # Validate if country is a valid ISO 3166-1 alpha-2 code
+            # For now, we'll just check that it's a 2-character string
+            if not isinstance(country, str) or len(country) != 2:
+                return jsonify({
+                    'success': False,
+                    'message': 'Country must be a valid ISO 3166-1 alpha-2 code (2 characters)'
+                }), 400
+
+        if language:
+            # Validate if language is a valid ISO 639-1 code
+            # For now, we'll just check that it's a 2-character string
+            if not isinstance(language, str) or len(language) != 2:
+                return jsonify({
+                    'success': False,
+                    'message': 'Language must be a valid ISO 639-1 code (2 characters)'
+                }), 400
+
+        # Register user with preferences
+        result = register_user(email, password, country, language)
+
         if result['success']:
             return jsonify(result), 201
         else:
             return jsonify(result), 400
-            
+
     except Exception as e:
         current_app.logger.error(f"Registration error: {str(e)}")
         return jsonify({
@@ -76,12 +100,12 @@ def handle_login_options():
 def login():
     """
     Authenticate and login a user.
-    
+
     Request Body:
         email (str): User email
         password (str): User password
         remember_me (bool): Remember me flag for extended session (optional)
-        
+
     Returns:
         JSON: Login result with JWT token
     """
@@ -90,9 +114,9 @@ def login():
         current_app.logger.info(f"Login request received from {request.remote_addr}")
         current_app.logger.info(f"Request headers: {dict(request.headers)}")
         current_app.logger.info(f"Request data: {request.get_json()}")
-        
+
         data = request.get_json()
-        
+
         # Validate required fields
         if not data or not all(k in data for k in ('email', 'password')):
             current_app.logger.warning("Login failed: Missing email or password")
@@ -100,14 +124,14 @@ def login():
                 'success': False,
                 'message': 'Email and password are required'
             }), 400
-        
+
         email = data['email']
         password = data['password']
         remember_me = data.get('remember_me', False)
-        
+
         # Login user
         result = login_user(email, password, remember_me)
-        
+
         if result['success']:
             # Set CORS headers explicitly
             response_data = jsonify(result)
@@ -118,7 +142,7 @@ def login():
         else:
             current_app.logger.warning(f"Login failed for user {email}: {result.get('message', 'Unknown error')}")
             return jsonify(result), 401
-            
+
     except Exception as e:
         current_app.logger.error(f"Login error: {str(e)}", exc_info=True)
         return jsonify({
@@ -136,7 +160,7 @@ def handle_logout_options():
 def logout():
     """
     Logout current user.
-    
+
     Returns:
         JSON: Logout result
     """
@@ -145,7 +169,7 @@ def logout():
             'success': True,
             'message': 'Logged out successfully'
         }), 200
-        
+
     except Exception as e:
         current_app.logger.error(f"Logout error: {str(e)}")
         return jsonify({
@@ -163,14 +187,14 @@ def handle_user_options():
 def get_current_user():
     """
     Get current authenticated user.
-    
+
     Returns:
         JSON: Current user data
     """
     try:
         user_id = get_jwt_identity()
         user_data = get_user_by_id(user_id)
-        
+
         if user_data:
             return jsonify({
                 'success': True,
@@ -181,7 +205,7 @@ def get_current_user():
                 'success': False,
                 'message': 'User not found'
             }), 404
-            
+
     except Exception as e:
         current_app.logger.error(f"Get user error: {str(e)}")
         return jsonify({
@@ -189,6 +213,27 @@ def get_current_user():
             'message': 'An error occurred while fetching user data'
         }), 500
 
+@auth_bp.route('/registration-options', methods=['GET'])
+def get_registration_options():
+    """
+    Get registration options including countries and languages.
+
+    Returns:
+        JSON: Registration options
+    """
+    try:
+        return jsonify({
+            'success': True,
+            'countries': COUNTRIES,
+            'languages': LANGUAGES
+        }), 200
+
+    except Exception as e:
+        current_app.logger.error(f"Get registration options error: {str(e)}")
+        return jsonify({
+            'success': False,
+            'message': 'An error occurred while fetching registration options'
+        }), 500
 
 @auth_bp.route('/forgot-password', methods=['OPTIONS'])
 def handle_forgot_password_options():
@@ -200,33 +245,33 @@ def handle_forgot_password_options():
 def forgot_password():
     """
     Request password reset for a user.
-    
+
     Request Body:
         email (str): User email
-        
+
     Returns:
         JSON: Password reset request result
     """
     try:
         data = request.get_json()
-        
+
         # Validate required fields
         if not data or 'email' not in data:
             return jsonify({
                 'success': False,
                 'message': 'Email is required'
             }), 400
-        
+
         email = data['email']
-        
+
         # Request password reset
         result = request_password_reset(current_app.supabase, email)
-        
+
         if result['success']:
             return jsonify(result), 200
         else:
             return jsonify(result), 400
-            
+
     except Exception as e:
         current_app.logger.error(f"Forgot password error: {str(e)}")
         return jsonify({
@@ -260,44 +305,44 @@ def show_reset_password_form():
 def reset_password():
     """
     Reset user password with token.
-    
+
     Request Body:
         token (str): Password reset token
         password (str): New password
-        
+
     Returns:
         JSON: Password reset result
     """
     try:
         data = request.get_json()
-        
+
         # Validate required fields
         if not data or not all(k in data for k in ('token', 'password')):
             return jsonify({
                 'success': False,
                 'message': 'Token and password are required'
             }), 400
-        
+
         token = data['token']
         password = data['password']
-        
+
         # Note: confirm_password validation is removed as Supabase handles password confirmation automatically
-        
+
         # Validate password length
         if len(password) < 8:
             return jsonify({
                 'success': False,
                 'message': 'Password must be at least 8 characters long'
             }), 400
-        
+
         # Reset password
         result = reset_user_password(current_app.supabase, token, password)
-        
+
         if result['success']:
             return jsonify(result), 200
         else:
             return jsonify(result), 400
-            
+
     except Exception as e:
         current_app.logger.error(f"Reset password error: {str(e)}")
         return jsonify({

backend/api/posts.py

@@ -21,7 +21,7 @@ def safe_log_message(message):
         else:
             # For non-strings, convert to string first
             safe_message = str(message)
-        
+
         # Log to app logger instead of print
         current_app.logger.debug(safe_message)
     except Exception as e:
@@ -38,17 +38,17 @@ def handle_options():
 def get_posts():
     """
     Get all posts for the current user.
-    
+
     Query Parameters:
         published (bool): Filter by published status
-        
+
     Returns:
         JSON: List of posts
     """
     try:
         user_id = get_jwt_identity()
         published = request.args.get('published', type=bool)
-        
+
         # Check if Supabase client is initialized
         if not hasattr(current_app, 'supabase') or current_app.supabase is None:
             # Add CORS headers to error response
@@ -59,26 +59,26 @@ def get_posts():
             response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
             response_data.headers.add('Access-Control-Allow-Credentials', 'true')
             return response_data, 500
-        
+
         # Build query
         query = (
             current_app.supabase
             .table("Post_content")
             .select("*, Social_network(id_utilisateur)")
         )
-        
+
         # Apply published filter if specified
         if published is not None:
             query = query.eq("is_published", published)
-        
+
         response = query.execute()
-        
+
         # Filter posts for the current user
         user_posts = [
             post for post in response.data
             if post.get('Social_network', {}).get('id_utilisateur') == user_id
         ] if response.data else []
-        
+
         # Add CORS headers explicitly
         response_data = jsonify({
             'success': True,
@@ -87,7 +87,7 @@ def get_posts():
         response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
         response_data.headers.add('Access-Control-Allow-Credentials', 'true')
         return response_data, 200
-        
+
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"Get posts error: {error_message}")
@@ -103,7 +103,7 @@ def get_posts():
 def _generate_post_task(user_id, job_id, job_store, hugging_key):
     """
     Background task to generate post content.
-    
+
     Args:
         user_id (str): User ID for personalization
         job_id (str): Job ID to update status in job store
@@ -117,12 +117,18 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
             'result': None,
             'error': None
         }
-        
+
+        # Log that the background task has started
+        current_app.logger.info(f"Starting background post generation task for user_id: {user_id}, job_id: {job_id}")
+
         # Generate content using content service
         # Pass the Hugging Face key directly to the service
         content_service = ContentService(hugging_key=hugging_key)
+        current_app.logger.info(f"ContentService created successfully for user_id: {user_id}")
+
         generated_result = content_service.generate_post_content(user_id)
-        
+        current_app.logger.info(f"Content generation completed successfully for user_id: {user_id}, result type: {type(generated_result)}")
+
         # Handle the case where generated_result might be a tuple, list, or string
         # image_data could be bytes (from base64) or a string (URL)
         if isinstance(generated_result, (tuple, list)) and len(generated_result) >= 2:
@@ -134,7 +140,7 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
         else:
             generated_content = generated_result
             image_data = None
-        
+
         # Update job status to completed with result
         job_store[job_id] = {
             'status': 'completed',
@@ -144,7 +150,9 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
             },
             'error': None
         }
-        
+
+        current_app.logger.info(f"Background task completed for job_id: {job_id}, status set to completed")
+
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"Generate post background task error: {error_message}")
@@ -154,56 +162,59 @@ def _generate_post_task(user_id, job_id, job_store, hugging_key):
             'result': None,
             'error': error_message
         }
+        current_app.logger.error(f"Background task failed for job_id: {job_id}, error: {error_message}")
 
 @posts_bp.route('/generate', methods=['POST'])
 @jwt_required()
 def generate_post():
     """
     Generate a new post using AI asynchronously.
-    
+
     Request Body:
         user_id (str): User ID (optional, defaults to current user)
-        
+
     Returns:
         JSON: Job ID for polling
     """
     try:
         current_user_id = get_jwt_identity()
         data = request.get_json()
-        
+
         # Use provided user_id or default to current user
         user_id = data.get('user_id', current_user_id)
-        
+
         # Verify user authorization (can only generate for self unless admin)
         if user_id != current_user_id:
             return jsonify({
                 'success': False,
                 'message': 'Unauthorized to generate posts for other users'
             }), 403
-        
+
         # Create a job ID
         job_id = str(uuid.uuid4())
-        
+
         # Initialize job status
         current_app.job_store[job_id] = {
             'status': 'pending',
             'result': None,
             'error': None
         }
-        
+
         # Get Hugging Face key
         hugging_key = current_app.config['HUGGING_KEY']
-        
+        current_app.logger.info(f"About to submit background task for user_id: {user_id}, job_id: {job_id}, hugging_key present: {bool(hugging_key)}")
+
         # Submit the background task, passing all necessary data
-        current_app.executor.submit(_generate_post_task, user_id, job_id, current_app.job_store, hugging_key)
-        
+        future = current_app.executor.submit(_generate_post_task, user_id, job_id, current_app.job_store, hugging_key)
+        current_app.logger.info(f"Background task submitted successfully, future object: {future}")
+
         # Return job ID immediately
         return jsonify({
             'success': True,
             'job_id': job_id,
             'message': 'Post generation started'
         }), 202  # 202 Accepted
-        
+
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"Generate post error: {error_message}")
@@ -217,30 +228,30 @@ def generate_post():
 def get_job_status(job_id):
     """
     Get the status of a post generation job.
-    
+
     Path Parameters:
         job_id (str): Job ID
-        
+
     Returns:
         JSON: Job status and result if completed
     """
     try:
         # Get job from store
         job = current_app.job_store.get(job_id)
-        
+
         if not job:
             return jsonify({
                 'success': False,
                 'message': 'Job not found'
             }), 404
-            
+
         # Prepare response
         response_data = {
             'success': True,
             'job_id': job_id,
             'status': job['status']
         }
-        
+
         # Include result or error if available
         if job['status'] == 'completed':
             # Handle the new structure of the result
@@ -305,9 +316,9 @@ def get_job_status(job_id):
                 response_data['has_image_data'] = False
         elif job['status'] == 'failed':
             response_data['error'] = job['error']
-            
+
         return jsonify(response_data), 200
-        
+
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"Get job status error: {error_message}")
@@ -320,23 +331,23 @@ def get_job_status(job_id):
 def get_job_image(job_id):
     """
     Serve image file for a completed job.
-    
+
     Path Parameters:
         job_id (str): Job ID
-        
+
     Returns:
         Image file
     """
     try:
         # Get job from store
         job = current_app.job_store.get(job_id)
-        
+
         if not job:
             return jsonify({
                 'success': False,
                 'message': 'Job not found'
             }), 404
-            
+
         # Check if job has an image file path
         image_file_path = job.get('image_file_path')
         if not image_file_path or not os.path.exists(image_file_path):
@@ -344,10 +355,10 @@ def get_job_image(job_id):
                 'success': False,
                 'message': 'Image not found'
             }), 404
-            
+
         # Serve the image file
         return send_file(image_file_path)
-        
+
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"Get job image error: {error_message}")
@@ -366,30 +377,30 @@ def handle_publish_direct_options():
 def publish_post_direct():
     """
     Publish a post directly to social media and save to database.
-    
+
     Request Body:
         social_account_id (str): Social account ID
         text_content (str): Post text content
         image_content_url (str, optional): Image URL
         scheduled_at (str, optional): Scheduled time in ISO format
-        
+
     Returns:
         JSON: Publish post result
     """
     try:
         user_id = get_jwt_identity()
         data = request.get_json()
-        
+
         # Validate required fields
         social_account_id = data.get('social_account_id')
         text_content = data.get('text_content')
-        
+
         if not social_account_id or not text_content:
             return jsonify({
                 'success': False,
                 'message': 'social_account_id and text_content are required'
             }), 400
-        
+
         # Verify the social account belongs to the user
         account_response = (
             current_app.supabase
@@ -398,33 +409,33 @@ def publish_post_direct():
             .eq("id", social_account_id)
             .execute()
         )
-        
+
         if not account_response.data:
             return jsonify({
                 'success': False,
                 'message': 'Social account not found'
             }), 404
-            
+
         account = account_response.data[0]
         if account.get('id_utilisateur') != user_id:
             return jsonify({
                 'success': False,
                 'message': 'Unauthorized to use this social account'
             }), 403
-        
+
         # Get account details
         access_token = account.get('token')
         user_sub = account.get('sub')
-        
+
         if not access_token or not user_sub:
             return jsonify({
                 'success': False,
                 'message': 'Social account not properly configured'
             }), 400
-        
+
         # Get optional fields
         image_data = data.get('image_content_url')  # This could be bytes or a URL string
-        
+
         # Handle image data - if it's bytes, we need to convert it for LinkedIn
         image_url_for_linkedin = None
         if image_data:
@@ -436,27 +447,27 @@ def publish_post_direct():
             else:
                 # If it's a string, assume it's a URL
                 image_url_for_linkedin = image_data
-        
+
         # Publish to LinkedIn
         linkedin_service = LinkedInService()
         publish_response = linkedin_service.publish_post(
             access_token, user_sub, text_content, image_url_for_linkedin
         )
-        
+
         # Save to database as published
         post_data = {
             'id_social': social_account_id,
             'Text_content': text_content,
             'is_published': True
         }
-        
+
         # Add optional fields if provided
         if image_data:
             post_data['image_content_url'] = ensure_bytes_format(image_data)
-            
+
         if 'scheduled_at' in data:
             post_data['scheduled_at'] = data['scheduled_at']
-        
+
         # Insert post into database
         response = (
             current_app.supabase
@@ -464,7 +475,7 @@ def publish_post_direct():
             .insert(post_data)
             .execute()
         )
-        
+
         if response.data:
             # Add CORS headers explicitly
             response_data = jsonify({
@@ -485,7 +496,7 @@ def publish_post_direct():
             response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
             response_data.headers.add('Access-Control-Allow-Credentials', 'true')
             return response_data, 500
-            
+
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"[Post] Publish post directly error: {error_message}")
@@ -508,31 +519,31 @@ def handle_post_options(post_id):
 def create_post():
     """
     Create a new post.
-    
+
     Request Body:
         social_account_id (str): Social account ID
         text_content (str): Post text content
         image_content_url (str, optional): Image URL
         scheduled_at (str, optional): Scheduled time in ISO format
         is_published (bool, optional): Whether the post is published (defaults to True)
-        
+
     Returns:
         JSON: Created post data
     """
     try:
         user_id = get_jwt_identity()
         data = request.get_json()
-        
+
         # Validate required fields
         social_account_id = data.get('social_account_id')
         text_content = data.get('text_content')
-        
+
         if not social_account_id or not text_content:
             return jsonify({
                 'success': False,
                 'message': 'social_account_id and text_content are required'
             }), 400
-        
+
         # Verify the social account belongs to the user
         account_response = (
             current_app.supabase
@@ -541,36 +552,36 @@ def create_post():
             .eq("id", social_account_id)
             .execute()
         )
-        
+
         if not account_response.data:
             return jsonify({
                 'success': False,
                 'message': 'Social account not found'
             }), 404
-            
+
         if account_response.data[0].get('id_utilisateur') != user_id:
             return jsonify({
                 'success': False,
                 'message': 'Unauthorized to use this social account'
             }), 403
-        
+
         # Prepare post data - always mark as published
         post_data = {
             'id_social': social_account_id,
             'Text_content': text_content,
             'is_published': data.get('is_published', True)  # Default to True
         }
-        
+
         # Handle image data - could be bytes or a URL string
         image_data = data.get('image_content_url')
-        
+
         # Add optional fields if provided
         if image_data is not None:
             post_data['image_content_url'] = ensure_bytes_format(image_data)
-            
+
         if 'scheduled_at' in data:
             post_data['scheduled_at'] = data['scheduled_at']
-        
+
         # Insert post into database
         response = (
             current_app.supabase
@@ -578,7 +589,7 @@ def create_post():
             .insert(post_data)
             .execute()
         )
-        
+
         if response.data:
             # Add CORS headers explicitly
             response_data = jsonify({
@@ -597,7 +608,7 @@ def create_post():
             response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
             response_data.headers.add('Access-Control-Allow-Credentials', 'true')
             return response_data, 500
-            
+
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"[Post] Create post error: {error_message}")
@@ -615,16 +626,16 @@ def create_post():
 def delete_post(post_id):
     """
     Delete a post.
-    
+
     Path Parameters:
         post_id (str): Post ID
-        
+
     Returns:
         JSON: Delete post result
     """
     try:
         user_id = get_jwt_identity()
-        
+
         # Verify the post belongs to the user
         response = (
             current_app.supabase
@@ -633,20 +644,20 @@ def delete_post(post_id):
             .eq("id", post_id)
             .execute()
         )
-        
+
         if not response.data:
             return jsonify({
                 'success': False,
                 'message': 'Post not found'
             }), 404
-        
+
         post = response.data[0]
         if post.get('Social_network', {}).get('id_utilisateur') != user_id:
             return jsonify({
                 'success': False,
                 'message': 'Unauthorized to delete this post'
             }), 403
-        
+
         # Delete post from Supabase
         delete_response = (
             current_app.supabase
@@ -655,7 +666,7 @@ def delete_post(post_id):
             .eq("id", post_id)
             .execute()
         )
-        
+
         if delete_response.data:
             return jsonify({
                 'success': True,
@@ -666,7 +677,7 @@ def delete_post(post_id):
                 'success': False,
                 'message': 'Failed to delete post'
             }), 500
-        
+
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"Delete post error: {error_message}")
@@ -680,18 +691,18 @@ def delete_post(post_id):
 def keyword_analysis():
     """
     Analyze keyword frequency in RSS feeds and posts.
-    
+
     Request Body:
         keyword (str): The keyword to analyze
         date_range (str, optional): Date range for analysis (daily, weekly, monthly)
-        
+
     Returns:
         JSON: Keyword frequency analysis data
     """
     try:
         user_id = get_jwt_identity()
         data = request.get_json()
-        
+
         # Validate required fields
         keyword = data.get('keyword')
         if not keyword:
@@ -699,14 +710,14 @@ def keyword_analysis():
                 'success': False,
                 'message': 'Keyword is required'
             }), 400
-        
+
         # Get date range (default to all available data)
         date_range = data.get('date_range', 'monthly')
-        
+
         # Use ContentService to perform keyword analysis
         content_service = current_app.content_service
         analysis_data = content_service.analyze_keyword_frequency(keyword, user_id, date_range)
-        
+
         # Add CORS headers explicitly
         response_data = jsonify({
             'success': True,
@@ -717,7 +728,7 @@ def keyword_analysis():
         response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
         response_data.headers.add('Access-Control-Allow-Credentials', 'true')
         return response_data, 200
-        
+
     except Exception as e:
         error_message = str(e)
         safe_log_message(f"Keyword analysis error: {error_message}")

backend/config.py

@@ -11,7 +11,7 @@ def get_system_encoding():
         # Try to get the preferred encoding
         import locale
         preferred_encoding = locale.getpreferredencoding(False)
-        
+
         # Ensure it's UTF-8 or a compatible encoding
         if preferred_encoding.lower() not in ['utf-8', 'utf8', 'utf_8']:
             # On Windows, try to set UTF-8
@@ -23,56 +23,57 @@ def get_system_encoding():
                     preferred_encoding = 'utf-8'
             else:
                 preferred_encoding = 'utf-8'
-        
+
         return preferred_encoding
     except:
         return 'utf-8'
 
 class Config:
     """Base configuration class."""
-    
+
     # Set default encoding
     DEFAULT_ENCODING = get_system_encoding()
-    
+
     # Supabase configuration
     SUPABASE_URL = os.environ.get('SUPABASE_URL') or ''
     SUPABASE_KEY = os.environ.get('SUPABASE_KEY') or ''
-    
+
     # LinkedIn OAuth configuration
     CLIENT_ID = os.environ.get('CLIENT_ID') or ''
     CLIENT_SECRET = os.environ.get('CLIENT_SECRET') or ''
     REDIRECT_URL = os.environ.get('REDIRECT_URL') or ''
-    
+
     # Hugging Face configuration
-    HUGGING_KEY = os.environ.get('HUGGING_KEY') or ''
-    
+    # Check for lowercase hugging_key first (for dev), then uppercase HUGGING_KEY (for production)
+    HUGGING_KEY = os.environ.get('hugging_key') or os.environ.get('HUGGING_KEY') or ''
+
     # JWT configuration
     JWT_SECRET_KEY = os.environ.get('JWT_SECRET_KEY') or 'your-secret-key-change-in-production'
-    
+
     # Database configuration
     DATABASE_URL = os.environ.get('DATABASE_URL') or ''
-    
+
     # Application configuration
     SECRET_KEY = os.environ.get('SECRET_KEY') or 'your-secret-key-change-in-production'
     DEBUG = os.environ.get('DEBUG', 'False').lower() == 'true'
-    
+
     # Scheduler configuration
     SCHEDULER_ENABLED = os.environ.get('SCHEDULER_ENABLED', 'True').lower() == 'true'
-    
+
     # Unicode/Encoding configuration
     FORCE_UTF8 = os.environ.get('FORCE_UTF8', 'True').lower() == 'true'
     UNICODE_LOGGING = os.environ.get('UNICODE_LOGGING', 'True').lower() == 'true'
-    
+
     # Environment detection
     ENVIRONMENT = os.environ.get('ENVIRONMENT', 'development').lower()
     IS_WINDOWS = platform.system() == 'Windows'
     IS_DOCKER = os.environ.get('DOCKER_CONTAINER', '').lower() == 'true'
-    
+
     # Set environment-specific encoding settings
     if FORCE_UTF8:
         os.environ['PYTHONIOENCODING'] = 'utf-8'
         os.environ['PYTHONUTF8'] = '1'
-    
+
     # Debug and logging settings
     LOG_LEVEL = os.environ.get('LOG_LEVEL', 'INFO' if ENVIRONMENT == 'production' else 'DEBUG')
     UNICODE_SAFE_LOGGING = UNICODE_LOGGING and not IS_WINDOWS

backend/services/auth_service.py

@@ -6,14 +6,16 @@ from supabase import Client
 from backend.models.user import User
 from backend.utils.database import authenticate_user, create_user
 
-def register_user(email: str, password: str) -> dict:
+def register_user(email: str, password: str, country: str = None, language: str = None) -> dict:
     """
     Register a new user.
-    
+
     Args:
         email (str): User email
         password (str): User password
-        
+        country (str, optional): User country (ISO 3166-1 alpha-2 code)
+        language (str, optional): User language (ISO 639-1 code)
+
     Returns:
         dict: Registration result with user data or error message
     """
@@ -33,10 +35,10 @@ def register_user(email: str, password: str) -> dict:
              current_app.logger.warning(f"Failed to check profiles table for email {email}: {str(profile_check_error)}")
              # Optionally, you could return an error here if you want to be strict about this check
              # return {'success': False, 'message': 'Unable to process registration at this time. Please try again later.'}
-            
+
         # If no profile found, proceed with Supabase Auth sign up
         response = create_user(current_app.supabase, email, password)
-        
+
         if response.user:
             user = User.from_dict({
                 'id': response.user.id,
@@ -44,7 +46,25 @@ def register_user(email: str, password: str) -> dict:
                 'created_at': response.user.created_at,
                 'email_confirmed_at': response.user.email_confirmed_at
             })
-            
+
+            # Store user preferences in profiles table if provided
+            if country or language:
+                try:
+                    # Prepare update data for dedicated country/language fields
+                    update_data = {}
+                    if country:
+                        update_data['country'] = country
+                    if language:
+                        update_data['language'] = language
+
+                    # Update the profiles table with user preferences in dedicated columns
+                    update_response = current_app.supabase.table("profiles").update(update_data).eq("id", response.user.id).execute()
+
+                    current_app.logger.info(f"User preferences stored for user {response.user.id}: country={country}, language={language}")
+                except Exception as profile_update_error:
+                    # Log the error but don't fail the registration
+                    current_app.logger.error(f"Failed to store user preferences: {str(profile_update_error)}")
+
             # Check if email is confirmed
             if response.user.email_confirmed_at:
                 # Email is confirmed, user can login immediately
@@ -71,7 +91,7 @@ def register_user(email: str, password: str) -> dict:
     except Exception as e:
         # Log the full error for debugging
         current_app.logger.error(f"Registration error for email {email}: {str(e)}")
-        
+
         # Check if it's a duplicate user error from Supabase Auth
         error_str = str(e).lower()
         if 'already registered' in error_str or 'already exists' in error_str:
@@ -101,19 +121,19 @@ def register_user(email: str, password: str) -> dict:
 def login_user(email: str, password: str, remember_me: bool = False) -> dict:
     """
     Authenticate and login a user.
-    
+
     Args:
         email (str): User email
         password (str): User password
         remember_me (bool): Remember me flag for extended session
-        
+
     Returns:
         dict: Login result with token and user data or error message
     """
     try:
         # Authenticate user with Supabase
         response = authenticate_user(current_app.supabase, email, password)
-        
+
         if response.user:
             # Check if email is confirmed
             if not response.user.email_confirmed_at:
@@ -122,7 +142,7 @@ def login_user(email: str, password: str, remember_me: bool = False) -> dict:
                     'message': 'Check your mail to confirm your account',
                     'requires_confirmation': True
                 }
-            
+
             # Set token expiration based on remember me flag
             if remember_me:
                 # Extended token expiration (7 days)
@@ -132,7 +152,7 @@ def login_user(email: str, password: str, remember_me: bool = False) -> dict:
                 # Standard token expiration (1 hour)
                 expires_delta = timedelta(hours=1)
                 token_type = "session"
-            
+
             # Create JWT token with proper expiration and claims
             access_token = create_access_token(
                 identity=response.user.id,
@@ -144,14 +164,14 @@ def login_user(email: str, password: str, remember_me: bool = False) -> dict:
                 },
                 expires_delta=expires_delta
             )
-            
+
             user = User.from_dict({
                 'id': response.user.id,
                 'email': response.user.email,
                 'created_at': response.user.created_at,
                 'email_confirmed_at': response.user.email_confirmed_at
             })
-            
+
             return {
                 'success': True,
                 'token': access_token,
@@ -167,7 +187,7 @@ def login_user(email: str, password: str, remember_me: bool = False) -> dict:
             }
     except Exception as e:
         current_app.logger.error(f"Login error: {str(e)}")
-        
+
         # Provide more specific error messages
         error_str = str(e).lower()
         if 'invalid credentials' in error_str or 'unauthorized' in error_str:
@@ -213,17 +233,17 @@ def login_user(email: str, password: str, remember_me: bool = False) -> dict:
 def get_user_by_id(user_id: str) -> dict:
     """
     Get user by ID.
-    
+
     Args:
         user_id (str): User ID
-        
+
     Returns:
         dict: User data or None if not found
     """
     try:
         # Get user from Supabase Auth
         response = current_app.supabase.auth.get_user(user_id)
-        
+
         if response.user:
             user = User.from_dict({
                 'id': response.user.id,
@@ -241,18 +261,18 @@ def get_user_by_id(user_id: str) -> dict:
 def request_password_reset(supabase: Client, email: str) -> dict:
     """
     Request password reset for a user.
-    
+
     Args:
         supabase (Client): Supabase client instance
         email (str): User email
-        
+
     Returns:
         dict: Password reset request result
     """
     try:
         # Request password reset
         response = supabase.auth.reset_password_for_email(email)
-        
+
         return {
             'success': True,
             'message': 'Password reset instructions sent to your email. Please check your inbox.'
@@ -277,17 +297,17 @@ def reset_user_password(supabase: Client, token: str, new_password: str) -> dict
     """
     This function is deprecated. Password reset should be handled directly by the frontend
     using the Supabase JavaScript client after the user is redirected from the reset email.
-    
+
     The standard Supabase v2 flow is:
     1. User clicks reset link -> Supabase verifies token and establishes a recovery session.
     2. User is redirected to the app (e.g., /reset-password).
     3. Frontend uses supabase.auth.updateUser({ password: newPassword }) directly.
-    
+
     Args:
         supabase (Client): Supabase client instance
         token (str): Password reset token (not used in this implementation)
         new_password (str): New password (not used in this implementation)
-        
+
     Returns:
         dict: Message indicating this endpoint is deprecated
     """

backend/services/content_service.py

@@ -139,11 +139,13 @@ class ContentService:
             if self.client is None:
                 self._initialize_client()
 
-            # Call the Hugging Face model to generate content
+            current_app.logger.info(f"Calling Gradio API with user_id: {user_id}")
             result = self.client.predict(
                 code=user_id,
                 api_name="/poster_linkedin"
             )
+            current_app.logger.info(f"Gradio API response received: {type(result)}")
+
 
             # Handle the case where result might be a tuple from Gradio
             # The Gradio API returns a tuple with (content, image_data)
@@ -737,4 +739,65 @@ class ContentService:
             f"https://news.google.com/rss/search?q={query_encoded}"
             f"&hl={language}&gl={country}&ceid={country}:{language}"
         )
-        return url
+        return url
+
+    def _get_user_preferences(self, user_id: str) -> dict:
+        """
+        Get user preferences (country and language) from the Supabase profiles table.
+
+        Args:
+            user_id (str): User ID to fetch preferences for
+
+        Returns:
+            Dict containing country and language, with default values if not found
+        """
+        try:
+            # Check if Supabase client is initialized
+            if not hasattr(current_app, 'supabase') or current_app.supabase is None:
+                raise Exception("Database connection not initialized")
+
+            response = (
+                current_app.supabase
+                .table("profiles")
+                .select("country, language")
+                .eq("id", user_id)
+                .execute()
+            )
+
+            if response.data:
+                profile = response.data[0]
+                country = profile.get('country', 'US')
+                language = profile.get('language', 'en')
+                return {'country': country, 'language': language}
+            else:
+                # Return default values if no profile found
+                return {'country': 'US', 'language': 'en'}
+        except Exception as e:
+            current_app.logger.error(f"Error fetching user preferences: {str(e)}")
+            # Return default values if there's an error
+            return {'country': 'US', 'language': 'en'}
+
+    def _merge_dataframes(self, df1: pd.DataFrame, df2: pd.DataFrame) -> pd.DataFrame:
+        """
+        Merge two dataframes removing duplicates based on article URL and sort by date.
+
+        Args:
+            df1 (pd.DataFrame): First dataframe containing articles
+            df2 (pd.DataFrame): Second dataframe containing articles
+
+        Returns:
+            pd.DataFrame: Merged dataframe with duplicates removed and sorted by date
+        """
+        # Concatenate both dataframes
+        combined_df = pd.concat([df1, df2], ignore_index=True)
+
+        # Remove duplicates based on the 'link' column to avoid duplication
+        combined_df = combined_df.drop_duplicates(subset=['link'], keep='first')
+
+        # Sort by date in descending order (most recent first)
+        if 'date' in combined_df.columns:
+            combined_df['date'] = pd.to_datetime(combined_df['date'], errors='coerce', utc=True)
+            combined_df = combined_df.sort_values(by='date', ascending=False)
+            combined_df = combined_df.reset_index(drop=True)
+
+        return combined_df

backend/utils/country_language_data.py

@@ -0,0 +1,265 @@
+"""
+Country and Language Data for Registration Form
+
+This module provides lists of ISO 3166-1 alpha-2 country codes and ISO 639-1 language codes
+for use in the registration form dropdowns.
+"""
+
+# ISO 3166-1 alpha-2 country codes with their full names
+COUNTRIES = [
+    {'code': 'AF', 'name': 'Afghanistan'},
+    {'code': 'AX', 'name': 'Åland Islands'},
+    {'code': 'AL', 'name': 'Albania'},
+    {'code': 'DZ', 'name': 'Algeria'},
+    {'code': 'AS', 'name': 'American Samoa'},
+    {'code': 'AD', 'name': 'Andorra'},
+    {'code': 'AO', 'name': 'Angola'},
+    {'code': 'AI', 'name': 'Anguilla'},
+    {'code': 'AQ', 'name': 'Antarctica'},
+    {'code': 'AG', 'name': 'Antigua and Barbuda'},
+    {'code': 'AR', 'name': 'Argentina'},
+    {'code': 'AM', 'name': 'Armenia'},
+    {'code': 'AW', 'name': 'Aruba'},
+    {'code': 'AU', 'name': 'Australia'},
+    {'code': 'AT', 'name': 'Austria'},
+    {'code': 'AZ', 'name': 'Azerbaijan'},
+    {'code': 'BS', 'name': 'Bahamas'},
+    {'code': 'BH', 'name': 'Bahrain'},
+    {'code': 'BD', 'name': 'Bangladesh'},
+    {'code': 'BB', 'name': 'Barbados'},
+    {'code': 'BY', 'name': 'Belarus'},
+    {'code': 'BE', 'name': 'Belgium'},
+    {'code': 'BZ', 'name': 'Belize'},
+    {'code': 'BJ', 'name': 'Benin'},
+    {'code': 'BM', 'name': 'Bermuda'},
+    {'code': 'BT', 'name': 'Bhutan'},
+    {'code': 'BO', 'name': 'Bolivia (Plurinational State of)'},
+    {'code': 'BQ', 'name': 'Bonaire, Sint Eustatius and Saba'},
+    {'code': 'BA', 'name': 'Bosnia and Herzegovina'},
+    {'code': 'BW', 'name': 'Botswana'},
+    {'code': 'BV', 'name': 'Bouvet Island'},
+    {'code': 'BR', 'name': 'Brazil'},
+    {'code': 'IO', 'name': 'British Indian Ocean Territory'},
+    {'code': 'BN', 'name': 'Brunei Darussalam'},
+    {'code': 'BG', 'name': 'Bulgaria'},
+    {'code': 'BF', 'name': 'Burkina Faso'},
+    {'code': 'BI', 'name': 'Burundi'},
+    {'code': 'CV', 'name': 'Cabo Verde'},
+    {'code': 'KH', 'name': 'Cambodia'},
+    {'code': 'CM', 'name': 'Cameroon'},
+    {'code': 'CA', 'name': 'Canada'},
+    {'code': 'KY', 'name': 'Cayman Islands'},
+    {'code': 'CF', 'name': 'Central African Republic'},
+    {'code': 'TD', 'name': 'Chad'},
+    {'code': 'CL', 'name': 'Chile'},
+    {'code': 'CN', 'name': 'China'},
+    {'code': 'CX', 'name': 'Christmas Island'},
+    {'code': 'CC', 'name': 'Cocos (Keeling) Islands'},
+    {'code': 'CO', 'name': 'Colombia'},
+    {'code': 'KM', 'name': 'Comoros'},
+    {'code': 'CG', 'name': 'Congo'},
+    {'code': 'CD', 'name': 'Congo, Democratic Republic of the'},
+    {'code': 'CK', 'name': 'Cook Islands'},
+    {'code': 'CR', 'name': 'Costa Rica'},
+    {'code': 'CI', 'name': 'Côte d\'Ivoire'},
+    {'code': 'HR', 'name': 'Croatia'},
+    {'code': 'CU', 'name': 'Cuba'},
+    {'code': 'CW', 'name': 'Curaçao'},
+    {'code': 'CY', 'name': 'Cyprus'},
+    {'code': 'CZ', 'name': 'Czechia'},
+    {'code': 'DK', 'name': 'Denmark'},
+    {'code': 'DJ', 'name': 'Djibouti'},
+    {'code': 'DM', 'name': 'Dominica'},
+    {'code': 'DO', 'name': 'Dominican Republic'},
+    {'code': 'EC', 'name': 'Ecuador'},
+    {'code': 'EG', 'name': 'Egypt'},
+    {'code': 'SV', 'name': 'El Salvador'},
+    {'code': 'GQ', 'name': 'Equatorial Guinea'},
+    {'code': 'ER', 'name': 'Eritrea'},
+    {'code': 'EE', 'name': 'Estonia'},
+    {'code': 'SZ', 'name': 'Eswatini'},
+    {'code': 'ET', 'name': 'Ethiopia'},
+    {'code': 'FK', 'name': 'Falkland Islands (Malvinas)'},
+    {'code': 'FO', 'name': 'Faroe Islands'},
+    {'code': 'FJ', 'name': 'Fiji'},
+    {'code': 'FI', 'name': 'Finland'},
+    {'code': 'FR', 'name': 'France'},
+    {'code': 'GF', 'name': 'French Guiana'},
+    {'code': 'PF', 'name': 'French Polynesia'},
+    {'code': 'TF', 'name': 'French Southern Territories'},
+    {'code': 'GA', 'name': 'Gabon'},
+    {'code': 'GM', 'name': 'Gambia'},
+    {'code': 'GE', 'name': 'Georgia'},
+    {'code': 'DE', 'name': 'Germany'},
+    {'code': 'GH', 'name': 'Ghana'},
+    {'code': 'GI', 'name': 'Gibraltar'},
+    {'code': 'GR', 'name': 'Greece'},
+    {'code': 'GL', 'name': 'Greenland'},
+    {'code': 'GD', 'name': 'Grenada'},
+    {'code': 'GP', 'name': 'Guadeloupe'},
+    {'code': 'GU', 'name': 'Guam'},
+    {'code': 'GT', 'name': 'Guatemala'},
+    {'code': 'GG', 'name': 'Guernsey'},
+    {'code': 'GN', 'name': 'Guinea'},
+    {'code': 'GW', 'name': 'Guinea-Bissau'},
+    {'code': 'GY', 'name': 'Guyana'},
+    {'code': 'HT', 'name': 'Haiti'},
+    {'code': 'HM', 'name': 'Heard Island and McDonald Islands'},
+    {'code': 'VA', 'name': 'Holy See'},
+    {'code': 'HN', 'name': 'Honduras'},
+    {'code': 'HK', 'name': 'Hong Kong'},
+    {'code': 'HU', 'name': 'Hungary'},
+    {'code': 'IS', 'name': 'Iceland'},
+    {'code': 'IN', 'name': 'India'},
+    {'code': 'ID', 'name': 'Indonesia'},
+    {'code': 'IR', 'name': 'Iran (Islamic Republic of)'},
+    {'code': 'IQ', 'name': 'Iraq'},
+    {'code': 'IE', 'name': 'Ireland'},
+    {'code': 'IM', 'name': 'Isle of Man'},
+    {'code': 'IL', 'name': 'Israel'},
+    {'code': 'IT', 'name': 'Italy'},
+    {'code': 'JM', 'name': 'Jamaica'},
+    {'code': 'JP', 'name': 'Japan'},
+    {'code': 'JE', 'name': 'Jersey'},
+    {'code': 'JO', 'name': 'Jordan'},
+    {'code': 'KZ', 'name': 'Kazakhstan'},
+    {'code': 'KE', 'name': 'Kenya'},
+    {'code': 'KI', 'name': 'Kiribati'},
+    {'code': 'KP', 'name': 'Korea (Democratic People\'s Republic of)'},
+    {'code': 'KR', 'name': 'Korea, Republic of'},
+    {'code': 'KW', 'name': 'Kuwait'},
+    {'code': 'KG', 'name': 'Kyrgyzstan'},
+    {'code': 'LA', 'name': 'Lao People\'s Democratic Republic'},
+    {'code': 'LV', 'name': 'Latvia'},
+    {'code': 'LB', 'name': 'Lebanon'},
+    {'code': 'LS', 'name': 'Lesotho'},
+    {'code': 'LR', 'name': 'Liberia'},
+    {'code': 'LY', 'name': 'Libya'},
+    {'code': 'LI', 'name': 'Liechtenstein'},
+    {'code': 'LT', 'name': 'Lithuania'},
+    {'code': 'LU', 'name': 'Luxembourg'},
+    {'code': 'MO', 'name': 'Macao'},
+    {'code': 'MG', 'name': 'Madagascar'},
+    {'code': 'MW', 'name': 'Malawi'},
+    {'code': 'MY', 'name': 'Malaysia'},
+    {'code': 'MV', 'name': 'Maldives'},
+    {'code': 'ML', 'name': 'Mali'},
+    {'code': 'MT', 'name': 'Malta'},
+    {'code': 'MH', 'name': 'Marshall Islands'},
+    {'code': 'MQ', 'name': 'Martinique'},
+    {'code': 'MR', 'name': 'Mauritania'},
+    {'code': 'MU', 'name': 'Mauritius'},
+    {'code': 'YT', 'name': 'Mayotte'},
+    {'code': 'MX', 'name': 'Mexico'},
+    {'code': 'FM', 'name': 'Micronesia (Federated States of)'},
+    {'code': 'MD', 'name': 'Moldova, Republic of'},
+    {'code': 'MC', 'name': 'Monaco'},
+    {'code': 'MN', 'name': 'Mongolia'},
+    {'code': 'ME', 'name': 'Montenegro'},
+    {'code': 'MS', 'name': 'Montserrat'},
+    {'code': 'MA', 'name': 'Morocco'},
+    {'code': 'MZ', 'name': 'Mozambique'},
+    {'code': 'MM', 'name': 'Myanmar'},
+    {'code': 'NA', 'name': 'Namibia'},
+    {'code': 'NR', 'name': 'Nauru'},
+    {'code': 'NP', 'name': 'Nepal'},
+    {'code': 'NL', 'name': 'Netherlands'},
+    {'code': 'NC', 'name': 'New Caledonia'},
+    {'code': 'NZ', 'name': 'New Zealand'},
+    {'code': 'NI', 'name': 'Nicaragua'},
+    {'code': 'NE', 'name': 'Niger'},
+    {'code': 'NG', 'name': 'Nigeria'},
+    {'code': 'NU', 'name': 'Niue'},
+    {'code': 'NF', 'name': 'Norfolk Island'},
+    {'code': 'MK', 'name': 'North Macedonia'},
+    {'code': 'MP', 'name': 'Northern Mariana Islands'},
+    {'code': 'NO', 'name': 'Norway'},
+    {'code': 'OM', 'name': 'Oman'},
+    {'code': 'PK', 'name': 'Pakistan'},
+    {'code': 'PW', 'name': 'Palau'},
+    {'code': 'PS', 'name': 'Palestine, State of'},
+    {'code': 'PA', 'name': 'Panama'},
+    {'code': 'PG', 'name': 'Papua New Guinea'},
+    {'code': 'PY', 'name': 'Paraguay'},
+    {'code': 'PE', 'name': 'Peru'},
+    {'code': 'PH', 'name': 'Philippines'},
+    {'code': 'PN', 'name': 'Pitcairn'},
+    {'code': 'PL', 'name': 'Poland'},
+    {'code': 'PT', 'name': 'Portugal'},
+    {'code': 'PR', 'name': 'Puerto Rico'},
+    {'code': 'QA', 'name': 'Qatar'},
+    {'code': 'RE', 'name': 'Réunion'},
+    {'code': 'RO', 'name': 'Romania'},
+    {'code': 'RU', 'name': 'Russian Federation'},
+    {'code': 'RW', 'name': 'Rwanda'},
+    {'code': 'BL', 'name': 'Saint Barthélemy'},
+    {'code': 'SH', 'name': 'Saint Helena, Ascension and Tristan da Cunha'},
+    {'code': 'KN', 'name': 'Saint Kitts and Nevis'},
+    {'code': 'LC', 'name': 'Saint Lucia'},
+    {'code': 'MF', 'name': 'Saint Martin (French part)'},
+    {'code': 'PM', 'name': 'Saint Pierre and Miquelon'},
+    {'code': 'VC', 'name': 'Saint Vincent and the Grenadines'},
+    {'code': 'WS', 'name': 'Samoa'},
+    {'code': 'SM', 'name': 'San Marino'},
+    {'code': 'ST', 'name': 'Sao Tome and Principe'},
+    {'code': 'SA', 'name': 'Saudi Arabia'},
+    {'code': 'SN', 'name': 'Senegal'},
+    {'code': 'RS', 'name': 'Serbia'},
+    {'code': 'SC', 'name': 'Seychelles'},
+    {'code': 'SL', 'name': 'Sierra Leone'},
+    {'code': 'SG', 'name': 'Singapore'},
+    {'code': 'SX', 'name': 'Sint Maarten (Dutch part)'},
+    {'code': 'SK', 'name': 'Slovakia'},
+    {'code': 'SI', 'name': 'Slovenia'},
+    {'code': 'SB', 'name': 'Solomon Islands'},
+    {'code': 'SO', 'name': 'Somalia'},
+    {'code': 'ZA', 'name': 'South Africa'},
+    {'code': 'GS', 'name': 'South Georgia and the South Sandwich Islands'},
+    {'code': 'SS', 'name': 'South Sudan'},
+    {'code': 'ES', 'name': 'Spain'},
+    {'code': 'LK', 'name': 'Sri Lanka'},
+    {'code': 'SD', 'name': 'Sudan'},
+    {'code': 'SR', 'name': 'Suriname'},
+    {'code': 'SJ', 'name': 'Svalbard and Jan Mayen'},
+    {'code': 'SE', 'name': 'Sweden'},
+    {'code': 'CH', 'name': 'Switzerland'},
+    {'code': 'SY', 'name': 'Syrian Arab Republic'},
+    {'code': 'TW', 'name': 'Taiwan, Province of China'},
+    {'code': 'TJ', 'name': 'Tajikistan'},
+    {'code': 'TZ', 'name': 'Tanzania, United Republic of'},
+    {'code': 'TH', 'name': 'Thailand'},
+    {'code': 'TL', 'name': 'Timor-Leste'},
+    {'code': 'TG', 'name': 'Togo'},
+    {'code': 'TK', 'name': 'Tokelau'},
+    {'code': 'TO', 'name': 'Tonga'},
+    {'code': 'TT', 'name': 'Trinidad and Tobago'},
+    {'code': 'TN', 'name': 'Tunisia'},
+    {'code': 'TR', 'name': 'Turkey'},
+    {'code': 'TM', 'name': 'Turkmenistan'},
+    {'code': 'TC', 'name': 'Turks and Caicos Islands'},
+    {'code': 'TV', 'name': 'Tuvalu'},
+    {'code': 'UG', 'name': 'Uganda'},
+    {'code': 'UA', 'name': 'Ukraine'},
+    {'code': 'AE', 'name': 'United Arab Emirates'},
+    {'code': 'GB', 'name': 'United Kingdom of Great Britain and Northern Ireland'},
+    {'code': 'US', 'name': 'United States of America'},
+    {'code': 'UM', 'name': 'United States Minor Outlying Islands'},
+    {'code': 'UY', 'name': 'Uruguay'},
+    {'code': 'UZ', 'name': 'Uzbekistan'},
+    {'code': 'VU', 'name': 'Vanuatu'},
+    {'code': 'VE', 'name': 'Venezuela (Bolivarian Republic of)'},
+    {'code': 'VN', 'name': 'Viet Nam'},
+    {'code': 'VG', 'name': 'Virgin Islands (British)'},
+    {'code': 'VI', 'name': 'Virgin Islands (U.S.)'},
+    {'code': 'WF', 'name': 'Wallis and Futuna'},
+    {'code': 'EH', 'name': 'Western Sahara'},
+    {'code': 'YE', 'name': 'Yemen'},
+    {'code': 'ZM', 'name': 'Zambia'},
+    {'code': 'ZW', 'name': 'Zimbabwe'},
+]
+
+# ISO 639-1 language codes with their full names - focusing on English and French as specified in the requirements
+LANGUAGES = [
+    {'code': 'en', 'name': 'English'},
+    {'code': 'fr', 'name': 'French'},
+]

docu_code/My_data_base_schema_.txt

@@ -56,6 +56,8 @@ CREATE TABLE public.profiles (
   raw_user_meta jsonb,
   created_at timestamp with time zone DEFAULT now(),
   updated_at timestamp with time zone,
+  country character varying,
+  language character varying,
   CONSTRAINT profiles_pkey PRIMARY KEY (id),
   CONSTRAINT profiles_id_fkey FOREIGN KEY (id) REFERENCES auth.users(id)
 );

frontend/src/pages/Register.jsx

@@ -9,90 +9,122 @@ const Register = () => {
   const { isAuthenticated, loading, error } = useSelector(state => state.auth);
   // Convert string loading state to boolean for the button
   const isLoading = loading === 'pending';
-  
+
+  const [countryOptions, setCountryOptions] = useState([]);
+  const [languageOptions, setLanguageOptions] = useState([]);
+  const [loadingOptions, setLoadingOptions] = useState(false);
+
   const [formData, setFormData] = useState({
     email: '',
     password: '',
-    confirmPassword: ''
+    confirmPassword: '',
+    country: '',
+    language: ''
   });
-  
+
   const [showPassword, setShowPassword] = useState(false);
   const [showConfirmPassword, setShowConfirmPassword] = useState(false);
   const [passwordStrength, setPasswordStrength] = useState(0);
   const [isFocused, setIsFocused] = useState({
     email: false,
     password: false,
-    confirmPassword: false
+    confirmPassword: false,
+    country: false,
+    language: false
   });
-  
+
   useEffect(() => {
     if (isAuthenticated) {
       navigate('/dashboard');
     }
-    
+
     // Clear any existing errors when component mounts
     dispatch(clearError());
+
+    // Load registration options
+    const loadOptions = async () => {
+      setLoadingOptions(true);
+      try {
+        const response = await fetch('/api/auth/registration-options');
+        if (response.ok) {
+          const data = await response.json();
+          if (data.success) {
+            setCountryOptions(data.countries);
+            setLanguageOptions(data.languages);
+          }
+        }
+      } catch (err) {
+        console.error('Failed to load registration options:', err);
+        // Use fallback options if API call fails
+        setCountryOptions([{ code: 'US', name: 'United States' }, { code: 'FR', name: 'France' }]);
+        setLanguageOptions([{ code: 'en', name: 'English' }, { code: 'fr', name: 'French' }]);
+      } finally {
+        setLoadingOptions(false);
+      }
+    };
+
+    loadOptions();
   }, [isAuthenticated, navigate, dispatch]);
-  
+
   const handleChange = (e) => {
     const { name, value } = e.target;
     setFormData({
       ...formData,
       [name]: value
     });
-    
+
     // Calculate password strength
     if (name === 'password') {
       calculatePasswordStrength(value);
     }
   };
-  
+
   const calculatePasswordStrength = (password) => {
     let strength = 0;
-    
+
     // Length check
     if (password.length >= 8) strength += 1;
     if (password.length >= 12) strength += 1;
-    
+
     // Character variety checks
     if (/[a-z]/.test(password)) strength += 1;
     if (/[A-Z]/.test(password)) strength += 1;
     if (/[0-9]/.test(password)) strength += 1;
     if (/[^A-Za-z0-9]/.test(password)) strength += 1;
-    
+
     setPasswordStrength(Math.min(strength, 6));
   };
-  
+
   const handleFocus = (field) => {
     setIsFocused({
       ...isFocused,
       [field]: true
     });
   };
-  
+
   const handleBlur = (field) => {
     setIsFocused({
       ...isFocused,
       [field]: false
     });
   };
-  
+
   const [showSuccess, setShowSuccess] = useState(false);
-  
+
   const handleSubmit = async (e) => {
     e.preventDefault();
-    
+
     // Basic validation
     if (formData.password !== formData.confirmPassword) {
       alert('Passwords do not match');
       return;
     }
-    
+
     if (formData.password.length < 8) {
       alert('Password must be at least 8 characters long');
       return;
     }
-    
+
     try {
       await dispatch(registerUser(formData)).unwrap();
       // Show success message
@@ -106,24 +138,24 @@ const Register = () => {
       console.error('Registration failed:', err);
     }
   };
-  
+
   const togglePasswordVisibility = () => {
     setShowPassword(!showPassword);
   };
-  
+
   const toggleConfirmPasswordVisibility = () => {
     setShowConfirmPassword(!showConfirmPassword);
   };
-  
+
   const toggleForm = () => {
     dispatch(clearError());
     navigate('/login');
   };
-  
+
   if (isAuthenticated) {
     return null; // Redirect handled by useEffect
   }
-  
+
   return (
     <div className="min-h-screen bg-gradient-to-br from-primary-50 via-white to-accent-50 flex items-center justify-center p-3 sm:p-4 animate-fade-in">
       <div className="w-full max-w-sm sm:max-w-md">
@@ -135,7 +167,7 @@ const Register = () => {
           <h1 className="text-2xl sm:text-3xl font-bold text-gray-900 mb-1 sm:mb-2">Create Account</h1>
           <p className="text-sm sm:text-base text-gray-600">Sign up to get started with Lin</p>
         </div>
-        
+
         {/* Auth Card */}
         <div className="bg-white rounded-2xl shadow-xl p-4 sm:p-8 space-y-4 sm:space-y-6 animate-slide-up animate-delay-100">
           {/* Success Message */}
@@ -163,7 +195,7 @@ const Register = () => {
               </div>
             </div>
           )}
-          
+
           {/* Register Form */}
           <form onSubmit={handleSubmit} className="space-y-4 sm:space-y-5">
             {/* Email Field */}
@@ -198,7 +230,75 @@ const Register = () => {
                 </div>
               </div>
             </div>
-            
+
+            {/* Country Selection */}
+            <div className="space-y-2">
+              <label htmlFor="country" className="block text-xs sm:text-sm font-semibold text-gray-700">
+                Country
+              </label>
+              <select
+                id="country"
+                name="country"
+                value={formData.country}
+                onChange={handleChange}
+                onFocus={() => handleFocus('country')}
+                onBlur={() => handleBlur('country')}
+                className={`w-full px-3 sm:px-4 py-2 sm:py-3 rounded-xl border-2 transition-all duration-200 ${
+                  isFocused.country
+                    ? 'border-primary-500 shadow-md'
+                    : 'border-gray-200 hover:border-gray-300'
+                } ${formData.country ? 'text-gray-900' : 'text-gray-500'} focus:outline-none focus:ring-2 focus:ring-primary-500 focus:ring-offset-2 touch-manipulation`}
+                required
+                aria-required="true"
+                aria-label="Select your country"
+              >
+                <option value="">Select a country</option>
+                {loadingOptions ? (
+                  <option value="">Loading...</option>
+                ) : (
+                  countryOptions.map(country => (
+                    <option key={country.code} value={country.code}>
+                      {country.name}
+                    </option>
+                  ))
+                )}
+              </select>
+            </div>
+
+            {/* Language Selection */}
+            <div className="space-y-2">
+              <label htmlFor="language" className="block text-xs sm:text-sm font-semibold text-gray-700">
+                Language
+              </label>
+              <select
+                id="language"
+                name="language"
+                value={formData.language}
+                onChange={handleChange}
+                onFocus={() => handleFocus('language')}
+                onBlur={() => handleBlur('language')}
+                className={`w-full px-3 sm:px-4 py-2 sm:py-3 rounded-xl border-2 transition-all duration-200 ${
+                  isFocused.language
+                    ? 'border-primary-500 shadow-md'
+                    : 'border-gray-200 hover:border-gray-300'
+                } ${formData.language ? 'text-gray-900' : 'text-gray-500'} focus:outline-none focus:ring-2 focus:ring-primary-500 focus:ring-offset-2 touch-manipulation`}
+                required
+                aria-required="true"
+                aria-label="Select your language"
+              >
+                <option value="">Select a language</option>
+                {loadingOptions ? (
+                  <option value="">Loading...</option>
+                ) : (
+                  languageOptions.map(lang => (
+                    <option key={lang.code} value={lang.code}>
+                      {lang.name}
+                    </option>
+                  ))
+                )}
+              </select>
+            </div>
+
             {/* Password Field */}
             <div className="space-y-2">
               <label htmlFor="password" className="block text-xs sm:text-sm font-semibold text-gray-700">
@@ -242,7 +342,7 @@ const Register = () => {
                   )}
                 </button>
               </div>
-              
+
               {/* Password Strength Indicator */}
               {formData.password && (
                 <div className="space-y-1">
@@ -274,7 +374,7 @@ const Register = () => {
                 </div>
               )}
             </div>
-            
+
             {/* Confirm Password Field */}
             <div className="space-y-2">
               <label htmlFor="confirmPassword" className="block text-xs sm:text-sm font-semibold text-gray-700">
@@ -322,7 +422,7 @@ const Register = () => {
                 <p className="text-red-600 text-xs">Passwords do not match</p>
               )}
             </div>
-            
+
             {/* Terms and Conditions */}
             <div className="flex items-start">
               <input
@@ -344,7 +444,7 @@ const Register = () => {
                 </a>
               </label>
             </div>
-            
+
             {/* Submit Button */}
             <button
               type="submit"
@@ -364,7 +464,7 @@ const Register = () => {
                 <span className="text-xs sm:text-sm">Create Account</span>
               )}
             </button>
-            
+
             {/* Confirmation Message */}
             {!error && !showSuccess && (
               <div className="text-center text-xs sm:text-sm text-gray-600">
@@ -372,8 +472,8 @@ const Register = () => {
               </div>
             )}
           </form>
-          
-          
+
+
           {/* Login Link */}
           <div className="text-center">
             <p className="text-xs sm:text-sm text-gray-600">
@@ -389,7 +489,7 @@ const Register = () => {
             </p>
           </div>
         </div>
-        
+
         {/* Footer */}
         <div className="text-center mt-6 sm:mt-8 text-xs text-gray-500">
           <p>&copy; 2024 Lin. All rights reserved.</p>

frontend/src/services/authService.js

@@ -10,6 +10,8 @@ class AuthService {
    * @param {Object} userData - User registration data
    * @param {string} userData.email - User email
    * @param {string} userData.password - User password
+   * @param {string} [userData.country] - User country (ISO 3166-1 alpha-2 code)
+   * @param {string} [userData.language] - User language (ISO 639-1 code)
    * @returns {Promise<Object>} - API response
    */
   async register(userData) {
@@ -23,7 +25,7 @@ class AuthService {
           fullData: userData
         });
       }
-      
+
       const response = await apiClient.post('/auth/register', userData);
       return response;
     } catch (error) {

frontend/src/store/reducers/authSlice.js

@@ -28,18 +28,18 @@ export const checkCachedAuth = createAsyncThunk(
   async (_, { rejectWithValue }) => {
     try {
       const isDevelopment = import.meta.env.VITE_NODE_ENV === 'development';
-      
+
       if (isDevelopment) {
         console.log('🔐 [Auth] Starting cached authentication check');
       }
-      
+
       // First check cache
       const cachedAuth = await cacheService.getAuthCache();
       if (cachedAuth) {
         if (isDevelopment) {
           console.log('🗃️ [Cache] Found cached authentication data');
         }
-        
+
         // Validate that the cached token is still valid by checking expiry
         if (cachedAuth.expiresAt && Date.now() < cachedAuth.expiresAt) {
           return {
@@ -58,18 +58,18 @@ export const checkCachedAuth = createAsyncThunk(
           await cacheService.clearAuthCache();
         }
       }
-      
+
       // If not in cache or expired, check cookies
       if (isDevelopment) {
         console.log('🍪 [Cookie] Checking for authentication cookies');
       }
-      
+
       const cookieAuth = await cookieService.getAuthTokens();
       if (cookieAuth?.accessToken) {
         if (isDevelopment) {
           console.log('🍪 [Cookie] Found authentication cookies, validating with API');
         }
-        
+
         // Validate token and get user data
         try {
           const response = await authService.getCurrentUser();
@@ -79,15 +79,15 @@ export const checkCachedAuth = createAsyncThunk(
               token: cookieAuth.accessToken,
               user: response.data.user
             }, cookieAuth.rememberMe);
-            
+
             const expiresAt = cookieAuth.rememberMe ?
               Date.now() + (7 * 24 * 60 * 60 * 1000) :
               Date.now() + (60 * 60 * 1000);
-            
+
             if (isDevelopment) {
               console.log('✅ [Auth] Cookie authentication validated successfully');
             }
-            
+
             return {
               success: true,
               user: response.data.user,
@@ -113,7 +113,7 @@ export const checkCachedAuth = createAsyncThunk(
           console.log('🍪 [Cookie] No authentication cookies found');
         }
       }
-      
+
       if (isDevelopment) {
         console.log('🔐 [Auth] No valid cached or cookie authentication found');
       }
@@ -136,16 +136,16 @@ export const autoLogin = createAsyncThunk(
       if (isDevelopment) {
         console.log('🔐 [Auth] Starting auto login process');
       }
-      
+
       // Try to get token from cookies first, then fallback to localStorage
       let token = null;
       let rememberMe = false;
-      
+
       try {
         const cookieAuth = await cookieService.getAuthTokens();
         token = cookieAuth?.accessToken;
         rememberMe = cookieAuth?.rememberMe || false;
-        
+
         if (isDevelopment) {
           console.log('🍪 [Cookie] Got tokens from cookie service:', { token: !!token, rememberMe });
         }
@@ -154,7 +154,7 @@ export const autoLogin = createAsyncThunk(
           console.warn('🍪 [Cookie] Error getting cookie tokens, trying localStorage:', cookieError.message);
         }
       }
-      
+
       // If no cookie token, try localStorage
       if (!token) {
         token = localStorage.getItem('token');
@@ -162,14 +162,14 @@ export const autoLogin = createAsyncThunk(
           console.log('💾 [Storage] Got token from localStorage:', !!token);
         }
       }
-      
+
       if (token) {
         try {
           // Try to validate token and get user data
           if (isDevelopment) {
             console.log('🔑 [Token] Validating token with API');
           }
-          
+
           const response = await authService.getCurrentUser();
           if (response.data.success) {
             // Update cache and cookies
@@ -177,14 +177,14 @@ export const autoLogin = createAsyncThunk(
               token: token,
               user: response.data.user
             }, rememberMe);
-            
+
             // Ensure cookies are set
             await cookieService.setAuthTokens(token, rememberMe);
-            
+
             if (isDevelopment) {
               console.log('✅ [Auth] Auto login successful');
             }
-            
+
             return {
               success: true,
               user: response.data.user,
@@ -202,7 +202,7 @@ export const autoLogin = createAsyncThunk(
           }
         }
       }
-      
+
       if (isDevelopment) {
         console.log('🔐 [Auth] Auto login failed - no valid token found');
       }
@@ -211,11 +211,11 @@ export const autoLogin = createAsyncThunk(
       // Clear tokens on error
       localStorage.removeItem('token');
       await cookieService.clearAuthTokens();
-      
+
       if (import.meta.env.VITE_NODE_ENV === 'development') {
         console.error('🔐 [Auth] Auto login error:', error);
       }
-      
+
       return rejectWithValue('Auto login failed');
     }
   }
@@ -229,10 +229,12 @@ export const registerUser = createAsyncThunk(
       // Send only the data that Supabase needs
       const transformedData = {
         email: userData.email,
-        password: userData.password
+        password: userData.password,
+        country: userData.country,      // User's selected country code
+        language: userData.language     // User's selected language code
         // Note: confirmPassword is not sent to Supabase as it handles validation automatically
       };
-      
+
       // Debug log to verify transformation
       if (import.meta.env.VITE_NODE_ENV === 'development') {
         console.log('🔄 [Auth] Transforming registration data:', {
@@ -240,7 +242,7 @@ export const registerUser = createAsyncThunk(
           transformed: transformedData
         });
       }
-      
+
       const response = await authService.register(transformedData);
       return response.data;
     } catch (error) {
@@ -255,7 +257,7 @@ export const loginUser = createAsyncThunk(
     try {
       const response = await authService.login(credentials);
       const result = response.data;
-      
+
       if (result.success) {
         // Store auth data in cache
         const rememberMe = credentials.rememberMe || false;
@@ -263,17 +265,17 @@ export const loginUser = createAsyncThunk(
           token: result.token,
           user: result.user
         }, rememberMe);
-        
+
         // Store tokens in secure cookies
         await cookieService.setAuthTokens(result.token, rememberMe);
-        
+
         return {
           ...result,
           rememberMe,
           expiresAt: rememberMe ? Date.now() + (7 * 24 * 60 * 60 * 1000) : Date.now() + (60 * 60 * 1000)
         };
       }
-      
+
       return result;
     } catch (error) {
       return rejectWithValue(error.response?.data || { success: false, message: 'Login failed' });
@@ -311,10 +313,10 @@ export const logoutUser = createAsyncThunk(
     try {
       // Clear cache first
       await cacheService.clearAuthCache();
-      
+
       // Clear cookies
       await cookieService.clearAuthTokens();
-      
+
       // Then call logout API
       const response = await authService.logout();
       return response.data;
@@ -349,14 +351,14 @@ const authSlice = createSlice({
       state.error = null;
       state.loading = 'idle';
     },
-    
+
     setUser: (state, action) => {
       state.user = action.payload.user;
       state.isAuthenticated = true;
       state.loading = 'succeeded';
       state.error = null;
     },
-    
+
     clearAuth: (state) => {
       state.user = null;
       state.isAuthenticated = false;
@@ -374,15 +376,15 @@ const authSlice = createSlice({
         deviceFingerprint: null
       };
     },
-    
+
     updateSecurityStatus: (state, action) => {
       state.security = { ...state.security, ...action.payload };
     },
-    
+
     updateCacheInfo: (state, action) => {
       state.cache = { ...state.cache, ...action.payload };
     },
-    
+
     setRememberMe: (state, action) => {
       state.cache.isRemembered = action.payload;
     }
@@ -440,7 +442,7 @@ const authSlice = createSlice({
       .addCase(registerUser.fulfilled, (state, action) => {
         state.loading = 'succeeded';
         state.user = action.payload.user;
-        
+
         // Check if email confirmation is required
         if (action.payload.requires_confirmation) {
           state.isAuthenticated = false;
@@ -451,11 +453,11 @@ const authSlice = createSlice({
       })
       .addCase(registerUser.rejected, (state, action) => {
         state.loading = 'failed';
-        
+
         // Handle different error types with specific messages
         const errorPayload = action.payload;
         let errorMessage = 'Registration failed';
-        
+
         if (errorPayload) {
           if (errorPayload.message) {
             // Check for specific error types
@@ -473,7 +475,7 @@ const authSlice = createSlice({
             errorMessage = errorPayload;
           }
         }
-        
+
         state.error = errorMessage;
       })
 
@@ -488,18 +490,18 @@ const authSlice = createSlice({
         state.isAuthenticated = true;
         state.cache.isRemembered = action.payload.rememberMe || false;
         state.cache.expiresAt = action.payload.expiresAt;
-        
+
         // Store token securely
         localStorage.setItem('token', action.payload.token);
       })
       .addCase(loginUser.rejected, (state, action) => {
         state.loading = 'failed';
         state.security.failedAttempts += 1;
-        
+
         // Handle different error types with specific messages
         const errorPayload = action.payload;
         let errorMessage = 'Login failed';
-        
+
         if (errorPayload) {
           if (errorPayload.message) {
             // Check for specific error types
@@ -517,7 +519,7 @@ const authSlice = createSlice({
             errorMessage = errorPayload;
           }
         }
-        
+
         console.log('Setting Redux error:', errorMessage);
         state.error = errorMessage;
       })
@@ -530,7 +532,7 @@ const authSlice = createSlice({
         state.cache.isRemembered = false;
         state.cache.expiresAt = null;
         state.cache.deviceFingerprint = null;
-        
+
         // Clear all cached data (already done in the thunk)
         localStorage.removeItem('token');
       })
@@ -541,7 +543,7 @@ const authSlice = createSlice({
         state.cache.isRemembered = false;
         state.cache.expiresAt = null;
         state.cache.deviceFingerprint = null;
-        
+
         localStorage.removeItem('token');
       })
 
@@ -556,11 +558,11 @@ const authSlice = createSlice({
       })
       .addCase(forgotPassword.rejected, (state, action) => {
         state.loading = 'failed';
-        
+
         // Handle different error types with specific messages
         const errorPayload = action.payload;
         let errorMessage = 'Password reset request failed';
-        
+
         if (errorPayload) {
           if (errorPayload.message) {
             errorMessage = errorPayload.message;
@@ -568,7 +570,7 @@ const authSlice = createSlice({
             errorMessage = errorPayload;
           }
         }
-        
+
         state.error = errorMessage;
       })
 
@@ -583,11 +585,11 @@ const authSlice = createSlice({
       })
       .addCase(resetPassword.rejected, (state, action) => {
         state.loading = 'failed';
-        
+
         // Handle different error types with specific messages
         const errorPayload = action.payload;
         let errorMessage = 'Password reset failed';
-        
+
         if (errorPayload) {
           if (errorPayload.message) {
             // Check for specific error types
@@ -603,7 +605,7 @@ const authSlice = createSlice({
             errorMessage = errorPayload;
           }
         }
-        
+
         state.error = errorMessage;
       })