Comprehensive comparison for Payment Processing technology in Software Development applications

const axios = require('axios');

class AuthorizeNetPaymentProcessor {
  constructor(apiLoginId, transactionKey, environment = 'sandbox') {
    this.apiLoginId = apiLoginId;
    this.transactionKey = transactionKey;
    this.apiEndpoint = environment === 'production'
      ? 'https://api.authorize.net/xml/v1/request.api'
      : 'https://apitest.authorize.net/xml/v1/request.api';
  }

  async chargeCustomerProfile(customerProfileId, paymentProfileId, amount, invoiceNumber) {
    try {
      // Validate input parameters
      if (!customerProfileId || !paymentProfileId || !amount) {
        throw new Error('Missing required payment parameters');
      }

      if (amount <= 0) {
        throw new Error('Amount must be greater than zero');
      }

      // Construct the payment request payload
      const requestPayload = {
        createTransactionRequest: {
          merchantAuthentication: {
            name: this.apiLoginId,
            transactionKey: this.transactionKey
          },
          refId: `REF-${Date.now()}`,
          transactionRequest: {
            transactionType: 'authCaptureTransaction',
            amount: amount.toFixed(2),
            profile: {
              customerProfileId: customerProfileId,
              paymentProfile: {
                paymentProfileId: paymentProfileId
              }
            },
            order: {
              invoiceNumber: invoiceNumber || `INV-${Date.now()}`,
              description: 'Subscription payment'
            },
            lineItems: {
              lineItem: [
                {
                  itemId: '1',
                  name: 'Monthly Subscription',
                  description: 'Premium plan subscription',
                  quantity: '1',
                  unitPrice: amount.toFixed(2)
                }
              ]
            },
            tax: {
              amount: '0.00',
              name: 'Sales Tax',
              description: 'No tax applicable'
            },
            customerIP: '192.168.1.1'
          }
        }
      };

      // Send request to Authorize.Net API
      const response = await axios.post(this.apiEndpoint, requestPayload, {
        headers: {
          'Content-Type': 'application/json'
        },
        timeout: 30000
      });

      // Parse and validate response
      const transactionResponse = response.data.transactionResponse;
      
      if (!transactionResponse) {
        throw new Error('Invalid response from payment gateway');
      }

      // Check if transaction was successful
      if (transactionResponse.responseCode === '1') {
        return {
          success: true,
          transactionId: transactionResponse.transId,
          authCode: transactionResponse.authCode,
          accountNumber: transactionResponse.accountNumber,
          accountType: transactionResponse.accountType,
          message: transactionResponse.messages[0].description
        };
      } else {
        // Handle declined or error transactions
        const errorMessage = transactionResponse.errors
          ? transactionResponse.errors[0].errorText
          : 'Transaction declined';
        
        return {
          success: false,
          errorCode: transactionResponse.errors ? transactionResponse.errors[0].errorCode : null,
          message: errorMessage,
          transactionId: transactionResponse.transId || null
        };
      }
    } catch (error) {
      // Handle network errors, timeouts, and other exceptions
      console.error('Payment processing error:', error.message);
      
      return {
        success: false,
        errorCode: 'SYSTEM_ERROR',
        message: error.response?.data?.messages?.message[0]?.text || error.message,
        systemError: true
      };
    }
  }

  async refundTransaction(transactionId, amount, cardLastFour) {
    try {
      const requestPayload = {
        createTransactionRequest: {
          merchantAuthentication: {
            name: this.apiLoginId,
            transactionKey: this.transactionKey
          },
          refId: `REFUND-${Date.now()}`,
          transactionRequest: {
            transactionType: 'refundTransaction',
            amount: amount.toFixed(2),
            payment: {
              creditCard: {
                cardNumber: cardLastFour,
                expirationDate: 'XXXX'
              }
            },
            refTransId: transactionId
          }
        }
      };

      const response = await axios.post(this.apiEndpoint, requestPayload, {
        headers: { 'Content-Type': 'application/json' },
        timeout: 30000
      });

      const transactionResponse = response.data.transactionResponse;
      
      if (transactionResponse.responseCode === '1') {
        return {
          success: true,
          transactionId: transactionResponse.transId,
          message: 'Refund processed successfully'
        };
      } else {
        return {
          success: false,
          message: transactionResponse.errors[0].errorText
        };
      }
    } catch (error) {
      console.error('Refund error:', error.message);
      return {
        success: false,
        message: error.message
      };
    }
  }
}

module.exports = AuthorizeNetPaymentProcessor;