REST API Integration Guide

// Capture click key from URL parameters
function captureClickKey() {
  const urlParams = new URLSearchParams(window.location.search);
  
  // Check for common click key parameter names
  const clickKey = urlParams.get('btag') || 
                   urlParams.get('clickId') || 
                   urlParams.get('clickkey') ||
                   urlParams.get('affiliate_id');
  
  if (clickKey) {
    // Store in cookie for 30 days (matching Affelios attribution window)
    document.cookie = `affiliate_click_key=${clickKey}; max-age=${30 * 24 * 60 * 60}; path=/`;
    console.log('Click key captured:', clickKey);
  }
}

// Call on page load
document.addEventListener('DOMContentLoaded', captureClickKey);

// Function to retrieve stored click key
function getStoredClickKey() {
  const cookies = document.cookie.split(';');
  for (let cookie of cookies) {
    const [name, value] = cookie.trim().split('=');
    if (name === 'affiliate_click_key') {
      return value;
    }
  }
  return null;
}

// Use during registration/purchase
async function submitRegistration(userData) {
  const clickKey = getStoredClickKey();
  
  const registrationData = {
    ...userData,
    affiliateClickKey: clickKey // Include with user data
  };
  
  // Submit to your backend
  const response = await fetch('/api/register', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(registrationData)
  });
  
  return response.json();
}

// Send customer to Affelios when they register
async function createAffeliosCustomer(customerData, clickKey) {
  const affeliosCustomer = {
    externalId: customerData.id, // Your internal customer ID
    brandId: process.env.AFFELIOS_BRAND_ID, // Your Affelios brand ID
    clickKey: clickKey, // Captured from tracking link
    username: customerData.username,
    registrationDate: new Date().toISOString(),
    country_code: customerData.countryCode
  };

  try {
    const response = await fetch('https://platform.affelios.com/api/v1/customer', {
      method: 'POST',
      headers: {
        'X-Api-Key': process.env.AFFELIOS_API_KEY,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify(affeliosCustomer)
    });

    if (!response.ok) {
      throw new Error(`Affelios API error: ${response.status} ${response.statusText}`);
    }

    const result = await response.json();
    console.log('Customer created in Affelios:', result.id);
    return result;
  } catch (error) {
    console.error('Failed to create customer in Affelios:', error);
    throw error;
  }
}

// Integration with your registration process
async function handleUserRegistration(userData) {
  // 1. Create user in your system
  const newUser = await createUserInYourSystem(userData);
  
  // 2. Get stored click key
  const clickKey = getStoredClickKey();
  
  // 3. Send to Affelios if click key exists
  if (clickKey) {
    try {
      await createAffeliosCustomer(newUser, clickKey);
    } catch (error) {
      // Log error but don't fail registration
      console.error('Affelios integration failed:', error);
    }
  }
  
  return newUser;
}

// Real-time transaction processing
async function processTransactionRealtime(transactionData, customerId) {
  const affeliosTransaction = {
    externalId: transactionData.id,
    externalCustomerId: customerId,
    externalBrandId: process.env.AFFELIOS_BRAND_ID,
    type: 'deposit', // or 'revenue', 'withdrawal', etc.
    grossRevenue: transactionData.amount,
    transactionDate: new Date().toISOString()
  };

  return await sendToAffelios('/api/v1/transaction', affeliosTransaction);
}

// Batch transaction processing
async function processTransactionsBatch(transactions) {
  // Group transactions by customer
  const groupedTransactions = groupBy(transactions, 'customerId');
  
  for (const [customerId, customerTransactions] of Object.entries(groupedTransactions)) {
    // Aggregate transaction data
    const aggregatedData = {
      externalCustomerId: customerId,
      externalBrandId: process.env.AFFELIOS_BRAND_ID,
      grossRevenue: customerTransactions.reduce((sum, t) => sum + t.amount, 0),
      transactionCount: customerTransactions.length,
      transactionDate: new Date().toISOString()
    };

             await sendToAffelios('/api/v1/transaction/bulk', aggregatedData);
  }
}

// Scheduled batch processing (run every hour)
setInterval(async () => {
  const pendingTransactions = await getPendingTransactions();
  if (pendingTransactions.length > 0) {
    await processTransactionsBatch(pendingTransactions);
    await markTransactionsAsProcessed(pendingTransactions);
  }
}, 60 * 60 * 1000); // Every hour