Create Customer

{
  "status": "success",
  "message": "Customer created successfully",
  "data": {
    "id": 47,
    "first_name": "Sarah",
    "last_name": "Johnson",
    "email": "sarah.johnson@email.com",
    "phone": "+1 555 987 6543",
    "status": "active",
    "customer_code": "CUST-2024-047",
    "avatar_url": "https://your-site.com/wp-content/plugins/latepoint/images/default-avatar.png",
    "date_of_birth": "1990-05-15",
    "gender": "female",
    "address": {
      "street": "123 Main Street, Apt 4B",
      "city": "New York",
      "state": "NY",
      "postal_code": "10001",
      "country": "US"
    },
    "preferences": {
      "preferred_agent_id": 3,
      "preferred_location_id": 1,
      "preferred_time_slots": ["09:00-12:00", "14:00-17:00"],
      "language": "en",
      "communication_preferences": {
        "email_notifications": true,
        "sms_notifications": true,
        "reminder_hours": 48,
        "marketing_emails": false
      }
    },
    "custom_fields": {
      "emergency_contact": "John Johnson - +1 555 111 2222",
      "insurance_provider": "Blue Cross Blue Shield",
      "referral_source": "Referral"
    },
    "notes": "VIP customer, prefers morning appointments",
    "created_at": "2024-01-20T15:30:00Z",
    "updated_at": "2024-01-20T15:30:00Z",
    "wp_user_id": 156,
    "welcome_email_sent": true
  }
}

// Validate email before creating
async function checkEmailAvailability(email) {
  const response = await fetch(`/wp-json/latepoint-api/v1/customers?search=${email}&search_field=email`, {
    headers: { 'X-API-Key': 'your_api_key' }
  });
  
  const result = await response.json();
  return result.data.length === 0; // true if available
}

const emailAvailable = await checkEmailAvailability('new@email.com');
if (!emailAvailable) {
  console.log('Email is already in use');
  return;
}

// Create customer with error handling
async function createCustomer(customerData) {
  try {
    const response = await fetch('/wp-json/latepoint-api/v1/customers', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': 'your_api_key'
      },
      body: JSON.stringify(customerData)
    });
    
    const result = await response.json();
    
    if (result.status === 'success') {
      return result.data;
    } else {
      throw new Error(result.error.message);
    }
  } catch (error) {
    console.error('Error creating customer:', error);
    throw error;
  }
}

// Actions after creating customer
async function handleCustomerCreated(customer) {
  console.log(`Customer created: ${customer.first_name} ${customer.last_name}`);
  console.log(`ID: ${customer.id}, Code: ${customer.customer_code}`);
  
  // Register in analytics
  if (typeof gtag !== 'undefined') {
    gtag('event', 'customer_created', {
      customer_id: customer.id,
      customer_email: customer.email
    });
  }
  
  // Show success message
  showSuccessMessage(`Welcome ${customer.first_name}! Your account has been created successfully.`);
  
  // Redirect or continue flow
  if (customer.wp_user_id) {
    // WordPress user created, can login
    window.location.href = '/my-account/';
  } else {
    // Continue with booking process
    window.location.href = `/booking?customer_id=${customer.id}`;
  }
}

// Create minimal customer during booking process
const quickCustomer = {
  first_name: 'John',
  last_name: 'Smith',
  email: 'john.smith@email.com',
  phone: '+1 555 123 4567',
  send_welcome_email: false, // Don't send email during booking
  create_wp_user: false // Don't create account for now
};

const customer = await createCustomer(quickCustomer);
console.log('Customer created for booking:', customer.id);

// Full registration with user account
const fullCustomer = {
  first_name: 'Mary',
  last_name: 'Johnson',
  email: 'mary.johnson@email.com',
  phone: '+1 555 987 6543',
  preferences: {
    language: 'en',
    communication_preferences: {
      email_notifications: true,
      sms_notifications: true,
      marketing_emails: false
    }
  },
  send_welcome_email: true,
  create_wp_user: true,
  wp_user_role: 'customer'
};

const customer = await createCustomer(fullCustomer);
console.log('Customer and user created:', customer);

// Import multiple customers
async function importCustomers(customersData) {
  const results = {
    success: [],
    errors: []
  };
  
  for (const customerData of customersData) {
    try {
      // Check if email already exists
      const emailExists = await checkEmailAvailability(customerData.email);
      if (!emailExists) {
        results.errors.push({
          email: customerData.email,
          error: 'Email already exists'
        });
        continue;
      }
      
      // Create customer
      const customer = await createCustomer({
        ...customerData,
        send_welcome_email: false, // Don't send bulk emails
        create_wp_user: false // Don't create users in bulk
      });
      
      results.success.push(customer);
      
      // Pause to avoid rate limiting
      await new Promise(resolve => setTimeout(resolve, 100));
      
    } catch (error) {
      results.errors.push({
        email: customerData.email,
        error: error.message
      });
    }
  }
  
  return results;
}

// Usage
const customersToImport = [
  { first_name: 'Anna', last_name: 'Williams', email: 'anna@email.com' },
  { first_name: 'Charles', last_name: 'Brown', email: 'charles@email.com' },
  // ... more customers
];

const importResults = await importCustomers(customersToImport);
console.log(`Imported: ${importResults.success.length}, Errors: ${importResults.errors.length}`);

// Validate data before sending
function validateCustomerForm(formData) {
  const errors = {};
  
  // Validate name
  if (!formData.first_name || formData.first_name.trim().length < 2) {
    errors.first_name = 'Name must be at least 2 characters';
  }
  
  // Validate email
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  if (!formData.email || !emailRegex.test(formData.email)) {
    errors.email = 'Invalid email';
  }
  
  // Validate phone (optional)
  if (formData.phone) {
    const phoneRegex = /^[\+]?[1-9][\d\s\-\(\)]{7,15}$/;
    if (!phoneRegex.test(formData.phone)) {
      errors.phone = 'Invalid phone format';
    }
  }
  
  return {
    isValid: Object.keys(errors).length === 0,
    errors
  };
}

// Function with automatic retries
async function createCustomerWithRetry(customerData, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await createCustomer(customerData);
    } catch (error) {
      if (attempt === maxRetries) {
        throw error;
      }
      
      // Only retry on network errors, not validation errors
      if (error.message.includes('validation') || error.message.includes('already_exists')) {
        throw error;
      }
      
      // Wait before next attempt
      await new Promise(resolve => setTimeout(resolve, 1000 * attempt));
    }
  }
}

// Create multiple customers efficiently
async function createCustomersBatch(customersData, batchSize = 5) {
  const results = [];
  
  for (let i = 0; i < customersData.length; i += batchSize) {
    const batch = customersData.slice(i, i + batchSize);
    
    const batchPromises = batch.map(customerData => 
      createCustomer(customerData).catch(error => ({ error: error.message, data: customerData }))
    );
    
    const batchResults = await Promise.all(batchPromises);
    results.push(...batchResults);
    
    // Pause between batches to respect rate limits
    if (i + batchSize < customersData.length) {
      await new Promise(resolve => setTimeout(resolve, 500));
    }
  }
  
  return results;
}