Free AI Code Generator

Create a Python function that validates email addresses. 
Requirements:
- Check for @ symbol presence
- Validate domain format (must have period)
- Accept list of common domains: gmail, yahoo, outlook, hotmail
- Return True for valid emails, False otherwise
- Handle edge cases: empty strings, multiple @ symbols, spaces

import re
from typing import List

def validate_email(email: str, allowed_domains: List[str] = None) -> bool:
    """
    Validates email addresses using regex pattern matching.
    
    Args:
        email: Email address string to validate
        allowed_domains: Optional list of allowed domains (gmail, yahoo, etc.)
    
    Returns:
        True if email is valid, False otherwise
    
    Examples:
        >>> validate_email('[email protected]')
        True
        >>> validate_email('invalid.email')
        False
        >>> validate_email('[email protected]', ['gmail', 'yahoo'])
        False
    """
    # Handle edge cases: empty string, None, whitespace
    if not email or not email.strip():
        return False
    
    # Remove leading/trailing whitespace
    email = email.strip()
    
    # Check for exactly one @ symbol
    if email.count('@') != 1:
        return False
    
    # Regex pattern for email validation
    # Pattern breakdown:
    # ^[a-zA-Z0-9._%+-]+ : Start with alphanumeric, dots, underscores, etc.
    # @ : Exactly one @ symbol
    # [a-zA-Z0-9.-]+ : Domain name with letters, numbers, dots, hyphens
    # \. : Literal period
    # [a-zA-Z]{2,}$ : Top-level domain (minimum 2 letters)
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    
    # Check basic email format
    if not re.match(pattern, email):
        return False
    
    # If allowed domains specified, verify domain
    if allowed_domains:
        domain = email.split('@')[1].split('.')[0].lower()
        return domain in [d.lower() for d in allowed_domains]
    
    return True

# Usage examples
print(validate_email('[email protected]'))  # True
print(validate_email('[email protected]', ['gmail', 'yahoo']))  # True
print(validate_email('invalid'))  # False
print(validate_email('user@@domain.com'))  # False

Generate an async JavaScript function that fetches user data from a REST API.
Requirements:
- Accept user ID as parameter
- Make GET request to /api/users/{id} endpoint
- Parse JSON response
- Handle network errors gracefully
- Return user object or null on error
- Include timeout of 5 seconds
- Add proper error logging

/**
 * Fetches user data from REST API endpoint
 * @param {number|string} userId - The unique user identifier
 * @param {number} timeout - Request timeout in milliseconds (default: 5000)
 * @returns {Promise<Object|null>} User object or null if request fails
 * 
 * @example
 * const user = await fetchUserData(123);
 * if (user) {
 *   console.log(user.name, user.email);
 * }
 */
async function fetchUserData(userId, timeout = 5000) {
  // Validate user ID
  if (!userId) {
    console.error('fetchUserData: userId is required');
    return null;
  }

  // Create AbortController for timeout
  const controller = new AbortController();
  const timeoutId = setTimeout(() => controller.abort(), timeout);

  try {
    // Make GET request with timeout signal
    const response = await fetch('/api/users/' + userId, {
      method: 'GET',
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      signal: controller.signal
    });

    // Clear timeout on successful response
    clearTimeout(timeoutId);

    // Check HTTP status code
    if (!response.ok) {
      console.error(
        'fetchUserData: HTTP error ' + response.status + ' - ' + response.statusText
      );
      return null;
    }

    // Parse JSON response
    const userData = await response.json();

    // Validate response structure
    if (!userData || typeof userData !== 'object') {
      console.error('fetchUserData: Invalid response format');
      return null;
    }

    return userData;

  } catch (error) {
    clearTimeout(timeoutId);

    // Handle different error types
    if (error.name === 'AbortError') {
      console.error('fetchUserData: Request timeout after ' + timeout + 'ms');
    } else if (error instanceof TypeError) {
      console.error('fetchUserData: Network error or CORS issue', error.message);
    } else {
      console.error('fetchUserData: Unexpected error', error);
    }

    return null;
  }
}

// Usage example
async function displayUser() {
  const user = await fetchUserData(123);
  
  if (user) {
    console.log('User found:', user.name);
    console.log('Email:', user.email);
  } else {
    console.log('Failed to load user data');
  }
}

displayUser();