Add batch DNC entries

curl -X POST "https://api.kakiyo.com/v1/dnc/batch" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "entries": [
      {
        "url": "https://linkedin.com/in/johnsmith"
      },
      {
        "url": "https://linkedin.com/in/sarahjohnson"
      },
      {
        "url": "https://linkedin.com/in/michaelchen"
      }
    ]
  }'

// JavaScript/Node.js
const bulkAddToDNC = async (linkedinUrls) => {
  const response = await fetch('https://api.kakiyo.com/v1/dnc/batch', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      entries: linkedinUrls.map(url => ({ url }))
    })
  });

  return await response.json();
};

// Usage example
const urls = [
  'https://linkedin.com/in/john',
  'https://linkedin.com/in/jane',
  'https://linkedin.com/in/bob'
];

const result = await bulkAddToDNC(urls);

console.log(`✅ Added: ${result.data.added}`);
console.log(`⚠️ Duplicates: ${result.data.duplicates}`);
console.log(`❌ Errors: ${result.data.errors}`);
console.log('Details:', result.data.details);

# Python
import requests

def bulk_add_to_dnc(linkedin_urls):
    """Bulk add LinkedIn URLs to the DNC list"""
    response = requests.post(
        'https://api.kakiyo.com/v1/dnc/batch',
        json={
            'entries': [{'url': url} for url in linkedin_urls]
        },
        headers={
            'Authorization': 'Bearer YOUR_API_KEY',
            'Content-Type': 'application/json'
        }
    )

    return response.json()

# Usage example
urls = [
    'https://linkedin.com/in/john',
    'https://linkedin.com/in/jane',
    'https://linkedin.com/in/bob'
]

result = bulk_add_to_dnc(urls)

print(f"✅ Added: {result['data']['added']}")
print(f"⚠️ Duplicates: {result['data']['duplicates']}")
print(f"❌ Errors: {result['data']['errors']}")
print('Details:', result['data']['details'])

{
  "entries": [
    {
      "url": "https://linkedin.com/in/johnsmith"
    },
    {
      "url": "https://linkedin.com/in/sarahjohnson"
    },
    {
      "url": "https://linkedin.com/in/michaelchen"
    },
    {
      "url": "linkedin.com/in/emilydavis"
    },
    {
      "url": "in/davidwilson"
    }
  ]
}

{
  "error": null,
  "data": {
    "added": 3,
    "duplicates": 1,
    "errors": 1,
    "details": [
      {
        "url": "https://linkedin.com/in/johnsmith",
        "status": "added"
      },
      {
        "url": "https://linkedin.com/in/sarahjohnson",
        "status": "added"
      },
      {
        "url": "https://linkedin.com/in/michaelchen",
        "status": "duplicate"
      },
      {
        "url": "https://linkedin.com/in/emilydavis",
        "status": "added"
      },
      {
        "url": "invalid-url",
        "status": "error",
        "error": "Invalid LinkedIn URL format"
      }
    ]
  },
  "message": "Bulk import completed: 3 added, 1 duplicates, 1 errors"
}

{
  "error": "invalid_request",
  "message": "Entries array is required"
}

{
  "error": "invalid_request",
  "message": "Entries array is required"
}

{
  "error": "invalid_request",
  "message": "Each entry must have a url field"
}

{
  "error": "rate_limit_exceeded",
  "message": "Too many requests. Please try again later.",
  "resetTime": 1700308800000
}

{
  "error": "unauthorized",
  "message": "Invalid or missing API key"
}

{
  "error": "internal_error",
  "message": "An internal error occurred"
}

const importDNCFromCSV = async (csvContent) => {
  // Parse CSV (assuming first column is LinkedIn URL)
  const rows = csvContent.split('\n').slice(1); // Skip header
  const urls = rows
    .map(row => row.split(',')[0].trim())
    .filter(url => url.length > 0);

  // Process in batches
  const batchSize = 100;
  const results = {
    totalAdded: 0,
    totalDuplicates: 0,
    totalErrors: 0,
    allDetails: []
  };

  for (let i = 0; i < urls.length; i += batchSize) {
    const batch = urls.slice(i, i + batchSize);

    const result = await bulkAddToDNC(batch);

    if (result.error) {
      console.error('Batch failed:', result.error);
      continue;
    }

    results.totalAdded += result.data.added;
    results.totalDuplicates += result.data.duplicates;
    results.totalErrors += result.data.errors;
    results.allDetails.push(...result.data.details);

    // Rate limit protection: wait 6 seconds between batches
    if (i + batchSize < urls.length) {
      await new Promise(resolve => setTimeout(resolve, 6000));
    }
  }

  return results;
};

// Usage
const csvData = `LinkedIn URL,Name,Reason
https://linkedin.com/in/john,John Smith,Opt-out request
https://linkedin.com/in/jane,Jane Doe,Unsubscribed
linkedin.com/in/bob,Bob Wilson,Customer request`;

const importResults = await importDNCFromCSV(csvData);
console.log('Import complete:', importResults);

