Comprehensive comparison for Payment Processing technology in Software Development applications

const express = require('express');
const crypto = require('crypto');
const axios = require('axios');
const app = express();

app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// Alipay Configuration
const ALIPAY_CONFIG = {
  appId: 'your_app_id',
  privateKey: `-----BEGIN PRIVATE KEY-----
YOUR_PRIVATE_KEY_HERE
-----END PRIVATE KEY-----`,
  alipayPublicKey: `-----BEGIN PUBLIC KEY-----
ALIPAY_PUBLIC_KEY_HERE
-----END PUBLIC KEY-----`,
  gatewayUrl: 'https://openapi.alipay.com/gateway.do',
  charset: 'utf-8',
  signType: 'RSA2',
  version: '1.0'
};

// Generate signature for Alipay request
function generateSignature(params, privateKey) {
  const sortedParams = Object.keys(params)
    .filter(key => params[key] !== '' && key !== 'sign')
    .sort()
    .map(key => `${key}=${params[key]}`)
    .join('&');
  
  const sign = crypto.createSign('RSA-SHA256');
  sign.update(sortedParams, 'utf8');
  return sign.sign(privateKey, 'base64');
}

// Verify Alipay callback signature
function verifySignature(params, signature, publicKey) {
  const sortedParams = Object.keys(params)
    .filter(key => params[key] !== '' && key !== 'sign' && key !== 'sign_type')
    .sort()
    .map(key => `${key}=${params[key]}`)
    .join('&');
  
  const verify = crypto.createVerify('RSA-SHA256');
  verify.update(sortedParams, 'utf8');
  return verify.verify(publicKey, signature, 'base64');
}

// Create payment order endpoint
app.post('/api/payment/create', async (req, res) => {
  try {
    const { orderId, amount, subject, description } = req.body;
    
    // Validate input
    if (!orderId || !amount || !subject) {
      return res.status(400).json({ error: 'Missing required fields' });
    }
    
    if (amount <= 0) {
      return res.status(400).json({ error: 'Invalid amount' });
    }
    
    // Build Alipay request parameters
    const bizContent = {
      out_trade_no: orderId,
      total_amount: amount.toFixed(2),
      subject: subject,
      body: description || '',
      product_code: 'FAST_INSTANT_TRADE_PAY'
    };
    
    const params = {
      app_id: ALIPAY_CONFIG.appId,
      method: 'alipay.trade.page.pay',
      charset: ALIPAY_CONFIG.charset,
      sign_type: ALIPAY_CONFIG.signType,
      timestamp: new Date().toISOString().replace('T', ' ').substring(0, 19),
      version: ALIPAY_CONFIG.version,
      notify_url: 'https://yourdomain.com/api/payment/notify',
      return_url: 'https://yourdomain.com/payment/success',
      biz_content: JSON.stringify(bizContent)
    };
    
    // Generate signature
    params.sign = generateSignature(params, ALIPAY_CONFIG.privateKey);
    
    // Build payment URL
    const paymentUrl = `${ALIPAY_CONFIG.gatewayUrl}?${Object.keys(params)
      .map(key => `${key}=${encodeURIComponent(params[key])}`)
      .join('&')}`;
    
    res.json({ success: true, paymentUrl });
  } catch (error) {
    console.error('Payment creation error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

// Payment notification callback endpoint
app.post('/api/payment/notify', async (req, res) => {
  try {
    const params = req.body;
    const signature = params.sign;
    
    // Verify signature
    if (!verifySignature(params, signature, ALIPAY_CONFIG.alipayPublicKey)) {
      console.error('Invalid signature');
      return res.send('failure');
    }
    
    // Check trade status
    if (params.trade_status === 'TRADE_SUCCESS' || params.trade_status === 'TRADE_FINISHED') {
      const orderId = params.out_trade_no;
      const tradeNo = params.trade_no;
      const amount = parseFloat(params.total_amount);
      
      // Update order status in database
      // await updateOrderStatus(orderId, 'paid', tradeNo, amount);
      
      console.log(`Payment successful for order ${orderId}, trade_no: ${tradeNo}`);
      return res.send('success');
    }
    
    res.send('success');
  } catch (error) {
    console.error('Notification processing error:', error);
    res.send('failure');
  }
});

// Query payment status endpoint
app.get('/api/payment/query/:orderId', async (req, res) => {
  try {
    const { orderId } = req.params;
    
    const bizContent = {
      out_trade_no: orderId
    };
    
    const params = {
      app_id: ALIPAY_CONFIG.appId,
      method: 'alipay.trade.query',
      charset: ALIPAY_CONFIG.charset,
      sign_type: ALIPAY_CONFIG.signType,
      timestamp: new Date().toISOString().replace('T', ' ').substring(0, 19),
      version: ALIPAY_CONFIG.version,
      biz_content: JSON.stringify(bizContent)
    };
    
    params.sign = generateSignature(params, ALIPAY_CONFIG.privateKey);
    
    const response = await axios.get(ALIPAY_CONFIG.gatewayUrl, { params });
    
    res.json({ success: true, data: response.data });
  } catch (error) {
    console.error('Query error:', error);
    res.status(500).json({ error: 'Query failed' });
  }
});

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