Devolución de una venta

curl -X POST https://checkout.developers.ar.ua.la/v2/api/orders/{{uuid}}/refund \
 -H "Content-Type: application/json" \
 -H "Authorization: Bearer your-auth-token" \
 -d '{
   "amount": "32221",
   "notification_url": "https://your-awesome-web.com/endpoint-to-notify"
 }'

class RefundClient {
constructor(uuid, amount, notificationUrl, authToken) {
  this.url = `https://checkout.developers.ar.ua.la/v2/api/orders/${uuid}/refund`;
  this.payload = {
    amount: amount,
    notification_url: notificationUrl,
  };
  this.authToken = authToken; // Guardar el token de autorización
}
 
async createRefund() {
  const options = {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${this.authToken}`, // Agregar el token de autorización
    },
    body: JSON.stringify(this.payload),
  };
 
  try {
    const response = await fetch(this.url, options);
 
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
 
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}
}
 
// Uso del constructor
const uuid = 'your-order-uuid'; // Reemplazar con el UUID real
const amount = '32221'; // Reemplazar con el amount real
const notificationUrl = 'https://your-awesome-web.com/endpoint-to-notify';
const authToken = 'your-auth-token'; // Reemplazar con tu token de autorización
 
const refundClient = new RefundClient(uuid, amount, notificationUrl, authToken);
refundClient.createRefund().then(r => console.log(r))

class RefundClient {
  private $url;
  private $payload;
  private $authToken;
 
  /**
   * Constructor de RefundClient
   *
   * @param string $uuid UUID de la orden.
   * @param string $amount Monto del reembolso.
   * @param string $notificationUrl URL para notificaciones.
   * @param string $authToken Token de autorización para la API.
   */
  public function __construct($uuid, $amount, $notificationUrl, $authToken) {
    $this->url = "https://checkout.developers.ar.ua.la/v2/api/orders/{$uuid}/refund";
    $this->payload = [
      'amount' => $amount,
      'notification_url' => $notificationUrl
    ];
    $this->authToken = $authToken;
  }
 
  /**
   * Crea una solicitud de reembolso.
   *
   * @return array|null Datos de la respuesta en formato array o null en caso de error.
   */
  public function createRefund() {
    $ch = curl_init($this->url);
 
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($this->payload));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
      'Content-Type: application/json',
      'Authorization: Bearer ' . $this->authToken  // Agregar encabezado Authorization
    ]);
 
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 
    if (curl_errno($ch)) {
      $this->handleError(curl_error($ch));
      curl_close($ch);
      return null;
    }
 
    curl_close($ch);
 
    if ($httpCode != 200) {
      $this->handleError("HTTP error! Status: " . $httpCode);
      return null;
    }
 
    return json_decode($response, true);
  }
 
  /**
   * Maneja los errores de la solicitud.
   *
   * @param string $error Mensaje de error.
   */
  private function handleError($error) {
    // Aquí puedes implementar un manejo de errores más detallado o loguear el error
    echo 'Error: ' . $error . PHP_EOL;
  }
}
 
// Uso del constructor
$uuid = 'your-order-uuid'; // Reemplaza con el UUID real
$amount = '32221';
$notificationUrl = 'https://your-awesome-web.com/endpoint-to-notify';
$authToken = 'your-auth-token'; // Reemplaza con tu token de autorización
 
$refundClient = new RefundClient($uuid, $amount, $notificationUrl, $authToken);
 
$result = $refundClient->createRefund();
 
if ($result !== null) {
  echo 'Success:';
  print_r($result);
} else {
  echo 'Error occurred.';
}

import requests
 
class OrderRefundClient:
   def __init__(self, base_url, token):
       self.base_url = base_url
       self.headers = {
           "Content-Type": "application/json",
           "Authorization": f"Bearer {token}"  # Reemplaza con tu token si es necesario
       }
 
   def refund_order(self, uuid, amount, notification_url):
       # Define la URL para el refund usando el UUID
       url = f"{self.base_url}/v2/api/orders/{uuid}/refund"
 
       # Define el payload
       payload = {
           "amount": amount,
           "notification_url": notification_url
       }
 
       # Realiza la solicitud POST
       response = requests.post(url, json=payload, headers=self.headers)
 
       # Maneja la respuesta
       if response.status_code == 200:
           print("Solicitud exitosa.")
           return response.json()
       else:
           print(f"Error: {response.status_code}")
           print("Detalles del error:", response.text)
           return None
 
# Uso de la clase
if __name__ == "__main__":
   # Reemplaza estos valores con los reales
   BASE_URL = "https://checkout.developers.ar.ua.la"
   TOKEN = "your-token-here"
   UUID = "your-uuid-here"
   AMOUNT = "32221"
   NOTIFICATION_URL = "https://your-awesome-web.com/endpoint-to-notify"
 
   # Instancia el cliente
   refund_client = OrderRefundClient(BASE_URL, TOKEN)
 
   # Realiza la solicitud de refund
   response = refund_client.refund_order(UUID, AMOUNT, NOTIFICATION_URL)
 
   # Muestra la respuesta si es exitosa
   if response:
       print("Respuesta del servidor:", response)

package main
 
import (
   "bytes"
   "encoding/json"
   "fmt"
   "io/ioutil"
   "net/http"
)
 
type OrderRefundClient struct {
   BaseURL   string
   AuthToken string
}
 
type RefundRequest struct {
   Amount          string `json:"amount"`
   NotificationURL string `json:"notification_url"`
}
 
// Método para realizar el refund de una orden
func (client *OrderRefundClient) RefundOrder(uuid string, request RefundRequest) (map[string]interface{}, error) {
   // Construir la URL para el refund usando el UUID
   url := fmt.Sprintf("%s/v2/api/orders/%s/refund", client.BaseURL, uuid)
 
   // Convertir el payload a JSON
   jsonData, err := json.Marshal(request)
   if err != nil {
   	return nil, fmt.Errorf("error serializando el payload: %v", err)
   }
 
   // Crear la solicitud HTTP
   req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
   if err != nil {
   	return nil, fmt.Errorf("error creando la solicitud: %v", err)
   }
 
   // Añadir encabezados
   req.Header.Set("Content-Type", "application/json")
   req.Header.Set("Authorization", "Bearer "+client.AuthToken)
 
   // Ejecutar la solicitud
   clientHTTP := &http.Client{}
   resp, err := clientHTTP.Do(req)
   if err != nil {
   	return nil, fmt.Errorf("error ejecutando la solicitud: %v", err)
   }
   defer resp.Body.Close()
 
   // Leer la respuesta
   body, err := ioutil.ReadAll(resp.Body)
   if err != nil {
   	return nil, fmt.Errorf("error leyendo la respuesta: %v", err)
   }
 
   // Manejar errores HTTP
   if resp.StatusCode != http.StatusOK {
   	return nil, fmt.Errorf("error en la solicitud: %s", body)
   }
 
   // Convertir la respuesta JSON a un mapa
   var responseMap map[string]interface{}
   if err := json.Unmarshal(body, &responseMap); err != nil {
   	return nil, fmt.Errorf("error deserializando la respuesta: %v", err)
   }
 
   return responseMap, nil
}
 
func main() {
   // Valores de ejemplo (deberías reemplazarlos por los reales)
   baseURL := "https://checkout.developers.ar.ua.la"
   authToken := "your-token-here"
   uuid := "your-uuid-here"
   amount := "32221"
   notificationURL := "https://your-awesome-web.com/endpoint-to-notify"
 
   // Crear instancia del cliente
   client := &OrderRefundClient{
   	BaseURL:   baseURL,
   	AuthToken: authToken,
   }
 
   // Crear el payload de refund
   request := RefundRequest{
   	Amount:          amount,
   	NotificationURL: notificationURL,
   }
 
   // Llamar al método RefundOrder
   response, err := client.RefundOrder(uuid, request)
   if err != nil {
   	fmt.Printf("Error al realizar el refund: %v\n", err)
   	return
   }
 
   // Imprimir la respuesta
   fmt.Printf("Respuesta del servidor: %v\n", response)
}

{
    "status": "INITIATED"
}

{
    "code": "request_error",
    "message": "Invalid request payload.",
    "errors": [
    "Invalid amount format. Amount must have only positive numbers and a single point.",
    "Check notification_url attribute value.",
    "Provide a valid token with active client_id.",
    "Provide a valid order id."
    ]
}

{
    "code": "request_error",
    "message": "The order is not valid to refund.",
    "errors": [
    "The refund period has expired.",
    "The order has a refund in progress.",
    "The order must be from API Checkout v2.",
    "The order must be approved.",
    "Send a valid order amount value."
    ]
}

{
    "message": "Unauthorized"
}

{
    "message": "User is not authorized to access this resource with an explicit deny"
}

{
    "code": "request_error",
    "message": "You are not allowed to perform this action."
}

{
    "code": "response_error",
    "message": "No record found."
}

{
    "code": "api_error",
    "message": "Something bad happened. Please try again."
}