Comprehensive comparison for Payment Processing technology in Software Development applications

const express = require('express');
const Flutterwave = require('flutterwave-node-v3');
const crypto = require('crypto');
const app = express();

app.use(express.json());

// Initialize Flutterwave
const flw = new Flutterwave(
  process.env.FLW_PUBLIC_KEY,
  process.env.FLW_SECRET_KEY
);

// Initiate payment endpoint
app.post('/api/payments/initiate', async (req, res) => {
  try {
    const { amount, currency, email, name, phone, orderId } = req.body;

    // Validation
    if (!amount || !email || !orderId) {
      return res.status(400).json({
        success: false,
        message: 'Missing required fields: amount, email, orderId'
      });
    }

    const payload = {
      tx_ref: `ORDER_${orderId}_${Date.now()}`,
      amount: parseFloat(amount),
      currency: currency || 'NGN',
      redirect_url: `${process.env.APP_URL}/payment/callback`,
      payment_options: 'card,banktransfer,ussd',
      customer: {
        email: email,
        name: name || 'Customer',
        phonenumber: phone || ''
      },
      customizations: {
        title: 'Product Purchase',
        description: `Payment for order ${orderId}`,
        logo: `${process.env.APP_URL}/logo.png`
      },
      meta: {
        order_id: orderId,
        source: 'web'
      }
    };

    const response = await flw.Charge.card(payload);

    if (response.status === 'success') {
      return res.status(200).json({
        success: true,
        data: {
          link: response.meta.authorization.redirect,
          tx_ref: payload.tx_ref
        }
      });
    } else {
      return res.status(400).json({
        success: false,
        message: 'Payment initiation failed',
        error: response.message
      });
    }
  } catch (error) {
    console.error('Payment initiation error:', error);
    return res.status(500).json({
      success: false,
      message: 'Internal server error',
      error: error.message
    });
  }
});

// Webhook endpoint for payment verification
app.post('/api/payments/webhook', async (req, res) => {
  try {
    const secretHash = process.env.FLW_SECRET_HASH;
    const signature = req.headers['verif-hash'];

    // Verify webhook signature
    if (!signature || signature !== secretHash) {
      return res.status(401).json({ message: 'Unauthorized' });
    }

    const payload = req.body;

    // Only process successful payments
    if (payload.status === 'successful') {
      const transactionId = payload.id;
      const txRef = payload.tx_ref;

      // Verify transaction with Flutterwave
      const response = await flw.Transaction.verify({ id: transactionId });

      if (
        response.data.status === 'successful' &&
        response.data.amount === payload.amount &&
        response.data.currency === payload.currency
      ) {
        // Update order status in database
        // await updateOrderStatus(payload.meta.order_id, 'paid');

        console.log('Payment verified:', {
          tx_ref: txRef,
          amount: response.data.amount,
          order_id: payload.meta.order_id
        });

        return res.status(200).json({ message: 'Webhook processed' });
      } else {
        console.error('Transaction verification failed:', response);
        return res.status(400).json({ message: 'Verification failed' });
      }
    }

    return res.status(200).json({ message: 'Webhook received' });
  } catch (error) {
    console.error('Webhook processing error:', error);
    return res.status(500).json({ message: 'Webhook processing failed' });
  }
});

// Verify payment endpoint (for frontend callback)
app.get('/api/payments/verify/:transactionId', async (req, res) => {
  try {
    const { transactionId } = req.params;

    const response = await flw.Transaction.verify({ id: transactionId });

    if (response.data.status === 'successful') {
      return res.status(200).json({
        success: true,
        message: 'Payment verified successfully',
        data: {
          amount: response.data.amount,
          currency: response.data.currency,
          tx_ref: response.data.tx_ref,
          status: response.data.status
        }
      });
    } else {
      return res.status(400).json({
        success: false,
        message: 'Payment verification failed',
        status: response.data.status
      });
    }
  } catch (error) {
    console.error('Verification error:', error);
    return res.status(500).json({
      success: false,
      message: 'Error verifying payment'
    });
  }
});

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