GET /payment-requests/release/{id}

curl -X GET \
  "https://apay.caibo.digital/payment-requests/release/12345" \
  -H "X-API-Key: your-api-key" \
  -H "Content-Type: application/json"

{
  "status": "released",
  "paymentRequestId": 12345,
  "releasedAt": "2024-01-15T10:45:00Z",
  "previousStatus": "pending",
  "reason": "Customer cancellation",
  "impact": {
    "transactionsAffected": [],
    "refundsInitiated": [],
    "notificationsSent": [
      {
        "type": "customer_notification",
        "recipient": "customer@example.com",
        "status": "sent"
      },
      {
        "type": "merchant_notification", 
        "recipient": "merchant@example.com",
        "status": "sent"
      }
    ]
  },
  "metadata": {
    "originalAmount": 100.50,
    "currency": "USD",
    "createdAt": "2024-01-15T10:30:00Z"
  }
}

{
  "error": {
    "code": "PAYMENT_REQUEST_NOT_FOUND",
    "message": "Payment request with ID 12345 not found",
    "details": {
      "requestId": "req_abc123",
      "timestamp": "2024-01-15T10:45:00Z"
    }
  }
}

{
  "error": {
    "code": "PAYMENT_ALREADY_PROCESSED",
    "message": "Cannot release payment request that has already been processed",
    "details": {
      "currentStatus": "completed",
      "transactionId": "txn_def456",
      "processedAt": "2024-01-15T10:35:00Z"
    }
  }
}

{
  "error": {
    "code": "RELEASE_OPERATION_FAILED",
    "message": "Failed to release payment request due to system error",
    "details": {
      "retryAfter": 300,
      "supportReference": "SUP-789123"
    }
  }
}

async function releasePaymentRequest(paymentId, apiKey, reason = null) {
  try {
    const response = await fetch(
      `https://apay.caibo.digital/payment-requests/release/${paymentId}`,
      {
        method: 'GET',
        headers: {
          'X-API-Key': apiKey,
          'Content-Type': 'application/json'
        }
      }
    );
    
    if (!response.ok) {
      const error = await response.json();
      throw new Error(`Release failed: ${error.message}`);
    }
    
    const result = await response.json();
    
    // Log release confirmation
    console.log(`Payment request ${paymentId} released successfully`);
    console.log('Release details:', result);
    
    // Handle notifications
    if (result.impact.notificationsSent.length > 0) {
      console.log('Notifications sent:', result.impact.notificationsSent);
    }
    
    return result;
    
  } catch (error) {
    console.error('Error releasing payment request:', error);
    throw error;
  }
}

// Usage examples
await releasePaymentRequest(12345, 'your-api-key');

async function batchReleasePaymentRequests(paymentIds, apiKey) {
  const results = [];
  const errors = [];
  
  for (const paymentId of paymentIds) {
    try {
      const result = await releasePaymentRequest(paymentId, apiKey);
      results.push({ paymentId, status: 'released', result });
    } catch (error) {
      errors.push({ paymentId, status: 'failed', error: error.message });
    }
  }
  
  return { 
    successful: results, 
    failed: errors,
    summary: {
      total: paymentIds.length,
      released: results.length,
      failed: errors.length
    }
  };
}

// Usage
const paymentIds = [12345, 12346, 12347];
const batchResult = await batchReleasePaymentRequests(paymentIds, 'your-api-key');
console.log('Batch release summary:', batchResult.summary);

<?php
function releasePaymentRequest($paymentId, $apiKey) {
    $url = "https://apay.caibo.digital/payment-requests/release/" . $paymentId;
    
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-API-Key: ' . $apiKey,
        'Content-Type: application/json'
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode === 200) {
        return json_decode($response, true);
    } else {
        $error = json_decode($response, true);
        throw new Exception("Release failed: " . $error['error']['message']);
    }
}

// Usage
try {
    $result = releasePaymentRequest(12345, 'your-api-key');
    echo "Payment request released: " . $result['status'];
} catch (Exception $e) {
    echo "Error: " . $e->getMessage();
}
?>

class OrderManager {
  async cancelOrder(orderId, reason) {
    try {
      // Get payment request ID from order
      const order = await this.getOrder(orderId);
      
      if (order.paymentRequestId) {
        // Release payment request
        await releasePaymentRequest(order.paymentRequestId, this.apiKey);
      }
      
      // Update order status
      await this.updateOrderStatus(orderId, 'cancelled', reason);
      
      // Send customer notification
      await this.notifyCustomer(order.customerId, 'order_cancelled', {
        orderId,
        reason,
        refundInfo: 'Refund will be processed within 3-5 business days'
      });
      
    } catch (error) {
      console.error('Order cancellation failed:', error);
      throw error;
    }
  }
}

async function cleanupExpiredPaymentRequests(apiKey) {
  try {
    // Get expired payment requests (implement based on your system)
    const expiredRequests = await getExpiredPaymentRequests();
    
    const results = [];
    for (const request of expiredRequests) {
      try {
        await releasePaymentRequest(request.id, apiKey);
        results.push({ id: request.id, status: 'released' });
      } catch (error) {
        results.push({ id: request.id, status: 'failed', error: error.message });
      }
    }
    
    // Log cleanup results
    console.log('Cleanup completed:', {
      total: expiredRequests.length,
      released: results.filter(r => r.status === 'released').length,
      failed: results.filter(r => r.status === 'failed').length
    });
    
    return results;
  } catch (error) {
    console.error('Cleanup operation failed:', error);
    throw error;
  }
}

// Schedule cleanup (example with cron)
// 0 2 * * * node cleanup-expired-payments.js