Obtener una orden

    curl -X GET "https://checkout.developers.ar.ua.la/v2/api/orders/<UUID>" \
     -H "Authorization: Bearer <TOKEN>"

class OrderAPI {
    constructor(baseURL, token) {
        this.baseURL = baseURL;
        this.token = token;
    }
 
    async getOrder(uuid) {
        const url = `${this.baseURL}/orders/${uuid}`;
 
        const response = await fetch(url, {
            method: 'GET',
            headers: {
                'Authorization': `Bearer ${this.token}`
            }
        });
 
        if (!response.ok) {
            throw new Error(`Failed to fetch order, status: ${response.status}`);
        }
 
        return response.json();
    }
}
 
// Ejemplo de uso
const token = "<TOKEN>";
const uuid = "<UUID>";
const api = new OrderAPI("https://checkout.developers.ar.ua.la/v2/api", token);
 
api.getOrder(uuid)
    .then(orderData => console.log("Order Data:", orderData))
    .catch(error => console.error("Failed to fetch order:", error));

class OrderAPI {
    private $baseURL;
    private $token;
 
    public function __construct($baseURL, $token) {
        $this->baseURL = $baseURL;
        $this->token = $token;
    }
 
    public function getOrder($uuid) {
        $url = "{$this->baseURL}/orders/{$uuid}";
 
        $headers = [
            "Authorization: Bearer {$this->token}"
        ];
 
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $url);
        curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
 
        if (curl_errno($ch)) {
            throw new Exception('Request Error: ' . curl_error($ch));
        }
 
        curl_close($ch);
 
        if ($httpCode !== 200) {
            throw new Exception("Failed to fetch order, status code: $httpCode");
        }
 
        return json_decode($response, true);
    }
}
 
// Ejemplo de uso
$token = "<TOKEN>";
$uuid = "<UUID>";
$api = new OrderAPI("https://checkout.developers.ar.ua.la/v2/api", $token);
 
try {
    $orderData = $api->getOrder($uuid);
    echo "Order Data: ";
    print_r($orderData);
} catch (Exception $e) {
    echo "Error fetching order: " . $e->getMessage();
}

import requests
 
class OrderAPI:
   def __init__(self, base_url: str, token: str):
       self.base_url = base_url
       self.headers = {
           "Authorization": f"Bearer {token}"
       }
 
   def get_order(self, uuid: str):
       url = f"{self.base_url}/orders/{uuid}"
       response = requests.get(url, headers=self.headers)
 
       if response.status_code == 200:
           return response.json()
       else:
           response.raise_for_status()  # Levanta una excepción en caso de error
 
# Ejemplo de uso
token = "<TOKEN>"
uuid = "<UUID>"
api = OrderAPI("https://checkout.developers.ar.ua.la/v2/api", token)
 
try:
   order_data = api.get_order(uuid)
   print("Order Data:", order_data)
except requests.exceptions.HTTPError as e:
   print("Failed to fetch order:", e)

package main
 
import (
   "encoding/json"
   "fmt"
   "io/ioutil"
   "log"
   "net/http"
)
 
type OrderAPI struct {
   BaseURL string
   Token   string
}
 
func (api *OrderAPI) GetOrder(uuid string) (map[string]interface{}, error) {
   url := fmt.Sprintf("%s/orders/%s", api.BaseURL, uuid)
 
   req, err := http.NewRequest("GET", url, nil)
   if err != nil {
       return nil, err
   }
 
   req.Header.Set("Authorization", "Bearer "+api.Token)
 
   client := &http.Client{}
   resp, err := client.Do(req)
   if err != nil {
       return nil, err
   }
   defer resp.Body.Close()
 
   if resp.StatusCode != http.StatusOK {
       return nil, fmt.Errorf("failed to fetch order, status code: %d", resp.StatusCode)
   }
 
   body, err := ioutil.ReadAll(resp.Body)
   if err != nil {
       return nil, err
   }
 
   var result map[string]interface{}
   if err := json.Unmarshal(body, &result); err != nil {
       return nil, err
   }
 
   return result, nil
}
 
func main() {
   api := OrderAPI{
       BaseURL: "https://checkout.developers.ar.ua.la/v2/api",
       Token:   "<YOUR_AUTH_TOKEN>",
   }
 
   uuid := "<YOUR_ORDER_UUID>"
   orderData, err := api.GetOrder(uuid)
   if err != nil {
       log.Fatalf("Error fetching order: %v", err)
   }
 
   fmt.Printf("Order Data: %v\n", orderData)
}

{
    "code": "request_error",
    "message": "Invalid query string request payload.",
    "errors": [
    "The limit must be less than 50.",
    "Provide a valid sort order (Ex: ascending or descending).",
    "Provide a valid status.",
    "Provide a valid from_date (Ex: YYYY-MM-DD).",
    "Provide a valid to_date (Ex: YYYY-MM-DD).",
    "Provide a valid last_search_key."
    ]
}

{
    "message": "Unauthorized"
}

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

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