Comprehensive comparison for Payment Processing technology in Software Development applications

const express = require('express');
const paypal = require('@paypal/checkout-server-sdk');
const app = express();

app.use(express.json());

// PayPal SDK Configuration
function environment() {
  const clientId = process.env.PAYPAL_CLIENT_ID;
  const clientSecret = process.env.PAYPAL_CLIENT_SECRET;
  
  if (process.env.NODE_ENV === 'production') {
    return new paypal.core.LiveEnvironment(clientId, clientSecret);
  }
  return new paypal.core.SandboxEnvironment(clientId, clientSecret);
}

const client = new paypal.core.PayPalHttpClient(environment());

// Create PayPal Order Endpoint
app.post('/api/payments/create-order', async (req, res) => {
  try {
    const { amount, currency, description, userId } = req.body;
    
    // Validation
    if (!amount || amount <= 0) {
      return res.status(400).json({ error: 'Invalid amount' });
    }
    
    if (!currency || !['USD', 'EUR', 'GBP'].includes(currency)) {
      return res.status(400).json({ error: 'Invalid currency' });
    }
    
    const request = new paypal.orders.OrdersCreateRequest();
    request.prefer('return=representation');
    request.requestBody({
      intent: 'CAPTURE',
      purchase_units: [{
        amount: {
          currency_code: currency,
          value: amount.toFixed(2)
        },
        description: description || 'Software License Purchase',
        custom_id: userId || 'guest'
      }],
      application_context: {
        brand_name: 'YourSoftwareCompany',
        landing_page: 'BILLING',
        user_action: 'PAY_NOW',
        return_url: `${process.env.BASE_URL}/payment/success`,
        cancel_url: `${process.env.BASE_URL}/payment/cancel`
      }
    });
    
    const order = await client.execute(request);
    
    // Log transaction for audit
    console.log('Order created:', {
      orderId: order.result.id,
      userId: userId,
      amount: amount,
      timestamp: new Date().toISOString()
    });
    
    res.status(201).json({
      orderId: order.result.id,
      status: order.result.status,
      links: order.result.links
    });
    
  } catch (error) {
    console.error('PayPal order creation error:', error);
    res.status(500).json({
      error: 'Failed to create payment order',
      message: error.message
    });
  }
});

// Capture PayPal Order Endpoint
app.post('/api/payments/capture-order', async (req, res) => {
  try {
    const { orderId, userId } = req.body;
    
    if (!orderId) {
      return res.status(400).json({ error: 'Order ID required' });
    }
    
    const request = new paypal.orders.OrdersCaptureRequest(orderId);
    request.requestBody({});
    
    const capture = await client.execute(request);
    
    // Verify capture status
    if (capture.result.status === 'COMPLETED') {
      // Update database with successful payment
      // await database.updateUserSubscription(userId, capture.result);
      
      console.log('Payment captured:', {
        orderId: orderId,
        captureId: capture.result.purchase_units[0].payments.captures[0].id,
        userId: userId,
        timestamp: new Date().toISOString()
      });
      
      return res.status(200).json({
        success: true,
        orderId: capture.result.id,
        status: capture.result.status,
        captureId: capture.result.purchase_units[0].payments.captures[0].id,
        amount: capture.result.purchase_units[0].payments.captures[0].amount
      });
    }
    
    res.status(400).json({
      success: false,
      error: 'Payment not completed',
      status: capture.result.status
    });
    
  } catch (error) {
    console.error('PayPal capture error:', error);
    
    // Handle specific PayPal errors
    if (error.statusCode === 422) {
      return res.status(422).json({
        error: 'Order already captured or invalid',
        details: error.message
      });
    }
    
    res.status(500).json({
      error: 'Failed to capture payment',
      message: error.message
    });
  }
});

// Webhook handler for PayPal events
app.post('/api/webhooks/paypal', async (req, res) => {
  try {
    const webhookEvent = req.body;
    
    // Verify webhook signature in production
    // const isValid = await verifyWebhookSignature(req);
    // if (!isValid) return res.status(401).send('Unauthorized');
    
    switch (webhookEvent.event_type) {
      case 'PAYMENT.CAPTURE.COMPLETED':
        console.log('Payment completed via webhook:', webhookEvent.resource.id);
        // Process successful payment
        break;
      case 'PAYMENT.CAPTURE.DENIED':
        console.log('Payment denied:', webhookEvent.resource.id);
        // Handle denied payment
        break;
      default:
        console.log('Unhandled webhook event:', webhookEvent.event_type);
    }
    
    res.status(200).send('Webhook processed');
  } catch (error) {
    console.error('Webhook processing error:', error);
    res.status(500).send('Webhook error');
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Payment server running on port ${PORT}`);
});