Integration Showcase

// Initialize payment flow
const checkout = await finfusion.checkout.create({
  amount: cart.total,
  currency: 'USD',
  customer: {
    email: user.email,
    metadata: {
      orderId: order.id
    }
  },
  lineItems: cart.items.map(item => ({
    name: item.name,
    amount: item.price,
    quantity: item.quantity
  })),
  successUrl: 'https://example.com/success',
  cancelUrl: 'https://example.com/cancel'
});

// Create connected account for vendor
const account = await finfusion.connect.accounts.create({
  type: 'standard',
  country: 'US',
  email: vendor.email,
  business_profile: {
    name: vendor.businessName,
    url: vendor.website
  }
});

// Process split payment
const payment = await finfusion.payments.create({
  amount: order.total,
  currency: 'USD',
  transfer_data: {
    destination: vendor.accountId,
    amount: order.vendorShare
  }
});

// Handle property booking payment
const bookingPayment = await finfusion.escrow.create({
  amount: property.bookingAmount,
  currency: 'INR',
  purpose: 'property_booking',
  property: {
    id: property.id,
    name: property.name,
    type: 'apartment'
  },
  releaseConditions: {
    type: 'milestone',
    milestones: [
      { 
        percentage: 20,
        description: 'Foundation completion'
      },
      { 
        percentage: 40,
        description: 'Structure completion'
      }
    ]
  }
});

// Create SIP investment
const sipInvestment = await finfusion.investments.createSIP({
  amount: 10000,
  frequency: 'monthly',
  scheme: {
    id: 'MF_HDFC_TOP_100',
    type: 'mutual_fund'
  },
  schedule: {
    startDate: '2024-02-01',
    endDate: '2029-02-01'
  },
  autoRebalance: {
    frequency: 'quarterly',
    threshold: 5 // percentage
  }
});

// Process insurance premium
const premium = await finfusion.insurance.collectPremium({
  policyId: 'POL123',
  amount: 12000,
  frequency: 'annual',
  coverage: {
    type: 'health',
    sumInsured: 500000
  },
  commissionSplit: {
    agentId: 'AGT456',
    percentage: 15
  }
});

// Process loan disbursement
const loan = await finfusion.lending.disburseLoan({
  applicationId: 'LA789',
  amount: 50000,
  tenure: 12,
  interestRate: 12,
  disbursement: {
    method: 'upi',
    vpa: 'user@upi'
  },
  repaymentSchedule: {
    frequency: 'monthly',
    startDate: '2024-02-01'
  }
});

// Create usage-based billing
const billing = await finfusion.billing.create({
  customerId: 'CST123',
  period: {
    start: '2024-01-01',
    end: '2024-01-31'
  },
  items: [
    {
      service: 'cloud_storage',
      usage: 500, // GB
      rate: 0.05, // per GB
      currency: 'USD'
    }
  ],
  autoCharge: true
});

// Execute stock purchase
const trade = await finfusion.trading.executeOrder({
  symbol: 'AAPL',
  type: 'market',
  side: 'buy',
  quantity: 10,
  portfolio: {
    id: 'PORT123',
    strategy: 'growth'
  },
  riskChecks: {
    maxLoss: 5, // percentage
    stopLoss: true
  }
});

// Process donation with impact tracking
const donation = await finfusion.donations.process({
  amount: 5000,
  currency: 'INR',
  campaign: 'education_2024',
  donor: {
    id: 'DNR123',
    anonymous: false
  },
  allocation: {
    education: 60,
    healthcare: 40
  },
  impactMetrics: {
    beneficiaries: 10,
    region: 'Karnataka'
  }
});

// Track cloud expenses
const cloudCosts = await finfusion.finops.trackExpenses({
  provider: 'aws',
  period: 'monthly',
  departments: ['dev', 'prod'],
  budgets: {
    dev: 5000,
    prod: 15000
  },
  alerts: {
    threshold: 80, // percentage
    notification: 'email'
  }
});

// Track marketing campaign ROI
const campaign = await finfusion.marketing.trackROI({
  campaignId: 'CAM123',
  spend: {
    amount: 50000,
    currency: 'USD',
    channels: {
      facebook: 20000,
      google: 30000
    }
  },
  metrics: {
    impressions: 1000000,
    clicks: 50000,
    conversions: 1000
  }
});

// AI-powered risk assessment
const riskScore = await finfusion.ai.assessRisk({
  transaction: {
    amount: 100000,
    currency: 'USD',
    type: 'international'
  },
  customer: {
    id: 'CUS123',
    history: true
  },
  models: {
    fraudDetection: true,
    creditScoring: true
  }
});

// Lambda handler
exports.handler = async (event) => {
  const finfusion = new FinFusion({
    apiKey: process.env.FINFUSION_API_KEY
  });

  try {
    const payment = await finfusion.payments.create({
      amount: event.amount,
      currency: event.currency
    });
    return {
      statusCode: 200,
      body: JSON.stringify(payment)
    };
  } catch (error) {
    return {
      statusCode: 400,
      body: JSON.stringify(error)
    };
  }
};