Obtener órdenes por filtro

curl -X GET\
    -H "Authorization: Bearer [[accessToken]]"\
    -H "Content-Type: application/json"\
    "https://checkout.developers.ar.ua.la/v2/api/orders?limit=100&fromDate=2022-08-04&toDate=2022-08-09"

class OrderAPI {
    constructor(baseURL, accessToken) {
        this.baseURL = baseURL;
        this.accessToken = accessToken;
    }
 
    async getOrders(limit = 100, fromDate, toDate) {
        const url = `${this.baseURL}/orders?limit=${limit}&fromDate=${fromDate}&toDate=${toDate}`;
 
        const response = await fetch(url, {
            method: 'GET',
            headers: {
                "Authorization": `Bearer ${this.accessToken}`,
                "Content-Type": "application/json"
            }
        });
 
        if (!response.ok) {
            throw new Error(`Failed to fetch orders, status: ${response.status}`);
        }
 
        return response.json();
    }
}
 
// Ejemplo de uso
const accessToken = "<accessToken>";
const api = new OrderAPI("https://checkout.developers.ar.ua.la/v2/api", accessToken);
 
api.getOrders(100, "2022-08-04", "2022-08-09")
    .then(orderData => console.log("Order Data:", orderData))
    .catch(error => console.error("Error fetching orders:", error));
 

class OrderAPI {
    private $baseURL;
    private $accessToken;
 
    public function __construct($baseURL, $accessToken) {
        $this->baseURL = $baseURL;
        $this->accessToken = $accessToken;
    }
 
    public function getOrders($limit = 100, $fromDate, $toDate) {
        $url = "{$this->baseURL}/orders?limit={$limit}&fromDate={$fromDate}&toDate={$toDate}";
 
        $headers = [
            "Authorization: Bearer {$this->accessToken}",
            "Content-Type: application/json"
        ];
 
        $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 orders, status code: $httpCode");
        }
 
        return json_decode($response, true);
    }
}
 
// Ejemplo de uso
$accessToken = "<accessToken>";
$api = new OrderAPI("https://checkout.developers.ar.ua.la/v2/api", $accessToken);
 
try {
    $orderData = $api->getOrders(100, "2022-08-04", "2022-08-09");
    echo "Order Data:\n";
    print_r($orderData);
} catch (Exception $e) {
    echo "Error fetching orders: " . $e->getMessage();
}
 

#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import json
import requests
 
# URLs para la API de Orders
BASE_URL = 'https://checkout.developers.ar.ua.la/v2/api/orders'
ORDER_URL = f'{BASE_URL}?limit=100&fromDate=2022-08-04&toDate=2022-08-09'
 
class Order:
   """
   Clase para manejar la obtención de órdenes desde la API.
   """
 
   def get_orders(self, access_token: str) -> dict:
       """
       Método para obtener órdenes desde la API.
 
       Args:
           access_token (str): Token de acceso para la autenticación.
 
       Returns:
           dict: Respuesta JSON de la API como un diccionario.
 
       Raises:
           Exception: Si ocurre un error en la solicitud HTTP.
       """
       try:
           headers = {
               'Content-Type': 'application/json',
               'Accept': 'application/json',
               'Authorization': f'Bearer {access_token}'
           }
 
           # Realizar la solicitud GET
           response = requests.get(ORDER_URL, headers=headers)
 
           # Manejar errores HTTP
           if response.status_code != 200:
               raise Exception(f'Error en la solicitud: HTTP {response.status_code} - {response.text}')
 
           # Devolver la respuesta como JSON
           return response.json()
 
       except requests.exceptions.RequestException as e:
           raise Exception(f'[!] Error al obtener las órdenes: {str(e)}')
 
if __name__ == '__main__':
   # Instanciar la clase Order
   order = Order()
 
   # Token de acceso (reemplaza con un token válido)
   token = 'ACCESS_TOKEN'
 
   try:
       # Obtener las órdenes desde la API
       response = order.get_orders(token)
 
       # Imprimir la respuesta en formato JSON legible
       print(json.dumps(response, indent=4, ensure_ascii=False))
   except Exception as e:
       # Manejar errores y mostrarlos en la consola
       print(f'[!] Error: {str(e)}')
 

package main
 
import (
   "encoding/json"
   "fmt"
   "net/http"
)
 
const checkoutUrl = "https://checkout.developers.ar.ua.la/v2/api/orders"
 
var orderUrl = fmt.Sprintf("%s?limit=100&fromDate=2022-08-04&toDate=2022-08-09", checkoutUrl)
 
type (
   Response struct {
   	Orders []Order `json:"orders"`
   }
 
   Order struct {
   	OrderID     string  `json:"order_id"`
   	Status      string  `json:"status"`
   	RefNumber   string  `json:"ref_number"`
   	CreatedDate string  `json:"created_date"`
   	Amount      float64 `json:"amount"`
   }
)
 
func GetOrders(token string) (Response, error) {
   var response Response
   access_token := fmt.Sprintf("Bearer %s", token)
   order_url := fmt.Sprintf("%s/%s", orderUrl)
   request, err := http.NewRequest("GET", order_url, nil)
   if err != nil {
   	return response, err
   }
   request.Header.Set("Content-Type", "application/json")
   request.Header.Set("Authorization", access_token)
   cli := &http.Client{}
   resp, err := cli.Do(request)
   if err != nil {
   	return response, err
   }
   defer resp.Body.Close()
   if err = json.NewDecoder(resp.Body).Decode(&response); err != nil {
   	return response, err
   }
   return response, err
}
 
func main() {
   token := "ACCESS_TOKEN"
   response, err := GetOrders(token)
   if err != nil {
   	panic(err)
   }
   fmt.Println(response)
}

{
    "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."
}