Create Batch Transactions

POST http://api.gu1.ai/transactions/batch
POST http://api.gu1.ai/transactions/batch/background
POST http://api.gu1.ai/transactions/batch/background-multi
POST http://api.gu1.ai/transactions/batch/upload   (multipart/form-data)

const form = new FormData();
form.append('file', fileInput.files[0]);           // or multiple: form.append('file', file1); form.append('file', file2);
form.append('executeRules', 'true');
form.append('skipDuplicates', 'true');
form.append('validateExistingEntity', 'true');

const response = await fetch('http://api.gu1.ai/transactions/batch/upload', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' },
  body: form   // Do not set Content-Type; browser sets multipart boundary
});
const data = await response.json();

curl -X POST http://api.gu1.ai/transactions/batch/upload \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@transactions.csv" \
  -F "file=@more-transactions.xlsx" \
  -F "executeRules=true" \
  -F "skipDuplicates=true"

Authorization: Bearer YOUR_API_KEY

import requests
from typing import List, Dict

def chunk_list(lst: List, chunk_size: int):
    """Split list into chunks of specified size"""
    for i in range(0, len(lst), chunk_size):
        yield lst[i:i + chunk_size]

def import_transactions_in_batches(transactions: List[Dict], batch_size: int = 100000):
    """Import large number of transactions in batches"""
    total_created = 0
    total_skipped = 0
    total_failed = 0

    for batch_num, batch in enumerate(chunk_list(transactions, batch_size), 1):
        print(f"Processing batch {batch_num} ({len(batch)} transactions)...")

        response = requests.post(
            'http://api.gu1.ai/transactions/batch',
            headers={
                'Authorization': f'Bearer {API_KEY}',
                'Content-Type': 'application/json'
            },
            json={
                'transactions': batch,
                'executeRules': False,  # Skip rules for faster import
                'skipDuplicates': True,
                'validateExistingEntity': False  # Skip validation for speed
            }
        )

        result = response.json()
        total_created += result['created']
        total_skipped += result['skipped']
        total_failed += result['failed']

        print(f"Batch {batch_num}: Created {result['created']}, Skipped {result['skipped']}, Failed {result['failed']}")

        # Handle errors
        if result.get('errors'):
            print(f"Errors in batch {batch_num}:")
            for error in result['errors'][:5]:  # Show first 5 errors
                print(f"  - {error['externalId']}: {error['error']}")

    print(f"\nTotal: Created {total_created}, Skipped {total_skipped}, Failed {total_failed}")
    return {
        'created': total_created,
        'skipped': total_skipped,
        'failed': total_failed
    }

# Usage
all_transactions = load_all_transactions_from_database()
result = import_transactions_in_batches(all_transactions, batch_size=100000)

// Import mobile app transactions with device info
const mobileTransactions = await database.query(`
  SELECT
    t.id as transaction_id,
    t.amount,
    t.currency,
    d.platform,
    d.os_name,
    d.device_model,
    l.latitude,
    l.longitude,
    l.city,
    l.country
  FROM transactions t
  JOIN devices d ON t.device_id = d.id
  JOIN locations l ON t.location_id = l.id
`);

const response = await fetch('http://api.gu1.ai/transactions/batch', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    transactions: mobileTransactions.map(txn => ({
      externalId: txn.transaction_id,
      type: 'PAYMENT',
      amount: txn.amount,
      currency: txn.currency,
      channel: 'mobile_app',
      deviceDetails: {
        platform: txn.platform,
        osName: txn.os_name,
        model: txn.device_model
      },
      locationDetails: {
        latitude: txn.latitude,
        longitude: txn.longitude,
        city: txn.city,
        country: txn.country
      }
    })),
    executeRules: true,
    skipDuplicates: true
  })
});

const result = await response.json();

{
  "success": true,
  "created": 98,
  "skipped": 2,
  "failed": 0,
  "processingTime": 1245,
  "transactions": [
    {
      "id": "550e8400-e29b-41d4-a716-446655440000",
      "externalId": "txn_001",
      "type": "PAYMENT",
      "amount": 50.00,
      "currency": "USD",
      "status": "CREATED",
      "riskScore": 12,
      "createdAt": "2024-10-03T14:30:00.000Z"
    },
    ... // All created transactions
  ],
  "errors": [
    {
      "index": 45,
      "externalId": "txn_046",
      "error": "Invalid currency format",
      "code": "VALIDATION_ERROR"
    }
  ]
}

const result = await createBatchTransactions(transactions);

if (result.failed > 0) {
  console.error(`${result.failed} transactions failed:`);

  result.errors.forEach(error => {
    console.error(`Transaction ${error.externalId} at index ${error.index}: ${error.error}`);

    // Retry failed transactions individually
    retryTransaction(transactions[error.index]);
  });
}

console.log(`Successfully created ${result.created} transactions`);

{
  "success": false,
  "error": {
    "code": "BATCH_SIZE_EXCEEDED",
    "message": "Batch size exceeds maximum of 100,000 transactions per request",
    "details": {
      "provided": 150000,
      "maximum": 100000
    }
  }
}

{
  "success": false,
  "error": {
    "code": "EMPTY_BATCH",
    "message": "Batch must contain at least 1 transaction",
    "details": {
      "provided": 0,
      "minimum": 1
    }
  }
}

import asyncio
import aiohttp

async def create_batch_async(session, transactions):
    async with session.post(
        'http://api.gu1.ai/transactions/batch',
        headers={'Authorization': f'Bearer {API_KEY}'},
        json={
            'transactions': transactions,
            'executeRules': False,  # Skip for speed
            'skipDuplicates': True,
            'validateExistingEntity': False  # Skip validation
        }
    ) as response:
        return await response.json()

async def bulk_import_parallel(all_transactions, batch_size=10000, max_concurrent=5):
    """Import transactions with parallel batches"""
    batches = [all_transactions[i:i+batch_size] for i in range(0, len(all_transactions), batch_size)]

    semaphore = asyncio.Semaphore(max_concurrent)

    async def process_batch(batch):
        async with semaphore:
            async with aiohttp.ClientSession() as session:
                return await create_batch_async(session, batch)

    results = await asyncio.gather(*[process_batch(batch) for batch in batches])

    total_created = sum(r['created'] for r in results)
    total_failed = sum(r['failed'] for r in results)

    print(f"Imported {total_created} transactions, {total_failed} failed")
    return results

# Usage
transactions = load_100k_transactions()
asyncio.run(bulk_import_parallel(transactions))

# Migrate historical data with minimal processing
response = requests.post(
    'http://api.gu1.ai/transactions/batch',
    json={
        'transactions': legacy_transactions,
        'executeRules': False,  # Don't analyze historical data
        'skipDuplicates': True,
        'validateExistingEntity': False
    }
)

// Cron job: Import yesterday's transactions
async function importYesterdayTransactions() {
  const yesterday = new Date();
  yesterday.setDate(yesterday.getDate() - 1);

  const transactions = await fetchTransactionsFromDatabase(yesterday);

  const result = await fetch('http://api.gu1.ai/transactions/batch', {
    method: 'POST',
    headers: { 'Authorization': 'Bearer YOUR_API_KEY' },
    body: JSON.stringify({
      transactions: transactions,
      executeRules: true,  // Analyze for alerts
      skipDuplicates: true
    })
  });

  const data = await result.json();
  console.log(`Imported ${data.created} transactions from ${yesterday.toDateString()}`);
}

// Run daily at 2am
schedule.scheduleJob('0 2 * * *', importYesterdayTransactions);