const syncCRMOptOuts = async (crmClient) => {
  // Fetch opt-outs from CRM since last sync
  const lastSync = await getLastSyncTimestamp();
  const crmOptOuts = await crmClient.getOptOuts({ since: lastSync });

  console.log(`Syncing ${crmOptOuts.length} opt-outs from CRM`);

  // Convert to format expected by API
  const entries = crmOptOuts.map(optOut => ({
    url: optOut.linkedinUrl
  }));

  // Bulk add to DNC
  const result = await fetch('https://api.kakiyo.com/v1/dnc/batch', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ entries })
  }).then(r => r.json());

  // Update sync timestamp
  await updateLastSyncTimestamp(new Date().toISOString());

  // Log results
  await logSyncResults({
    timestamp: new Date().toISOString(),
    source: 'CRM',
    added: result.data.added,
    duplicates: result.data.duplicates,
    errors: result.data.errors
  });

  return result;
};

// Run every hour
setInterval(syncCRMOptOuts, 60 * 60 * 1000);

const migrateLegacyDNC = async (legacySystem) => {
  console.log('Starting DNC migration from legacy system...');

  // Fetch all DNC entries from legacy system
  const legacyEntries = await legacySystem.getAllDNC();

  // Process in batches
  const batchSize = 200;
  const totalBatches = Math.ceil(legacyEntries.length / batchSize);

  for (let i = 0; i < totalBatches; i++) {
    const start = i * batchSize;
    const end = Math.min(start + batchSize, legacyEntries.length);
    const batch = legacyEntries.slice(start, end);

    console.log(`Processing batch ${i + 1}/${totalBatches} (${batch.length} entries)`);

    try {
      const result = await bulkAddToDNC(batch.map(e => e.linkedinUrl));

      console.log(`Batch ${i + 1} complete:`, {
        added: result.data.added,
        duplicates: result.data.duplicates,
        errors: result.data.errors
      });

      // Log errors for review
      const errors = result.data.details.filter(d => d.status === 'error');
      if (errors.length > 0) {
        await logMigrationErrors(errors);
      }

    } catch (error) {
      console.error(`Batch ${i + 1} failed:`, error);
      await logMigrationError({ batch: i + 1, error: error.message });
    }

    // Rate limit protection
    if (i < totalBatches - 1) {
      await new Promise(resolve => setTimeout(resolve, 6000));
    }
  }

  console.log('Migration complete');
};

const processWebhookBatch = async (webhookPayload) => {
  const { optOuts, source } = webhookPayload;

  // Validate payload
  if (!Array.isArray(optOuts)) {
    throw new Error('Invalid webhook payload: optOuts must be an array');
  }

  // Convert to API format
  const entries = optOuts.map(optOut => ({
    url: optOut.linkedinUrl
  }));

  // Bulk add to DNC
  const result = await bulkAddToDNC(entries.map(e => e.url));

  // Log the webhook event
  await auditLog({
    action: 'dnc_batch_added',
    source: source,
    timestamp: new Date().toISOString(),
    stats: {
      added: result.data.added,
      duplicates: result.data.duplicates,
      errors: result.data.errors
    }
  });

  return result;
};

const exportAndReimportDNC = async () => {
  // Export current DNC list
  const currentList = await fetch('https://api.kakiyo.com/v1/dnc?limit=1000', {
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
  }).then(r => r.json());

  // Transform data
  const transformed = currentList.data.entries.map(entry => ({
    url: entry.url,
    // Add any transformations here
  }));

  // Re-import with transformations
  const result = await bulkAddToDNC(transformed.map(e => e.url));

  return result;
};

const dailyCRMSync = async () => {
  const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000);
  const optOuts = await crmClient.getOptOuts({ since: yesterday });

  if (optOuts.length === 0) {
    console.log('No new opt-outs to sync');
    return;
  }

  const result = await bulkAddToDNC(optOuts.map(o => o.linkedinUrl));

  console.log('Daily sync complete:', {
    date: new Date().toISOString(),
    processed: optOuts.length,
    added: result.data.added,
    duplicates: result.data.duplicates,
    errors: result.data.errors
  });
};

// Run daily at midnight
const schedule = require('node-schedule');
schedule.scheduleJob('0 0 * * *', dailyCRMSync);

const migrateFromPlatform = async (platform) => {
  const allDNC = await platform.exportDNCList();

  console.log(`Migrating ${allDNC.length} DNC entries`);

  // Split into batches
  const batches = [];
  const batchSize = 200;

  for (let i = 0; i < allDNC.length; i += batchSize) {
    batches.push(allDNC.slice(i, i + batchSize));
  }

  // Process batches with progress tracking
  const progress = {
    total: allDNC.length,
    processed: 0,
    added: 0,
    duplicates: 0,
    errors: 0
  };

  for (let i = 0; i < batches.length; i++) {
    const batch = batches[i];
    const result = await bulkAddToDNC(batch.map(e => e.url));

    progress.processed += batch.length;
    progress.added += result.data.added;
    progress.duplicates += result.data.duplicates;
    progress.errors += result.data.errors;

    console.log(`Progress: ${progress.processed}/${progress.total} (${Math.round(progress.processed / progress.total * 100)}%)`);

    // Wait between batches
    if (i < batches.length - 1) {
      await new Promise(resolve => setTimeout(resolve, 6000));
    }
  }

  return progress;
};