Orders API (vtex.local) – OpenAPI Spec, Docs & Bruno Collection

GET Get window to change seller

{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller" {:headers {:content-type ""
                                                                                                            :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/checkout/pvt/configuration/window-to-change-seller HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"))
    .header("content-type", "")
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .header("content-type", "")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {'content-type': '', accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');

req.headers({
  'content-type': '',
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/checkout/pvt/configuration/window-to-change-seller", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

headers = {
    "content-type": "",
    "accept": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/checkout/pvt/configuration/window-to-change-seller') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

text/plain

RESPONSE BODY text

POST Update window to change seller

{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller

HEADERS

Content-Type

BODY json

{
  "waitingTime": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"waitingTime\": 4\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller" {:headers {:accept ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:waitingTime 4}})

require "http/client"

url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"
headers = HTTP::Headers{
  "content-type" => "application/json"
  "accept" => ""
}
reqBody = "{\n  \"waitingTime\": 4\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"waitingTime\": 4\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddHeader("accept", "");
request.AddParameter("application/json", "{\n  \"waitingTime\": 4\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

	payload := strings.NewReader("{\n  \"waitingTime\": 4\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/checkout/pvt/configuration/window-to-change-seller HTTP/1.1
Content-Type: application/json
Accept: 
Host: example.com
Content-Length: 22

{
  "waitingTime": 4
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .setHeader("content-type", "application/json")
  .setHeader("accept", "")
  .setBody("{\n  \"waitingTime\": 4\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"))
    .header("content-type", "application/json")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"waitingTime\": 4\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"waitingTime\": 4\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .header("content-type", "application/json")
  .header("accept", "")
  .body("{\n  \"waitingTime\": 4\n}")
  .asString();

const data = JSON.stringify({
  waitingTime: 4
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');
xhr.setRequestHeader('content-type', 'application/json');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {'content-type': 'application/json', accept: ''},
  data: {waitingTime: 4}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json', accept: ''},
  body: '{"waitingTime":4}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  method: 'POST',
  headers: {
    'content-type': 'application/json',
    accept: ''
  },
  processData: false,
  data: '{\n  "waitingTime": 4\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"waitingTime\": 4\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {
    'content-type': 'application/json',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({waitingTime: 4}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {'content-type': 'application/json', accept: ''},
  body: {waitingTime: 4},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');

req.headers({
  'content-type': 'application/json',
  accept: ''
});

req.type('json');
req.send({
  waitingTime: 4
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller',
  headers: {'content-type': 'application/json', accept: ''},
  data: {waitingTime: 4}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json', accept: ''},
  body: '{"waitingTime":4}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json",
                           @"accept": @"" };
NSDictionary *parameters = @{ @"waitingTime": @4 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "application/json");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"waitingTime\": 4\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'waitingTime' => 4
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller', [
  'body' => '{
  "waitingTime": 4
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json',
  'accept' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'waitingTime' => 4
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'waitingTime' => 4
]));
$request->setRequestUrl('{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "waitingTime": 4
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "waitingTime": 4
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"waitingTime\": 4\n}"

headers = {
    'content-type': "application/json",
    'accept': ""
}

conn.request("POST", "/baseUrl/api/checkout/pvt/configuration/window-to-change-seller", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

payload = { "waitingTime": 4 }
headers = {
    "content-type": "application/json",
    "accept": ""
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller"

payload <- "{\n  \"waitingTime\": 4\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request["accept"] = ''
request.body = "{\n  \"waitingTime\": 4\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/checkout/pvt/configuration/window-to-change-seller') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"waitingTime\": 4\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller";

    let payload = json!({"waitingTime": 4});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --data '{
  "waitingTime": 4
}'

echo '{
  "waitingTime": 4
}' |  \
  http POST {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --header 'accept: ' \
  --body-data '{\n  "waitingTime": 4\n}' \
  --output-document \
  - {{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller

import Foundation

let headers = [
  "content-type": "application/json",
  "accept": ""
]
let parameters = ["waitingTime": 4] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/checkout/pvt/configuration/window-to-change-seller")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Retrieve order conversation

{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message

HEADERS

Content-Type

QUERY PARAMS

orderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message" {:headers {:accept ""
                                                                                                      :content-type ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/oms/pvt/orders/:orderId/conversation-message HTTP/1.1
Accept: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message"))
    .header("accept", "")
    .header("content-type", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message")
  .header("accept", "")
  .header("content-type", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message',
  method: 'GET',
  headers: {
    accept: '',
    'content-type': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId/conversation-message',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message',
  headers: {accept: '', 'content-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message');

req.headers({
  accept: '',
  'content-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("GET", "/baseUrl/api/oms/pvt/orders/:orderId/conversation-message", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message"

headers = {
    "accept": "",
    "content-type": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''
request["content-type"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/oms/pvt/orders/:orderId/conversation-message') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId/conversation-message")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json; charset=utf-8

RESPONSE BODY json

[
  {
    "attachmentNames": [
      "attachments439505"
    ],
    "body": "      recorrenciaqa                 
 Seu pagamento foi aprovado.
  Referente ao Pedido #1305371685465-01 
  
        Olá, jose.     Estamos providenciando a emissão da Nota Fiscal do seu pedido e o envio do seu produto.  
 
  
   Pagamento
     Visa  final 1111  
R$ 3,99  à vista  
      
    Atenciosamente,
Equipe recorrenciaqa 
  
 
  
   ",
    "date": "2023-01-23T09:23:31.0000000+00:00",
    "firstWords": "Your payment has been aproved and we are waiting for...",
    "from": {
      "aliasMaskType": 0,
      "conversationRelatedTo": "1305371685465-01",
      "conversationSubject": "oms",
      "email": "noreply@store.com.br",
      "emailAlias": "noreply@vtexcommerce.com.br-9814872b.ct.store.com.br",
      "name": "no reply",
      "role": "null"
    },
    "hasAttachment": false,
    "id": "2023-01-23t09-23-08_619a80a05aa34efb982b309c7a1910e3",
    "subject": "Your payment has been aproved.",
    "to": [
      {
        "aliasMaskType": 0,
        "conversationRelatedTo": "1305371685465-01",
        "conversationSubject": "oms",
        "email": "customer.name@email.com",
        "emailAlias": "64d8bd8dbe5c4e7b93b8b3c237e50be1@ct.name.com.br",
        "name": "Mary John",
        "role": "Customer"
      }
    ]
  }
]

GET Export order report with status 'Completed'

{{baseUrl}}/api/oms/pvt/admin/reports/completed

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/admin/reports/completed");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/oms/pvt/admin/reports/completed" {:headers {:content-type ""
                                                                                         :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/admin/reports/completed"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/admin/reports/completed"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/admin/reports/completed");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/admin/reports/completed"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/oms/pvt/admin/reports/completed HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/oms/pvt/admin/reports/completed")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/admin/reports/completed"))
    .header("content-type", "")
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/admin/reports/completed")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/oms/pvt/admin/reports/completed")
  .header("content-type", "")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/oms/pvt/admin/reports/completed');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/admin/reports/completed',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/admin/reports/completed';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/admin/reports/completed',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/admin/reports/completed")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/admin/reports/completed',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/admin/reports/completed',
  headers: {'content-type': '', accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/oms/pvt/admin/reports/completed');

req.headers({
  'content-type': '',
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/admin/reports/completed',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/admin/reports/completed';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/admin/reports/completed"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/admin/reports/completed" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/admin/reports/completed",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/oms/pvt/admin/reports/completed', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/admin/reports/completed');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/pvt/admin/reports/completed');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/admin/reports/completed' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/admin/reports/completed' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/oms/pvt/admin/reports/completed", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/admin/reports/completed"

headers = {
    "content-type": "",
    "accept": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/admin/reports/completed"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/admin/reports/completed")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/oms/pvt/admin/reports/completed') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/admin/reports/completed";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/oms/pvt/admin/reports/completed \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/oms/pvt/admin/reports/completed \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/admin/reports/completed

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/admin/reports/completed")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json; charset=utf-8

RESPONSE BODY json

[
  {
    "cancelled": false,
    "completedDate": "2017-05-10T18:31:35.5530698+00:00",
    "dateOfRequest": "2017-05-10T18:31:28.3984674+00:00",
    "email": "renan.servare@vtex.com.br",
    "filter": "generateCsv=true&orderBy=creationDate%2cdesc&page=1&utc=-0300",
    "hostUri": "http://accountname.vtexcommercestable.com.br/",
    "id": "a83d6d30-a52a-4706-9fc9-e2e7c1841acb",
    "instanceId": "i-0b359c34e40c3f281",
    "lasUpdateTime": "2017-05-10T18:31:35.5250685+00:00",
    "linkToDownload": "http://accountname.vtexcommercestable.com.br/api/oms/pub/636300378883984674/report?AWSAccessKeyId=ASIAJM7A43QHIYFHFSMQ&Expires=1494527496&x-amz-security-token=FQoDYXdzEHsaDBnJIX7Yxf7j6gEuTCK3A3AS4wJiFF97%2FpIGtq4rpqA2F7CqU0g%2BIhPPdD%2FaqnF9TKxX1%2BSj4JloO%2F54XdgL3VZyb%2B76Z0FrOZAYnGZvuE%2FMB4KUz1d4NKFOh0sFt%2FxzYFrBOLvMO%2F%2FW3LMG%2FuyiHecP9pYceVysntj41jJeRcLG%2BRBN4Z69TQBQrUp%2FOS%2FOaJFssVvF6olk5WjK9gYxBDpUUiOQvyAIdhmRKiMfhfOSdT%2FgrPG06YGJE18lm4kIThxH3aqE1k2pl3gVd250QRFzGrFRCPgylnlm5C9xEFf2Mr794Dc2I2ki5GCR8Vhxwgi3rlCvI4G8R1PIXcwG7YfFyzb%2BgKUYCsAcvUschtbpWm5ahXZsJG2FioeFIzHbd3xQ5I2yjV9lrKyUiQHjxsyX7Z0dd7YkKkclmOR85wrhgxHLLpOrM021lYNbm1K9a%2FfPjIOxhMt3a1dgkwNaIJmgxnY3n%2FDgNSJsDpYEpckx9tNqbcuCEJYLC54fmbOH%2B3Nip%2Fks3X%2FBmvzo2iB79Y5cucIEkl9wFeKr9kqw5t5u4ciFf%2F4opHnT85eHZm3POEYsD9XxcIHUrlYyLbMawaFwBgklp6oo7LDNyAU%3D&Signature=%2BFGUxl8zViIqttg5f5y%2F9tbAQhw%3D",
    "publishId": "263fd533551e445caceec991385ef610",
    "query": "{\"Queries\":[{\"Quoted\":true,\"FieldName\":\"InstanceId\",\"FieldValue\":\"263FD533551E445CACEEC991385EF610\"},{\"Quoted\":true,\"FieldName\":\"OrderIsComplete\",\"FieldValue\":\"True\"}],\"Oper\":\"AND\"}",
    "rowNumber": 8,
    "rowsProcessed": 8,
    "startDate": "2017-05-10T18:31:27.4043359+00:00",
    "utcTime": "-0300"
  }
]

GET Export order report with status 'In Progress'

{{baseUrl}}/api/oms/pvt/admin/reports/inprogress

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress" {:headers {:content-type ""
                                                                                          :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/admin/reports/inprogress"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/admin/reports/inprogress");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/oms/pvt/admin/reports/inprogress HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/admin/reports/inprogress"))
    .header("content-type", "")
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/admin/reports/inprogress")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/oms/pvt/admin/reports/inprogress")
  .header("content-type", "")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/admin/reports/inprogress")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/admin/reports/inprogress',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress',
  headers: {'content-type': '', accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress');

req.headers({
  'content-type': '',
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/admin/reports/inprogress"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/admin/reports/inprogress');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/pvt/admin/reports/inprogress');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/admin/reports/inprogress' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/oms/pvt/admin/reports/inprogress", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress"

headers = {
    "content-type": "",
    "accept": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/admin/reports/inprogress")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/oms/pvt/admin/reports/inprogress') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/oms/pvt/admin/reports/inprogress \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/oms/pvt/admin/reports/inprogress \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/admin/reports/inprogress

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/admin/reports/inprogress")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json; charset=utf-8

RESPONSE BODY json

[
  {
    "cancelled": false,
    "completedDate": "2022-05-10T16:21:30.7714518+00:00",
    "dateOfRequest": "2017-05-10T16:21:31.7452567+00:00",
    "email": "renan.servare@vtex.com.br",
    "filter": "generateCsv=true&orderBy=creationDate%2cdesc&page=1&utc=-0300",
    "hostUri": "http://accountname.vtexcommercestable.com.br/",
    "id": "b7bdafba-2456-4aba-9bc0-1d598df685bd",
    "instanceId": "i-0a3b7a89f1fe13ba9",
    "lasUpdateTime": "2017-05-10T16:21:30.7714518+00:00",
    "linkToDownload": "download.link.url.com",
    "publishId": "263fd533551e445caceec991385ef610",
    "query": "{\"Queries\":[{\"Quoted\":true,\"FieldName\":\"InstanceId\",\"FieldValue\":\"263FD533551E445CACEEC991385EF610\"},{\"Quoted\":true,\"FieldName\":\"OrderIsComplete\",\"FieldValue\":\"True\"}],\"Oper\":\"AND\"}",
    "rowNumber": 0,
    "rowsProcessed": 0,
    "startDate": "2017-05-10T16:21:30.7714518+00:00",
    "utcTime": "-0300"
  }
]

GET Get feed order status

{{baseUrl}}/api/oms/pvt/feed/orders/status

HEADERS

Content-Type

QUERY PARAMS

maxLot

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/oms/pvt/feed/orders/status" {:headers {:accept ""
                                                                                    :content-type ""}
                                                                          :query-params {:maxLot ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot="
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/oms/pvt/feed/orders/status?maxLot= HTTP/1.1
Accept: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot="))
    .header("accept", "")
    .header("content-type", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=")
  .header("accept", "")
  .header("content-type", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/feed/orders/status',
  params: {maxLot: ''},
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=',
  method: 'GET',
  headers: {
    accept: '',
    'content-type': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/feed/orders/status?maxLot=',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/feed/orders/status',
  qs: {maxLot: ''},
  headers: {accept: '', 'content-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/oms/pvt/feed/orders/status');

req.query({
  maxLot: ''
});

req.headers({
  accept: '',
  'content-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/feed/orders/status',
  params: {maxLot: ''},
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/feed/orders/status');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'maxLot' => ''
]);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/pvt/feed/orders/status');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'maxLot' => ''
]));

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("GET", "/baseUrl/api/oms/pvt/feed/orders/status?maxLot=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/feed/orders/status"

querystring = {"maxLot":""}

headers = {
    "accept": "",
    "content-type": ""
}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/feed/orders/status"

queryString <- list(maxLot = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''
request["content-type"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/oms/pvt/feed/orders/status') do |req|
  req.headers['accept'] = ''
  req.params['maxLot'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/feed/orders/status";

    let querystring = [
        ("maxLot", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=' \
  --header 'accept: ' \
  --header 'content-type: '

http GET '{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=' \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --header 'content-type: ' \
  --output-document \
  - '{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot='

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/feed/orders/status?maxLot=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Commit feed items

{{baseUrl}}/api/orders/feed

HEADERS

Content-Type

BODY json

{
  "handles": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/orders/feed");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/orders/feed" {:headers {:accept ""}
                                                            :content-type :json
                                                            :form-params {:handles ["AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="]}})

require "http/client"

url = "{{baseUrl}}/api/orders/feed"
headers = HTTP::Headers{
  "content-type" => "application/json"
  "accept" => ""
}
reqBody = "{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/orders/feed"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/orders/feed");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddHeader("accept", "");
request.AddParameter("application/json", "{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/orders/feed"

	payload := strings.NewReader("{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/orders/feed HTTP/1.1
Content-Type: application/json
Accept: 
Host: example.com
Content-Length: 461

{
  "handles": [
    "AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/orders/feed")
  .setHeader("content-type", "application/json")
  .setHeader("accept", "")
  .setBody("{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/orders/feed"))
    .header("content-type", "application/json")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/orders/feed")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/orders/feed")
  .header("content-type", "application/json")
  .header("accept", "")
  .body("{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}")
  .asString();

const data = JSON.stringify({
  handles: [
    'AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE='
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/orders/feed');
xhr.setRequestHeader('content-type', 'application/json');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/feed',
  headers: {'content-type': 'application/json', accept: ''},
  data: {
    handles: [
      'AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE='
    ]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/orders/feed';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json', accept: ''},
  body: '{"handles":["AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/orders/feed',
  method: 'POST',
  headers: {
    'content-type': 'application/json',
    accept: ''
  },
  processData: false,
  data: '{\n  "handles": [\n    "AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/orders/feed")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/orders/feed',
  headers: {
    'content-type': 'application/json',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  handles: [
    'AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE='
  ]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/feed',
  headers: {'content-type': 'application/json', accept: ''},
  body: {
    handles: [
      'AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE='
    ]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/orders/feed');

req.headers({
  'content-type': 'application/json',
  accept: ''
});

req.type('json');
req.send({
  handles: [
    'AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE='
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/feed',
  headers: {'content-type': 'application/json', accept: ''},
  data: {
    handles: [
      'AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE='
    ]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/orders/feed';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json', accept: ''},
  body: '{"handles":["AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json",
                           @"accept": @"" };
NSDictionary *parameters = @{ @"handles": @[ @"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=" ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/orders/feed"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/orders/feed" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "application/json");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/orders/feed",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'handles' => [
        'AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE='
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/orders/feed', [
  'body' => '{
  "handles": [
    "AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="
  ]
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/orders/feed');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json',
  'accept' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'handles' => [
    'AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE='
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'handles' => [
    'AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE='
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/orders/feed');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/orders/feed' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "handles": [
    "AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/orders/feed' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "handles": [
    "AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}"

headers = {
    'content-type': "application/json",
    'accept': ""
}

conn.request("POST", "/baseUrl/api/orders/feed", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/orders/feed"

payload = { "handles": ["AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="] }
headers = {
    "content-type": "application/json",
    "accept": ""
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/orders/feed"

payload <- "{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/orders/feed")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request["accept"] = ''
request.body = "{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/orders/feed') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"handles\": [\n    \"AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=\"\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/orders/feed";

    let payload = json!({"handles": ("AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE=")});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/orders/feed \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --data '{
  "handles": [
    "AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="
  ]
}'

echo '{
  "handles": [
    "AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="
  ]
}' |  \
  http POST {{baseUrl}}/api/orders/feed \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --header 'accept: ' \
  --body-data '{\n  "handles": [\n    "AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/api/orders/feed

import Foundation

let headers = [
  "content-type": "application/json",
  "accept": ""
]
let parameters = ["handles": ["AQEBSM/bSqonHYtx+UrHdbuJ0i7M9yMbI2jtYwMIPdEc4BenuneaCTC9VEJ3dgAy1XtfQvHBvgwZTO8LvGObIKNqiKXDZiMKY25vK+pblZEqf1pWdLMugu5XoHA5ZAd4IcBcXrBcrlr1GU8uvPEBoVLOsVBP9IAxIZkkeEedIDg3K6GPyEXVuPlTEYb/0OCunEGxWF+AZ1frFdXh7ulORTcuqO5oDlBGbpD+QYzCmF4mUZtQ0VVWh9icM1QBVh6PlJ0D/lfwnJKWpBn3jf8c+DTm7sD7wb1Lcz9uWMLhDtPwvH9vue4MvKU9sCahEQe7K5jWuwwb54szGbFKdfcACsTSQ9WlyBfMdbV83c27k68G3cnaBFExkC1MLHHE9UzpQ6l4s43BT4k95ocgMXffnj/HMUYXn+OCvlvjytY59x1OCRE="]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/orders/feed")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Create or update feed configuration

{{baseUrl}}/api/orders/feed/config

HEADERS

Content-Type

BODY json

{
  "filter": {
    "disableSingleFire": false,
    "expression": "",
    "status": [],
    "type": ""
  },
  "queue": {
    "MessageRetentionPeriodInSeconds": 0,
    "visibilityTimeoutInSeconds": 0
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/orders/feed/config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/orders/feed/config" {:headers {:accept ""}
                                                                   :content-type :json
                                                                   :form-params {:filter {:disableSingleFire false
                                                                                          :expression "value > 100"
                                                                                          :type "FromOrders"}
                                                                                 :queue {:MessageRetentionPeriodInSeconds 345600
                                                                                         :visibilityTimeoutInSeconds 250}}})

require "http/client"

url = "{{baseUrl}}/api/orders/feed/config"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/orders/feed/config"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/orders/feed/config");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/orders/feed/config"

	payload := strings.NewReader("{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/orders/feed/config HTTP/1.1
Accept: 
Content-Type: application/json
Host: example.com
Content-Length: 214

{
  "filter": {
    "disableSingleFire": false,
    "expression": "value > 100",
    "type": "FromOrders"
  },
  "queue": {
    "MessageRetentionPeriodInSeconds": 345600,
    "visibilityTimeoutInSeconds": 250
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/orders/feed/config")
  .setHeader("accept", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/orders/feed/config"))
    .header("accept", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/orders/feed/config")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/orders/feed/config")
  .header("accept", "")
  .header("content-type", "application/json")
  .body("{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}")
  .asString();

const data = JSON.stringify({
  filter: {
    disableSingleFire: false,
    expression: 'value > 100',
    type: 'FromOrders'
  },
  queue: {
    MessageRetentionPeriodInSeconds: 345600,
    visibilityTimeoutInSeconds: 250
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/orders/feed/config');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/feed/config',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {
    filter: {disableSingleFire: false, expression: 'value > 100', type: 'FromOrders'},
    queue: {MessageRetentionPeriodInSeconds: 345600, visibilityTimeoutInSeconds: 250}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/orders/feed/config';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"filter":{"disableSingleFire":false,"expression":"value > 100","type":"FromOrders"},"queue":{"MessageRetentionPeriodInSeconds":345600,"visibilityTimeoutInSeconds":250}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/orders/feed/config',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "filter": {\n    "disableSingleFire": false,\n    "expression": "value > 100",\n    "type": "FromOrders"\n  },\n  "queue": {\n    "MessageRetentionPeriodInSeconds": 345600,\n    "visibilityTimeoutInSeconds": 250\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/orders/feed/config")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/orders/feed/config',
  headers: {
    accept: '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  filter: {disableSingleFire: false, expression: 'value > 100', type: 'FromOrders'},
  queue: {MessageRetentionPeriodInSeconds: 345600, visibilityTimeoutInSeconds: 250}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/feed/config',
  headers: {accept: '', 'content-type': 'application/json'},
  body: {
    filter: {disableSingleFire: false, expression: 'value > 100', type: 'FromOrders'},
    queue: {MessageRetentionPeriodInSeconds: 345600, visibilityTimeoutInSeconds: 250}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/orders/feed/config');

req.headers({
  accept: '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  filter: {
    disableSingleFire: false,
    expression: 'value > 100',
    type: 'FromOrders'
  },
  queue: {
    MessageRetentionPeriodInSeconds: 345600,
    visibilityTimeoutInSeconds: 250
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/feed/config',
  headers: {accept: '', 'content-type': 'application/json'},
  data: {
    filter: {disableSingleFire: false, expression: 'value > 100', type: 'FromOrders'},
    queue: {MessageRetentionPeriodInSeconds: 345600, visibilityTimeoutInSeconds: 250}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/orders/feed/config';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': 'application/json'},
  body: '{"filter":{"disableSingleFire":false,"expression":"value > 100","type":"FromOrders"},"queue":{"MessageRetentionPeriodInSeconds":345600,"visibilityTimeoutInSeconds":250}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"filter": @{ @"disableSingleFire": @NO, @"expression": @"value > 100", @"type": @"FromOrders" },
                              @"queue": @{ @"MessageRetentionPeriodInSeconds": @345600, @"visibilityTimeoutInSeconds": @250 } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/orders/feed/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/orders/feed/config" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/orders/feed/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'filter' => [
        'disableSingleFire' => null,
        'expression' => 'value > 100',
        'type' => 'FromOrders'
    ],
    'queue' => [
        'MessageRetentionPeriodInSeconds' => 345600,
        'visibilityTimeoutInSeconds' => 250
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/orders/feed/config', [
  'body' => '{
  "filter": {
    "disableSingleFire": false,
    "expression": "value > 100",
    "type": "FromOrders"
  },
  "queue": {
    "MessageRetentionPeriodInSeconds": 345600,
    "visibilityTimeoutInSeconds": 250
  }
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/orders/feed/config');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'filter' => [
    'disableSingleFire' => null,
    'expression' => 'value > 100',
    'type' => 'FromOrders'
  ],
  'queue' => [
    'MessageRetentionPeriodInSeconds' => 345600,
    'visibilityTimeoutInSeconds' => 250
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'filter' => [
    'disableSingleFire' => null,
    'expression' => 'value > 100',
    'type' => 'FromOrders'
  ],
  'queue' => [
    'MessageRetentionPeriodInSeconds' => 345600,
    'visibilityTimeoutInSeconds' => 250
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/orders/feed/config');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/orders/feed/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "filter": {
    "disableSingleFire": false,
    "expression": "value > 100",
    "type": "FromOrders"
  },
  "queue": {
    "MessageRetentionPeriodInSeconds": 345600,
    "visibilityTimeoutInSeconds": 250
  }
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/orders/feed/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "filter": {
    "disableSingleFire": false,
    "expression": "value > 100",
    "type": "FromOrders"
  },
  "queue": {
    "MessageRetentionPeriodInSeconds": 345600,
    "visibilityTimeoutInSeconds": 250
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}"

headers = {
    'accept': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/api/orders/feed/config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/orders/feed/config"

payload = {
    "filter": {
        "disableSingleFire": False,
        "expression": "value > 100",
        "type": "FromOrders"
    },
    "queue": {
        "MessageRetentionPeriodInSeconds": 345600,
        "visibilityTimeoutInSeconds": 250
    }
}
headers = {
    "accept": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/orders/feed/config"

payload <- "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/orders/feed/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/orders/feed/config') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"value > 100\",\n    \"type\": \"FromOrders\"\n  },\n  \"queue\": {\n    \"MessageRetentionPeriodInSeconds\": 345600,\n    \"visibilityTimeoutInSeconds\": 250\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/orders/feed/config";

    let payload = json!({
        "filter": json!({
            "disableSingleFire": false,
            "expression": "value > 100",
            "type": "FromOrders"
        }),
        "queue": json!({
            "MessageRetentionPeriodInSeconds": 345600,
            "visibilityTimeoutInSeconds": 250
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/orders/feed/config \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --data '{
  "filter": {
    "disableSingleFire": false,
    "expression": "value > 100",
    "type": "FromOrders"
  },
  "queue": {
    "MessageRetentionPeriodInSeconds": 345600,
    "visibilityTimeoutInSeconds": 250
  }
}'

echo '{
  "filter": {
    "disableSingleFire": false,
    "expression": "value > 100",
    "type": "FromOrders"
  },
  "queue": {
    "MessageRetentionPeriodInSeconds": 345600,
    "visibilityTimeoutInSeconds": 250
  }
}' |  \
  http POST {{baseUrl}}/api/orders/feed/config \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "filter": {\n    "disableSingleFire": false,\n    "expression": "value > 100",\n    "type": "FromOrders"\n  },\n  "queue": {\n    "MessageRetentionPeriodInSeconds": 345600,\n    "visibilityTimeoutInSeconds": 250\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/orders/feed/config

import Foundation

let headers = [
  "accept": "",
  "content-type": "application/json"
]
let parameters = [
  "filter": [
    "disableSingleFire": false,
    "expression": "value > 100",
    "type": "FromOrders"
  ],
  "queue": [
    "MessageRetentionPeriodInSeconds": 345600,
    "visibilityTimeoutInSeconds": 250
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/orders/feed/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

DELETE Delete feed configuration

{{baseUrl}}/api/orders/feed/config

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/orders/feed/config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/orders/feed/config" {:headers {:accept ""
                                                                               :content-type ""}})

require "http/client"

url = "{{baseUrl}}/api/orders/feed/config"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/orders/feed/config"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/orders/feed/config");
var request = new RestRequest("", Method.Delete);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/orders/feed/config"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/api/orders/feed/config HTTP/1.1
Accept: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/orders/feed/config")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/orders/feed/config"))
    .header("accept", "")
    .header("content-type", "")
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/orders/feed/config")
  .delete(null)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/orders/feed/config")
  .header("accept", "")
  .header("content-type", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/api/orders/feed/config');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/orders/feed/config',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/orders/feed/config';
const options = {method: 'DELETE', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/orders/feed/config',
  method: 'DELETE',
  headers: {
    accept: '',
    'content-type': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/orders/feed/config")
  .delete(null)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/orders/feed/config',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/orders/feed/config',
  headers: {accept: '', 'content-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/orders/feed/config');

req.headers({
  accept: '',
  'content-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/orders/feed/config',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/orders/feed/config';
const options = {method: 'DELETE', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/orders/feed/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/orders/feed/config" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/orders/feed/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/api/orders/feed/config', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/orders/feed/config');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/orders/feed/config');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/orders/feed/config' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/orders/feed/config' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("DELETE", "/baseUrl/api/orders/feed/config", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/orders/feed/config"

headers = {
    "accept": "",
    "content-type": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/orders/feed/config"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/orders/feed/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = ''
request["content-type"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/api/orders/feed/config') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/orders/feed/config";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/api/orders/feed/config \
  --header 'accept: ' \
  --header 'content-type: '

http DELETE {{baseUrl}}/api/orders/feed/config \
  accept:'' \
  content-type:''

wget --quiet \
  --method DELETE \
  --header 'accept: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/api/orders/feed/config

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/orders/feed/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get feed configuration

{{baseUrl}}/api/orders/feed/config

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/orders/feed/config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/orders/feed/config" {:headers {:content-type ""
                                                                            :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/orders/feed/config"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/orders/feed/config"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/orders/feed/config");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/orders/feed/config"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/orders/feed/config HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/orders/feed/config")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/orders/feed/config"))
    .header("content-type", "")
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/orders/feed/config")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/orders/feed/config")
  .header("content-type", "")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/orders/feed/config');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/orders/feed/config',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/orders/feed/config';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/orders/feed/config',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/orders/feed/config")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/orders/feed/config',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/orders/feed/config',
  headers: {'content-type': '', accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/orders/feed/config');

req.headers({
  'content-type': '',
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/orders/feed/config',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/orders/feed/config';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/orders/feed/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/orders/feed/config" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/orders/feed/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/orders/feed/config', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/orders/feed/config');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/orders/feed/config');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/orders/feed/config' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/orders/feed/config' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/orders/feed/config", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/orders/feed/config"

headers = {
    "content-type": "",
    "accept": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/orders/feed/config"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/orders/feed/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/orders/feed/config') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/orders/feed/config";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/orders/feed/config \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/orders/feed/config \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/orders/feed/config

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/orders/feed/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "filter": {
    "disableSingleFire": false,
    "expression": "status = \"payment-pending\"",
    "type": "FromOrders"
  },
  "queue": {
    "messageRetentionPeriodInSeconds": 345600,
    "visibilityTimeoutInSeconds": 240
  }
}

GET Retrieve feed items

{{baseUrl}}/api/orders/feed

HEADERS

Content-Type

QUERY PARAMS

maxlot

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/orders/feed?maxlot=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/orders/feed" {:headers {:accept ""
                                                                     :content-type ""}
                                                           :query-params {:maxlot ""}})

require "http/client"

url = "{{baseUrl}}/api/orders/feed?maxlot="
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/orders/feed?maxlot="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/orders/feed?maxlot=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/orders/feed?maxlot="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/orders/feed?maxlot= HTTP/1.1
Accept: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/orders/feed?maxlot=")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/orders/feed?maxlot="))
    .header("accept", "")
    .header("content-type", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/orders/feed?maxlot=")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/orders/feed?maxlot=")
  .header("accept", "")
  .header("content-type", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/orders/feed?maxlot=');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/orders/feed',
  params: {maxlot: ''},
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/orders/feed?maxlot=';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/orders/feed?maxlot=',
  method: 'GET',
  headers: {
    accept: '',
    'content-type': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/orders/feed?maxlot=")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/orders/feed?maxlot=',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/orders/feed',
  qs: {maxlot: ''},
  headers: {accept: '', 'content-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/orders/feed');

req.query({
  maxlot: ''
});

req.headers({
  accept: '',
  'content-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/orders/feed',
  params: {maxlot: ''},
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/orders/feed?maxlot=';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/orders/feed?maxlot="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/orders/feed?maxlot=" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/orders/feed?maxlot=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/orders/feed?maxlot=', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/orders/feed');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'maxlot' => ''
]);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/orders/feed');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'maxlot' => ''
]));

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/orders/feed?maxlot=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/orders/feed?maxlot=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("GET", "/baseUrl/api/orders/feed?maxlot=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/orders/feed"

querystring = {"maxlot":""}

headers = {
    "accept": "",
    "content-type": ""
}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/orders/feed"

queryString <- list(maxlot = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/orders/feed?maxlot=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''
request["content-type"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/orders/feed') do |req|
  req.headers['accept'] = ''
  req.params['maxlot'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/orders/feed";

    let querystring = [
        ("maxlot", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/orders/feed?maxlot=' \
  --header 'accept: ' \
  --header 'content-type: '

http GET '{{baseUrl}}/api/orders/feed?maxlot=' \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --header 'content-type: ' \
  --output-document \
  - '{{baseUrl}}/api/orders/feed?maxlot='

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/orders/feed?maxlot=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

[
  {
    "currentChange": "2019-08-12T20:54:23.7153839Z",
    "domain": "Fulfillment",
    "eventId": "ED423DDED4C1AE580CADAC1A4D02DA3F",
    "handle": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwOi8vc2NoZW1hcy54bWxzb2FwLm9yZy93cy8yMDA1LzA1L2lkZW50aXR5L2NsYWltcy9uYW1lIjoidnRleGFwcGtleS1wYXJ0bmVyc2xhdGFtLVJNQkpNUyIsIkFwcEtleSI6InZ0ZXhhcHBrZXktcGFydG5lcnNsYXRhbS1STUJKTVMiLCJBY2NvdW50IjoicGFydG5lcnNsYXRhbSIsIkhhbmRsZSI6IkFRRUIzbmtWR0piOXhhNGRjYlpkOTFVVWMyL2JObHc0Qnp3ZlNLV201Rjg2QXgrSGlRM053bEJkb2NwM2wvVytLdjFNQTZ4d3ZLcFYwYjlSeUttNVRpb3hrSVFMSG1Uck9xenB2aFlwU29uMzRrVmlNaWZHY2lnZFFqalBJdk00eWU4amVuaS9QKytaTmVxOFZWeFNGay81Yzg3YS84MTRjTFg2WGZPR2x2WitlTnVjTzA3S3UxK0xXaU5vQmJEY0cycGxKekxkRks3Qld3b1NTV3BmSWhrOGhmSFNkSzlzZVpJeG01QXFLbHFrUHNDNGk5emVaYVpBUVVrSi9aZWo3UjRrRDVRaXFjNmpjcnFheEdHc1lsNHMzUWM0ZmtWdmhYblJVQ2l2ZGdpMEtUYS8zcXlWWU9QTktIV2huTlZxMEZHNDNjME4vaWh6dDc0d1laNVl6aDFJRitHU2t1YTkrN1pCdnQ2VGs1cFRhZmVVclk0ckNPL2Fobnl1eXFLOG53ZkorVWxUTmt2ZVNFS29FdTNiUWQzSmc5R1lYWHlXOVVxRGo5dHJIZ1N5M3ZZa0dBWjd0MDZNZWUwQnBsdFBxWExaIiwiT3JkZXJJZCI6Ijk1MzcxMjAwNDEyNi0wMSIsIk1lc3NhZ2VJZCI6ImI5YjI4NDkwLTNjNzAtNDdjNi1hMTE3LWNhN2FjMTk2MDY1OSIsIkRvbWFpbiI6IkZ1bGZpbGxtZW50IiwiU3RhdGUiOiJyZWFkeS1mb3ItaGFuZGxpbmciLCJMYXN0U3RhdGUiOiJ3aW5kb3ctdG8tY2FuY2VsIiwiTGFzdENoYW5nZSI6IjA4LzEyLzIwMTkgMjA6NTQ6MDEiLCJDdXJyZW50Q2hhbmdlIjoiMDgvMTIvMjAxOSAyMDo1NDoyMyIsIkNyZWF0ZWRBdCI6IjA4LzEyLzIwMTkgMjE6MDE6MzAiLCJpc3MiOiJicm9hZGNhc3QtYXBpLnZ0ZXhjb21tZXJjZS5jb20uYnIiLCJhdWQiOiJwYXJ0bmVyc2xhdGFtX3Z0ZXhhcHBrZXktcGFydG5lcnNsYXRhbS1STUJKTVMifQ.7RQBZQb6pHhFhA_jMKTiSoJbDck7awgD3Xx7sdJcW6w",
    "lastChange": "2019-08-12T20:54:01.134057Z",
    "lastState": "window-to-cancel",
    "orderId": "953712004126-01",
    "state": "ready-for-handling"
  }
]

POST Test JSONata expression

{{baseUrl}}/api/orders/expressions/jsonata

HEADERS

Content-Type

BODY json

{
  "Document": "",
  "Expression": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/orders/expressions/jsonata");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/orders/expressions/jsonata" {:headers {:accept ""}
                                                                           :content-type :json
                                                                           :form-params {:Document ""
                                                                                         :Expression ""}})

require "http/client"

url = "{{baseUrl}}/api/orders/expressions/jsonata"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/orders/expressions/jsonata"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/orders/expressions/jsonata");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/orders/expressions/jsonata"

	payload := strings.NewReader("{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/orders/expressions/jsonata HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 40

{
  "Document": "",
  "Expression": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/orders/expressions/jsonata")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/orders/expressions/jsonata"))
    .header("accept", "")
    .header("content-type", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/orders/expressions/jsonata")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/orders/expressions/jsonata")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Document: '',
  Expression: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/orders/expressions/jsonata');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/expressions/jsonata',
  headers: {accept: '', 'content-type': ''},
  data: {Document: '', Expression: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/orders/expressions/jsonata';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"Document":"","Expression":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/orders/expressions/jsonata',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "Document": "",\n  "Expression": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/orders/expressions/jsonata")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/orders/expressions/jsonata',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({Document: '', Expression: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/expressions/jsonata',
  headers: {accept: '', 'content-type': ''},
  body: {Document: '', Expression: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/orders/expressions/jsonata');

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  Document: '',
  Expression: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/expressions/jsonata',
  headers: {accept: '', 'content-type': ''},
  data: {Document: '', Expression: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/orders/expressions/jsonata';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"Document":"","Expression":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"Document": @"",
                              @"Expression": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/orders/expressions/jsonata"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/orders/expressions/jsonata" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/orders/expressions/jsonata",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Document' => '',
    'Expression' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/orders/expressions/jsonata', [
  'body' => '{
  "Document": "",
  "Expression": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/orders/expressions/jsonata');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Document' => '',
  'Expression' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Document' => '',
  'Expression' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/orders/expressions/jsonata');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/orders/expressions/jsonata' -Method POST -Headers $headers -ContentType '' -Body '{
  "Document": "",
  "Expression": ""
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/orders/expressions/jsonata' -Method POST -Headers $headers -ContentType '' -Body '{
  "Document": "",
  "Expression": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/api/orders/expressions/jsonata", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/orders/expressions/jsonata"

payload = {
    "Document": "",
    "Expression": ""
}
headers = {
    "accept": "",
    "content-type": ""
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/orders/expressions/jsonata"

payload <- "{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/orders/expressions/jsonata")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/orders/expressions/jsonata') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"Document\": \"\",\n  \"Expression\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/orders/expressions/jsonata";

    let payload = json!({
        "Document": "",
        "Expression": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/orders/expressions/jsonata \
  --header 'accept: ' \
  --header 'content-type: ' \
  --data '{
  "Document": "",
  "Expression": ""
}'

echo '{
  "Document": "",
  "Expression": ""
}' |  \
  http POST {{baseUrl}}/api/orders/expressions/jsonata \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "Document": "",\n  "Expression": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/orders/expressions/jsonata

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = [
  "Document": "",
  "Expression": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/orders/expressions/jsonata")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

text/plain

RESPONSE BODY text

True

POST Order invoice notification

{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice

HEADERS

Content-Type

QUERY PARAMS

orderId

BODY json

{
  "courier": "",
  "dispatchedDate": "",
  "embeddedInvoice": "",
  "invoiceKey": "",
  "invoiceNumber": "",
  "invoiceUrl": "",
  "invoiceValue": "",
  "issuanceDate": "",
  "items": [
    {
      "description": "",
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "trackingNumber": "",
  "trackingUrl": "",
  "type": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice" {:headers {:accept ""}
                                                                                :content-type :json
                                                                                :form-params {:courier ""
                                                                                              :dispatchedDate ""
                                                                                              :embeddedInvoice ""
                                                                                              :invoiceKey ""
                                                                                              :invoiceNumber ""
                                                                                              :invoiceUrl ""
                                                                                              :invoiceValue ""
                                                                                              :issuanceDate ""
                                                                                              :items [{:description ""
                                                                                                       :id ""
                                                                                                       :price 0
                                                                                                       :quantity 0}]
                                                                                              :trackingNumber ""
                                                                                              :trackingUrl ""
                                                                                              :type ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice"

	payload := strings.NewReader("{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/oms/pvt/orders/:orderId/invoice HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 343

{
  "courier": "",
  "dispatchedDate": "",
  "embeddedInvoice": "",
  "invoiceKey": "",
  "invoiceNumber": "",
  "invoiceUrl": "",
  "invoiceValue": "",
  "issuanceDate": "",
  "items": [
    {
      "description": "",
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "trackingNumber": "",
  "trackingUrl": "",
  "type": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice"))
    .header("accept", "")
    .header("content-type", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  courier: '',
  dispatchedDate: '',
  embeddedInvoice: '',
  invoiceKey: '',
  invoiceNumber: '',
  invoiceUrl: '',
  invoiceValue: '',
  issuanceDate: '',
  items: [
    {
      description: '',
      id: '',
      price: 0,
      quantity: 0
    }
  ],
  trackingNumber: '',
  trackingUrl: '',
  type: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice',
  headers: {accept: '', 'content-type': ''},
  data: {
    courier: '',
    dispatchedDate: '',
    embeddedInvoice: '',
    invoiceKey: '',
    invoiceNumber: '',
    invoiceUrl: '',
    invoiceValue: '',
    issuanceDate: '',
    items: [{description: '', id: '', price: 0, quantity: 0}],
    trackingNumber: '',
    trackingUrl: '',
    type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"courier":"","dispatchedDate":"","embeddedInvoice":"","invoiceKey":"","invoiceNumber":"","invoiceUrl":"","invoiceValue":"","issuanceDate":"","items":[{"description":"","id":"","price":0,"quantity":0}],"trackingNumber":"","trackingUrl":"","type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "courier": "",\n  "dispatchedDate": "",\n  "embeddedInvoice": "",\n  "invoiceKey": "",\n  "invoiceNumber": "",\n  "invoiceUrl": "",\n  "invoiceValue": "",\n  "issuanceDate": "",\n  "items": [\n    {\n      "description": "",\n      "id": "",\n      "price": 0,\n      "quantity": 0\n    }\n  ],\n  "trackingNumber": "",\n  "trackingUrl": "",\n  "type": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId/invoice',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  courier: '',
  dispatchedDate: '',
  embeddedInvoice: '',
  invoiceKey: '',
  invoiceNumber: '',
  invoiceUrl: '',
  invoiceValue: '',
  issuanceDate: '',
  items: [{description: '', id: '', price: 0, quantity: 0}],
  trackingNumber: '',
  trackingUrl: '',
  type: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice',
  headers: {accept: '', 'content-type': ''},
  body: {
    courier: '',
    dispatchedDate: '',
    embeddedInvoice: '',
    invoiceKey: '',
    invoiceNumber: '',
    invoiceUrl: '',
    invoiceValue: '',
    issuanceDate: '',
    items: [{description: '', id: '', price: 0, quantity: 0}],
    trackingNumber: '',
    trackingUrl: '',
    type: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice');

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  courier: '',
  dispatchedDate: '',
  embeddedInvoice: '',
  invoiceKey: '',
  invoiceNumber: '',
  invoiceUrl: '',
  invoiceValue: '',
  issuanceDate: '',
  items: [
    {
      description: '',
      id: '',
      price: 0,
      quantity: 0
    }
  ],
  trackingNumber: '',
  trackingUrl: '',
  type: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice',
  headers: {accept: '', 'content-type': ''},
  data: {
    courier: '',
    dispatchedDate: '',
    embeddedInvoice: '',
    invoiceKey: '',
    invoiceNumber: '',
    invoiceUrl: '',
    invoiceValue: '',
    issuanceDate: '',
    items: [{description: '', id: '', price: 0, quantity: 0}],
    trackingNumber: '',
    trackingUrl: '',
    type: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"courier":"","dispatchedDate":"","embeddedInvoice":"","invoiceKey":"","invoiceNumber":"","invoiceUrl":"","invoiceValue":"","issuanceDate":"","items":[{"description":"","id":"","price":0,"quantity":0}],"trackingNumber":"","trackingUrl":"","type":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"courier": @"",
                              @"dispatchedDate": @"",
                              @"embeddedInvoice": @"",
                              @"invoiceKey": @"",
                              @"invoiceNumber": @"",
                              @"invoiceUrl": @"",
                              @"invoiceValue": @"",
                              @"issuanceDate": @"",
                              @"items": @[ @{ @"description": @"", @"id": @"", @"price": @0, @"quantity": @0 } ],
                              @"trackingNumber": @"",
                              @"trackingUrl": @"",
                              @"type": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'courier' => '',
    'dispatchedDate' => '',
    'embeddedInvoice' => '',
    'invoiceKey' => '',
    'invoiceNumber' => '',
    'invoiceUrl' => '',
    'invoiceValue' => '',
    'issuanceDate' => '',
    'items' => [
        [
                'description' => '',
                'id' => '',
                'price' => 0,
                'quantity' => 0
        ]
    ],
    'trackingNumber' => '',
    'trackingUrl' => '',
    'type' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice', [
  'body' => '{
  "courier": "",
  "dispatchedDate": "",
  "embeddedInvoice": "",
  "invoiceKey": "",
  "invoiceNumber": "",
  "invoiceUrl": "",
  "invoiceValue": "",
  "issuanceDate": "",
  "items": [
    {
      "description": "",
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "trackingNumber": "",
  "trackingUrl": "",
  "type": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'courier' => '',
  'dispatchedDate' => '',
  'embeddedInvoice' => '',
  'invoiceKey' => '',
  'invoiceNumber' => '',
  'invoiceUrl' => '',
  'invoiceValue' => '',
  'issuanceDate' => '',
  'items' => [
    [
        'description' => '',
        'id' => '',
        'price' => 0,
        'quantity' => 0
    ]
  ],
  'trackingNumber' => '',
  'trackingUrl' => '',
  'type' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'courier' => '',
  'dispatchedDate' => '',
  'embeddedInvoice' => '',
  'invoiceKey' => '',
  'invoiceNumber' => '',
  'invoiceUrl' => '',
  'invoiceValue' => '',
  'issuanceDate' => '',
  'items' => [
    [
        'description' => '',
        'id' => '',
        'price' => 0,
        'quantity' => 0
    ]
  ],
  'trackingNumber' => '',
  'trackingUrl' => '',
  'type' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice' -Method POST -Headers $headers -ContentType '' -Body '{
  "courier": "",
  "dispatchedDate": "",
  "embeddedInvoice": "",
  "invoiceKey": "",
  "invoiceNumber": "",
  "invoiceUrl": "",
  "invoiceValue": "",
  "issuanceDate": "",
  "items": [
    {
      "description": "",
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "trackingNumber": "",
  "trackingUrl": "",
  "type": ""
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice' -Method POST -Headers $headers -ContentType '' -Body '{
  "courier": "",
  "dispatchedDate": "",
  "embeddedInvoice": "",
  "invoiceKey": "",
  "invoiceNumber": "",
  "invoiceUrl": "",
  "invoiceValue": "",
  "issuanceDate": "",
  "items": [
    {
      "description": "",
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "trackingNumber": "",
  "trackingUrl": "",
  "type": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/api/oms/pvt/orders/:orderId/invoice", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice"

payload = {
    "courier": "",
    "dispatchedDate": "",
    "embeddedInvoice": "",
    "invoiceKey": "",
    "invoiceNumber": "",
    "invoiceUrl": "",
    "invoiceValue": "",
    "issuanceDate": "",
    "items": [
        {
            "description": "",
            "id": "",
            "price": 0,
            "quantity": 0
        }
    ],
    "trackingNumber": "",
    "trackingUrl": "",
    "type": ""
}
headers = {
    "accept": "",
    "content-type": ""
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice"

payload <- "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/oms/pvt/orders/:orderId/invoice') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"embeddedInvoice\": \"\",\n  \"invoiceKey\": \"\",\n  \"invoiceNumber\": \"\",\n  \"invoiceUrl\": \"\",\n  \"invoiceValue\": \"\",\n  \"issuanceDate\": \"\",\n  \"items\": [\n    {\n      \"description\": \"\",\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\",\n  \"type\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice";

    let payload = json!({
        "courier": "",
        "dispatchedDate": "",
        "embeddedInvoice": "",
        "invoiceKey": "",
        "invoiceNumber": "",
        "invoiceUrl": "",
        "invoiceValue": "",
        "issuanceDate": "",
        "items": (
            json!({
                "description": "",
                "id": "",
                "price": 0,
                "quantity": 0
            })
        ),
        "trackingNumber": "",
        "trackingUrl": "",
        "type": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId/invoice \
  --header 'accept: ' \
  --header 'content-type: ' \
  --data '{
  "courier": "",
  "dispatchedDate": "",
  "embeddedInvoice": "",
  "invoiceKey": "",
  "invoiceNumber": "",
  "invoiceUrl": "",
  "invoiceValue": "",
  "issuanceDate": "",
  "items": [
    {
      "description": "",
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "trackingNumber": "",
  "trackingUrl": "",
  "type": ""
}'

echo '{
  "courier": "",
  "dispatchedDate": "",
  "embeddedInvoice": "",
  "invoiceKey": "",
  "invoiceNumber": "",
  "invoiceUrl": "",
  "invoiceValue": "",
  "issuanceDate": "",
  "items": [
    {
      "description": "",
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "trackingNumber": "",
  "trackingUrl": "",
  "type": ""
}' |  \
  http POST {{baseUrl}}/api/oms/pvt/orders/:orderId/invoice \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "courier": "",\n  "dispatchedDate": "",\n  "embeddedInvoice": "",\n  "invoiceKey": "",\n  "invoiceNumber": "",\n  "invoiceUrl": "",\n  "invoiceValue": "",\n  "issuanceDate": "",\n  "items": [\n    {\n      "description": "",\n      "id": "",\n      "price": 0,\n      "quantity": 0\n    }\n  ],\n  "trackingNumber": "",\n  "trackingUrl": "",\n  "type": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId/invoice

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = [
  "courier": "",
  "dispatchedDate": "",
  "embeddedInvoice": "",
  "invoiceKey": "",
  "invoiceNumber": "",
  "invoiceUrl": "",
  "invoiceValue": "",
  "issuanceDate": "",
  "items": [
    [
      "description": "",
      "id": "",
      "price": 0,
      "quantity": 0
    ]
  ],
  "trackingNumber": "",
  "trackingUrl": "",
  "type": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "date": "2014-02-07T15:22:56.7612218-02:00",
  "orderId": "123543123",
  "receipt": "38e0e47da2934847b489216d208cfd91"
}

PATCH Update order's partial invoice (send tracking number)

{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber

HEADERS

Content-Type

QUERY PARAMS

orderId

invoiceNumber

BODY json

{
  "courier": "",
  "dispatchedDate": "",
  "trackingNumber": "",
  "trackingUrl": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber" {:headers {:accept ""}
                                                                                                :content-type :json
                                                                                                :form-params {:courier ""
                                                                                                              :dispatchedDate ""
                                                                                                              :trackingNumber ""
                                                                                                              :trackingUrl ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}
reqBody = "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
request.AddParameter("", "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber"

	payload := strings.NewReader("{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber HTTP/1.1
Content-Type: 
Accept: 
Host: example.com
Content-Length: 88

{
  "courier": "",
  "dispatchedDate": "",
  "trackingNumber": "",
  "trackingUrl": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .setBody("{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber"))
    .header("content-type", "")
    .header("accept", "")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber")
  .patch(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber")
  .header("content-type", "")
  .header("accept", "")
  .body("{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  courier: '',
  dispatchedDate: '',
  trackingNumber: '',
  trackingUrl: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber',
  headers: {'content-type': '', accept: ''},
  data: {courier: '', dispatchedDate: '', trackingNumber: '', trackingUrl: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber';
const options = {
  method: 'PATCH',
  headers: {'content-type': '', accept: ''},
  body: '{"courier":"","dispatchedDate":"","trackingNumber":"","trackingUrl":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber',
  method: 'PATCH',
  headers: {
    'content-type': '',
    accept: ''
  },
  processData: false,
  data: '{\n  "courier": "",\n  "dispatchedDate": "",\n  "trackingNumber": "",\n  "trackingUrl": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber")
  .patch(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({courier: '', dispatchedDate: '', trackingNumber: '', trackingUrl: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber',
  headers: {'content-type': '', accept: ''},
  body: {courier: '', dispatchedDate: '', trackingNumber: '', trackingUrl: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber');

req.headers({
  'content-type': '',
  accept: ''
});

req.type('json');
req.send({
  courier: '',
  dispatchedDate: '',
  trackingNumber: '',
  trackingUrl: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber',
  headers: {'content-type': '', accept: ''},
  data: {courier: '', dispatchedDate: '', trackingNumber: '', trackingUrl: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber';
const options = {
  method: 'PATCH',
  headers: {'content-type': '', accept: ''},
  body: '{"courier":"","dispatchedDate":"","trackingNumber":"","trackingUrl":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };
NSDictionary *parameters = @{ @"courier": @"",
                              @"dispatchedDate": @"",
                              @"trackingNumber": @"",
                              @"trackingUrl": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'courier' => '',
    'dispatchedDate' => '',
    'trackingNumber' => '',
    'trackingUrl' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber', [
  'body' => '{
  "courier": "",
  "dispatchedDate": "",
  "trackingNumber": "",
  "trackingUrl": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'courier' => '',
  'dispatchedDate' => '',
  'trackingNumber' => '',
  'trackingUrl' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'courier' => '',
  'dispatchedDate' => '',
  'trackingNumber' => '',
  'trackingUrl' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber' -Method PATCH -Headers $headers -ContentType '' -Body '{
  "courier": "",
  "dispatchedDate": "",
  "trackingNumber": "",
  "trackingUrl": ""
}'

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber' -Method PATCH -Headers $headers -ContentType '' -Body '{
  "courier": "",
  "dispatchedDate": "",
  "trackingNumber": "",
  "trackingUrl": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}"

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("PATCH", "/baseUrl/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber"

payload = {
    "courier": "",
    "dispatchedDate": "",
    "trackingNumber": "",
    "trackingUrl": ""
}
headers = {
    "content-type": "",
    "accept": ""
}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber"

payload <- "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = ''
request["accept"] = ''
request.body = "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.patch('/baseUrl/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"courier\": \"\",\n  \"dispatchedDate\": \"\",\n  \"trackingNumber\": \"\",\n  \"trackingUrl\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber";

    let payload = json!({
        "courier": "",
        "dispatchedDate": "",
        "trackingNumber": "",
        "trackingUrl": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PATCH \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber \
  --header 'accept: ' \
  --header 'content-type: ' \
  --data '{
  "courier": "",
  "dispatchedDate": "",
  "trackingNumber": "",
  "trackingUrl": ""
}'

echo '{
  "courier": "",
  "dispatchedDate": "",
  "trackingNumber": "",
  "trackingUrl": ""
}' |  \
  http PATCH {{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber \
  accept:'' \
  content-type:''

wget --quiet \
  --method PATCH \
  --header 'content-type: ' \
  --header 'accept: ' \
  --body-data '{\n  "courier": "",\n  "dispatchedDate": "",\n  "trackingNumber": "",\n  "trackingUrl": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]
let parameters = [
  "courier": "",
  "dispatchedDate": "",
  "trackingNumber": "",
  "trackingUrl": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "date": "2019-02-08T13:16:13.4617653+00:00",
  "orderId": "00-v5195004lux-01",
  "receipt": "527b1ae251264ef1b7a9b597cd8f16b9"
}

POST Create or update hook configuration

{{baseUrl}}/api/orders/hook/config

HEADERS

Content-Type

BODY json

{
  "filter": {
    "disableSingleFire": false,
    "expression": "",
    "status": [],
    "type": ""
  },
  "hook": {
    "headers": {
      "key": ""
    },
    "url": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/orders/hook/config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/orders/hook/config" {:headers {:accept ""}
                                                                   :content-type :json
                                                                   :form-params {:filter {:disableSingleFire false
                                                                                          :expression ""
                                                                                          :status []
                                                                                          :type ""}
                                                                                 :hook {:headers {:key ""}
                                                                                        :url ""}}})

require "http/client"

url = "{{baseUrl}}/api/orders/hook/config"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}
reqBody = "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/orders/hook/config"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/orders/hook/config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
request.AddParameter("", "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/orders/hook/config"

	payload := strings.NewReader("{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/orders/hook/config HTTP/1.1
Content-Type: 
Accept: 
Host: example.com
Content-Length: 179

{
  "filter": {
    "disableSingleFire": false,
    "expression": "",
    "status": [],
    "type": ""
  },
  "hook": {
    "headers": {
      "key": ""
    },
    "url": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/orders/hook/config")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .setBody("{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/orders/hook/config"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/orders/hook/config")
  .post(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/orders/hook/config")
  .header("content-type", "")
  .header("accept", "")
  .body("{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  filter: {
    disableSingleFire: false,
    expression: '',
    status: [],
    type: ''
  },
  hook: {
    headers: {
      key: ''
    },
    url: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/orders/hook/config');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/hook/config',
  headers: {'content-type': '', accept: ''},
  data: {
    filter: {disableSingleFire: false, expression: '', status: [], type: ''},
    hook: {headers: {key: ''}, url: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/orders/hook/config';
const options = {
  method: 'POST',
  headers: {'content-type': '', accept: ''},
  body: '{"filter":{"disableSingleFire":false,"expression":"","status":[],"type":""},"hook":{"headers":{"key":""},"url":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/orders/hook/config',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  },
  processData: false,
  data: '{\n  "filter": {\n    "disableSingleFire": false,\n    "expression": "",\n    "status": [],\n    "type": ""\n  },\n  "hook": {\n    "headers": {\n      "key": ""\n    },\n    "url": ""\n  }\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/orders/hook/config")
  .post(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/orders/hook/config',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  filter: {disableSingleFire: false, expression: '', status: [], type: ''},
  hook: {headers: {key: ''}, url: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/hook/config',
  headers: {'content-type': '', accept: ''},
  body: {
    filter: {disableSingleFire: false, expression: '', status: [], type: ''},
    hook: {headers: {key: ''}, url: ''}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/orders/hook/config');

req.headers({
  'content-type': '',
  accept: ''
});

req.type('json');
req.send({
  filter: {
    disableSingleFire: false,
    expression: '',
    status: [],
    type: ''
  },
  hook: {
    headers: {
      key: ''
    },
    url: ''
  }
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/orders/hook/config',
  headers: {'content-type': '', accept: ''},
  data: {
    filter: {disableSingleFire: false, expression: '', status: [], type: ''},
    hook: {headers: {key: ''}, url: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/orders/hook/config';
const options = {
  method: 'POST',
  headers: {'content-type': '', accept: ''},
  body: '{"filter":{"disableSingleFire":false,"expression":"","status":[],"type":""},"hook":{"headers":{"key":""},"url":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };
NSDictionary *parameters = @{ @"filter": @{ @"disableSingleFire": @NO, @"expression": @"", @"status": @[  ], @"type": @"" },
                              @"hook": @{ @"headers": @{ @"key": @"" }, @"url": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/orders/hook/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/orders/hook/config" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/orders/hook/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'filter' => [
        'disableSingleFire' => null,
        'expression' => '',
        'status' => [
                
        ],
        'type' => ''
    ],
    'hook' => [
        'headers' => [
                'key' => ''
        ],
        'url' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/orders/hook/config', [
  'body' => '{
  "filter": {
    "disableSingleFire": false,
    "expression": "",
    "status": [],
    "type": ""
  },
  "hook": {
    "headers": {
      "key": ""
    },
    "url": ""
  }
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/orders/hook/config');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'filter' => [
    'disableSingleFire' => null,
    'expression' => '',
    'status' => [
        
    ],
    'type' => ''
  ],
  'hook' => [
    'headers' => [
        'key' => ''
    ],
    'url' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'filter' => [
    'disableSingleFire' => null,
    'expression' => '',
    'status' => [
        
    ],
    'type' => ''
  ],
  'hook' => [
    'headers' => [
        'key' => ''
    ],
    'url' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/api/orders/hook/config');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/orders/hook/config' -Method POST -Headers $headers -ContentType '' -Body '{
  "filter": {
    "disableSingleFire": false,
    "expression": "",
    "status": [],
    "type": ""
  },
  "hook": {
    "headers": {
      "key": ""
    },
    "url": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/orders/hook/config' -Method POST -Headers $headers -ContentType '' -Body '{
  "filter": {
    "disableSingleFire": false,
    "expression": "",
    "status": [],
    "type": ""
  },
  "hook": {
    "headers": {
      "key": ""
    },
    "url": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}"

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("POST", "/baseUrl/api/orders/hook/config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/orders/hook/config"

payload = {
    "filter": {
        "disableSingleFire": False,
        "expression": "",
        "status": [],
        "type": ""
    },
    "hook": {
        "headers": { "key": "" },
        "url": ""
    }
}
headers = {
    "content-type": "",
    "accept": ""
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/orders/hook/config"

payload <- "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/orders/hook/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = ''
request["accept"] = ''
request.body = "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/orders/hook/config') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"filter\": {\n    \"disableSingleFire\": false,\n    \"expression\": \"\",\n    \"status\": [],\n    \"type\": \"\"\n  },\n  \"hook\": {\n    \"headers\": {\n      \"key\": \"\"\n    },\n    \"url\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/orders/hook/config";

    let payload = json!({
        "filter": json!({
            "disableSingleFire": false,
            "expression": "",
            "status": (),
            "type": ""
        }),
        "hook": json!({
            "headers": json!({"key": ""}),
            "url": ""
        })
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/orders/hook/config \
  --header 'accept: ' \
  --header 'content-type: ' \
  --data '{
  "filter": {
    "disableSingleFire": false,
    "expression": "",
    "status": [],
    "type": ""
  },
  "hook": {
    "headers": {
      "key": ""
    },
    "url": ""
  }
}'

echo '{
  "filter": {
    "disableSingleFire": false,
    "expression": "",
    "status": [],
    "type": ""
  },
  "hook": {
    "headers": {
      "key": ""
    },
    "url": ""
  }
}' |  \
  http POST {{baseUrl}}/api/orders/hook/config \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --body-data '{\n  "filter": {\n    "disableSingleFire": false,\n    "expression": "",\n    "status": [],\n    "type": ""\n  },\n  "hook": {\n    "headers": {\n      "key": ""\n    },\n    "url": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/api/orders/hook/config

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]
let parameters = [
  "filter": [
    "disableSingleFire": false,
    "expression": "",
    "status": [],
    "type": ""
  ],
  "hook": [
    "headers": ["key": ""],
    "url": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/orders/hook/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "CurrentChange": "2019-08-14T17:12:48.0965893Z",
  "Domain": "Fulfillment",
  "LastChange": "2019-08-14T17:11:39.2550122Z",
  "LastState": "window-to-cancel",
  "OrderId": "v52277740atmc-01",
  "Origin": {
    "Account": "automacaoqa",
    "Key": "vtexappkey-appvtex"
  },
  "State": "ready-for-handling"
}

DELETE Delete hook configuration

{{baseUrl}}/api/orders/hook/config

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/orders/hook/config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/api/orders/hook/config" {:headers {:accept ""
                                                                               :content-type ""}})

require "http/client"

url = "{{baseUrl}}/api/orders/hook/config"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}

response = HTTP::Client.delete url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/api/orders/hook/config"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/orders/hook/config");
var request = new RestRequest("", Method.Delete);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/orders/hook/config"

	req, _ := http.NewRequest("DELETE", url, nil)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/api/orders/hook/config HTTP/1.1
Accept: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/api/orders/hook/config")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/orders/hook/config"))
    .header("accept", "")
    .header("content-type", "")
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/orders/hook/config")
  .delete(null)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/api/orders/hook/config")
  .header("accept", "")
  .header("content-type", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/api/orders/hook/config');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/orders/hook/config',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/orders/hook/config';
const options = {method: 'DELETE', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/orders/hook/config',
  method: 'DELETE',
  headers: {
    accept: '',
    'content-type': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/orders/hook/config")
  .delete(null)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/orders/hook/config',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/orders/hook/config',
  headers: {accept: '', 'content-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/api/orders/hook/config');

req.headers({
  accept: '',
  'content-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/api/orders/hook/config',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/orders/hook/config';
const options = {method: 'DELETE', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/orders/hook/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/orders/hook/config" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in

Client.call ~headers `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/orders/hook/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/api/orders/hook/config', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/orders/hook/config');
$request->setMethod(HTTP_METH_DELETE);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/orders/hook/config');
$request->setRequestMethod('DELETE');
$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/orders/hook/config' -Method DELETE -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/orders/hook/config' -Method DELETE -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("DELETE", "/baseUrl/api/orders/hook/config", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/orders/hook/config"

headers = {
    "accept": "",
    "content-type": ""
}

response = requests.delete(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/orders/hook/config"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/orders/hook/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)
request["accept"] = ''
request["content-type"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/api/orders/hook/config') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/orders/hook/config";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/api/orders/hook/config \
  --header 'accept: ' \
  --header 'content-type: '

http DELETE {{baseUrl}}/api/orders/hook/config \
  accept:'' \
  content-type:''

wget --quiet \
  --method DELETE \
  --header 'accept: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/api/orders/hook/config

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/orders/hook/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

GET Get hook configuration

{{baseUrl}}/api/orders/hook/config

HEADERS

Content-Type

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/orders/hook/config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/orders/hook/config" {:headers {:content-type ""
                                                                            :accept ""}})

require "http/client"

url = "{{baseUrl}}/api/orders/hook/config"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/orders/hook/config"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/orders/hook/config");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/orders/hook/config"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/orders/hook/config HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/orders/hook/config")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/orders/hook/config"))
    .header("content-type", "")
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/orders/hook/config")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/orders/hook/config")
  .header("content-type", "")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/orders/hook/config');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/orders/hook/config',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/orders/hook/config';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/orders/hook/config',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/orders/hook/config")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/orders/hook/config',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/orders/hook/config',
  headers: {'content-type': '', accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/orders/hook/config');

req.headers({
  'content-type': '',
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/orders/hook/config',
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/orders/hook/config';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/orders/hook/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/orders/hook/config" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/orders/hook/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/orders/hook/config', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/orders/hook/config');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/orders/hook/config');
$request->setRequestMethod('GET');
$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/orders/hook/config' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/orders/hook/config' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/orders/hook/config", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/orders/hook/config"

headers = {
    "content-type": "",
    "accept": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/orders/hook/config"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/orders/hook/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/orders/hook/config') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/orders/hook/config";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/orders/hook/config \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/orders/hook/config \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - {{baseUrl}}/api/orders/hook/config

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/orders/hook/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Add log in orders

{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions

HEADERS

Content-Type

QUERY PARAMS

orderId

BODY json

{
  "message": "",
  "source": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions" {:headers {:accept ""}
                                                                                     :content-type :json
                                                                                     :form-params {:message "Teste add interactions"
                                                                                                   :source "Postman"}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions"
headers = HTTP::Headers{
  "content-type" => "application/json"
  "accept" => ""
}
reqBody = "{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddHeader("accept", "");
request.AddParameter("application/json", "{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions"

	payload := strings.NewReader("{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/oms/pvt/orders/:orderId/interactions HTTP/1.1
Content-Type: application/json
Accept: 
Host: example.com
Content-Length: 64

{
  "message": "Teste add interactions",
  "source": "Postman"
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions")
  .setHeader("content-type", "application/json")
  .setHeader("accept", "")
  .setBody("{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions"))
    .header("content-type", "application/json")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions")
  .header("content-type", "application/json")
  .header("accept", "")
  .body("{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}")
  .asString();

const data = JSON.stringify({
  message: 'Teste add interactions',
  source: 'Postman'
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions');
xhr.setRequestHeader('content-type', 'application/json');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions',
  headers: {'content-type': 'application/json', accept: ''},
  data: {message: 'Teste add interactions', source: 'Postman'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json', accept: ''},
  body: '{"message":"Teste add interactions","source":"Postman"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions',
  method: 'POST',
  headers: {
    'content-type': 'application/json',
    accept: ''
  },
  processData: false,
  data: '{\n  "message": "Teste add interactions",\n  "source": "Postman"\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions")
  .post(body)
  .addHeader("content-type", "application/json")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId/interactions',
  headers: {
    'content-type': 'application/json',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({message: 'Teste add interactions', source: 'Postman'}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions',
  headers: {'content-type': 'application/json', accept: ''},
  body: {message: 'Teste add interactions', source: 'Postman'},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions');

req.headers({
  'content-type': 'application/json',
  accept: ''
});

req.type('json');
req.send({
  message: 'Teste add interactions',
  source: 'Postman'
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions',
  headers: {'content-type': 'application/json', accept: ''},
  data: {message: 'Teste add interactions', source: 'Postman'}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json', accept: ''},
  body: '{"message":"Teste add interactions","source":"Postman"}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json",
                           @"accept": @"" };
NSDictionary *parameters = @{ @"message": @"Teste add interactions",
                              @"source": @"Postman" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "application/json");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'message' => 'Teste add interactions',
    'source' => 'Postman'
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions', [
  'body' => '{
  "message": "Teste add interactions",
  "source": "Postman"
}',
  'headers' => [
    'accept' => '',
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json',
  'accept' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'message' => 'Teste add interactions',
  'source' => 'Postman'
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'message' => 'Teste add interactions',
  'source' => 'Postman'
]));
$request->setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "message": "Teste add interactions",
  "source": "Postman"
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "message": "Teste add interactions",
  "source": "Postman"
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}"

headers = {
    'content-type': "application/json",
    'accept': ""
}

conn.request("POST", "/baseUrl/api/oms/pvt/orders/:orderId/interactions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions"

payload = {
    "message": "Teste add interactions",
    "source": "Postman"
}
headers = {
    "content-type": "application/json",
    "accept": ""
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions"

payload <- "{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request["accept"] = ''
request.body = "{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/api/oms/pvt/orders/:orderId/interactions') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"message\": \"Teste add interactions\",\n  \"source\": \"Postman\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions";

    let payload = json!({
        "message": "Teste add interactions",
        "source": "Postman"
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId/interactions \
  --header 'accept: ' \
  --header 'content-type: application/json' \
  --data '{
  "message": "Teste add interactions",
  "source": "Postman"
}'

echo '{
  "message": "Teste add interactions",
  "source": "Postman"
}' |  \
  http POST {{baseUrl}}/api/oms/pvt/orders/:orderId/interactions \
  accept:'' \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --header 'accept: ' \
  --body-data '{\n  "message": "Teste add interactions",\n  "source": "Postman"\n}' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId/interactions

import Foundation

let headers = [
  "content-type": "application/json",
  "accept": ""
]
let parameters = [
  "message": "Teste add interactions",
  "source": "Postman"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId/interactions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST Cancel order

{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel

HEADERS

Content-Type

QUERY PARAMS

orderId

BODY json

{
  "reason": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"reason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel" {:headers {:accept ""}
                                                                               :content-type :json
                                                                               :form-params {:reason ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}
reqBody = "{\n  \"reason\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"reason\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
request.AddParameter("", "{\n  \"reason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel"

	payload := strings.NewReader("{\n  \"reason\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/oms/pvt/orders/:orderId/cancel HTTP/1.1
Accept: 
Content-Type: 
Host: example.com
Content-Length: 18

{
  "reason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .setBody("{\n  \"reason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel"))
    .header("accept", "")
    .header("content-type", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"reason\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"reason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel")
  .header("accept", "")
  .header("content-type", "")
  .body("{\n  \"reason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  reason: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel',
  headers: {accept: '', 'content-type': ''},
  data: {reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': ''
  },
  processData: false,
  data: '{\n  "reason": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"reason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel")
  .post(body)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId/cancel',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({reason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel',
  headers: {accept: '', 'content-type': ''},
  body: {reason: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel');

req.headers({
  accept: '',
  'content-type': ''
});

req.type('json');
req.send({
  reason: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel',
  headers: {accept: '', 'content-type': ''},
  data: {reason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel';
const options = {
  method: 'POST',
  headers: {accept: '', 'content-type': ''},
  body: '{"reason":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };
NSDictionary *parameters = @{ @"reason": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"reason\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'reason' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel', [
  'body' => '{
  "reason": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'reason' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'reason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel' -Method POST -Headers $headers -ContentType '' -Body '{
  "reason": ""
}'

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel' -Method POST -Headers $headers -ContentType '' -Body '{
  "reason": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"reason\": \"\"\n}"

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/api/oms/pvt/orders/:orderId/cancel", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel"

payload = { "reason": "" }
headers = {
    "accept": "",
    "content-type": ""
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel"

payload <- "{\n  \"reason\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = ''
request.body = "{\n  \"reason\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/oms/pvt/orders/:orderId/cancel') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"reason\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel";

    let payload = json!({"reason": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId/cancel \
  --header 'accept: ' \
  --header 'content-type: ' \
  --data '{
  "reason": ""
}'

echo '{
  "reason": ""
}' |  \
  http POST {{baseUrl}}/api/oms/pvt/orders/:orderId/cancel \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: ' \
  --body-data '{\n  "reason": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId/cancel

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]
let parameters = ["reason": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId/cancel")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "date": "2014-02-07T15:22:56.7612218-02:00",
  "orderId": "123543123",
  "receipt": "38e0e47da2934847b489216d208cfd91"
}

GET Get order

{{baseUrl}}/api/oms/pvt/orders/:orderId

HEADERS

Content-Type

QUERY PARAMS

orderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/oms/pvt/orders/:orderId" {:headers {:accept ""
                                                                                 :content-type ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/oms/pvt/orders/:orderId HTTP/1.1
Accept: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/oms/pvt/orders/:orderId")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId"))
    .header("accept", "")
    .header("content-type", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/oms/pvt/orders/:orderId")
  .header("accept", "")
  .header("content-type", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/oms/pvt/orders/:orderId');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId',
  method: 'GET',
  headers: {
    accept: '',
    'content-type': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId',
  headers: {accept: '', 'content-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/oms/pvt/orders/:orderId');

req.headers({
  accept: '',
  'content-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/oms/pvt/orders/:orderId', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("GET", "/baseUrl/api/oms/pvt/orders/:orderId", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId"

headers = {
    "accept": "",
    "content-type": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''
request["content-type"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/oms/pvt/orders/:orderId') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/oms/pvt/orders/:orderId \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "affiliateId": "",
  "allowCancellation": false,
  "allowEdition": false,
  "approvedBy": "Person's name",
  "authorizedDate": "2019-01-28T20:33:04+00:00",
  "callCenterOperatorData": null,
  "cancelReason": "Explanation for cancellation",
  "cancelledBy": "Person's name",
  "changesAttachment": {
    "changesData": [
      {
        "discountValue": 3290,
        "incrementValue": 0,
        "itemsAdded": [],
        "itemsRemoved": [
          {
            "id": "1234568358",
            "name": "Bay Max L",
            "price": 3290,
            "quantity": 1,
            "unitMultiplier": null
          }
        ],
        "reason": "Blah",
        "receipt": {
          "date": "2019-02-06T20:46:04.4003606+00:00",
          "orderId": "v5195004lux-01",
          "receipt": "029f9ab8-751a-4b1e-bf81-7dd25d14b49b"
        }
      }
    ],
    "id": "changeAttachment"
  },
  "clientProfileData": {
    "corporateDocument": null,
    "corporateName": null,
    "corporatePhone": null,
    "customerClass": null,
    "document": "11047867702",
    "documentType": "cpf",
    "email": "rodrigo.cunha@vtex.com.br",
    "firstName": "Rodrigo",
    "id": "clientProfileData",
    "isCorporate": false,
    "lastName": "VTEX",
    "phone": "+5521972321094",
    "stateInscription": null,
    "tradeName": null,
    "userProfileId": "5a3692de-358a-4bea-8885-044bce33bb93"
  },
  "commercialConditionData": null,
  "creationDate": "2019-01-28T20:09:43.899958+00:00",
  "customData": null,
  "emailTracked": "a27499cad31f42b7a771ae34f57c8358@ct.vtex.com.br",
  "followUpEmail": "7bf3a59bbc56402c810bda9521ba449e@ct.vtex.com.br",
  "giftRegistryData": null,
  "hostname": "luxstore",
  "invoiceData": null,
  "invoicedDate": null,
  "isCheckedIn": false,
  "isCompleted": true,
  "items": [
    {
      "additionalInfo": {
        "brandId": "2000023",
        "brandName": "VTEX",
        "categoriesIds": "/1/",
        "commercialConditionId": "5",
        "dimension": {
          "cubicweight": 0.7031,
          "height": 15,
          "length": 15,
          "weight": 15,
          "width": 15
        },
        "offeringInfo": "Fragile.",
        "offeringType": null,
        "offeringTypeId": null,
        "productClusterId": "135,142"
      },
      "assemblies": [],
      "attachmentOfferings": [
        {
          "name": "vtex.subscription.weekly",
          "required": false,
          "schema": {
            "vtex.subscription.key.frequency": {
              "Domain": [
                " 1 week",
                " 2 week",
                " 3 week",
                " 4 week"
              ],
              "MaximumNumberOfCharacters": 7
            }
          }
        }
      ],
      "attachments": [],
      "bundleItems": [],
      "callCenterOperator": "callCenterOp5473869",
      "commission": 0,
      "components": [],
      "costPrice": 52,
      "detailUrl": "/bay-max-9429485/p",
      "ean": null,
      "freightCommission": 0,
      "id": "1234568358",
      "imageUrl": "http://luxstore.vteximg.com.br/arquivos/ids/159263-55-55/image-cc1aed75cbfa424a85a94900be3eacec.jpg?v=636795432619830000",
      "isGift": false,
      "itemAttachment": {
        "content": {},
        "name": null
      },
      "listPrice": 3290,
      "lockId": "00-v5195004lux-01",
      "manualPrice": null,
      "measurementUnit": "un",
      "name": "Bay Max L",
      "offerings": [],
      "params": [],
      "parentAssemblyBinding": null,
      "parentItemIndex": null,
      "preSaleDate": null,
      "price": 3290,
      "priceDefinitions": {
        "calculatedSellingPrice": 99,
        "sellingPrices": [
          {
            "quantity": 1,
            "value": 99
          }
        ],
        "total": 99
      },
      "priceTags": [],
      "priceValidUntil": null,
      "productId": "9429485",
      "quantity": 1,
      "refId": "BIGHEROBML",
      "rewardValue": 0,
      "seller": "1",
      "sellerSku": "1234568358",
      "sellingPrice": 3290,
      "serialNumbers": "3",
      "shippingPrice": null,
      "tax": 0,
      "taxCode": null,
      "uniqueId": "87F0945396994B349158C7D9C9941442",
      "unitMultiplier": 1
    }
  ],
  "lastChange": "2019-02-06T20:46:11.7010747+00:00",
  "lastMessage": null,
  "marketingData": "marketing data",
  "marketplace": {
    "baseURL": "http://oms.vtexinternal.com.br/api/oms?an=luxstore",
    "isCertified": null,
    "name": "luxstore"
  },
  "marketplaceItems": [],
  "marketplaceOrderId": "",
  "marketplaceServicesEndpoint": "http://oms.vtexinternal.com.br/api/oms?an=luxstore",
  "merchantName": null,
  "openTextField": null,
  "orderFormId": "caae7471333e403f959fa5fd66951340",
  "orderGroup": null,
  "orderId": "v5195004lux-01",
  "origin": "Marketplace",
  "packageAttachment": {
    "packages": []
  },
  "paymentData": {
    "transactions": [
      {
        "isActive": true,
        "merchantName": "luxstore",
        "payments": [
          {
            "accountId": "5BC5C6B417FE432AB971B1D399F190C9",
            "bankIssuedInvoiceBarCodeNumber": "325349573975945245345439573421443986734065",
            "bankIssuedInvoiceBarCodeType": "i25",
            "bankIssuedInvoiceIdentificationNumber": "23797770100000019003099260100022107500729050",
            "bankIssuedInvoiceIdentificationNumberFormatted": "32534.95739 75945.24534 54395.734214 5",
            "billingAddress": {},
            "cardHolder": null,
            "cardNumber": null,
            "connectorResponses": {
              "Message": "logMessage",
              "ReturnCode": "200",
              "Tid": "94857956",
              "authId": "857956"
            },
            "cvv2": null,
            "dueDate": "2019-02-02",
            "expireMonth": null,
            "expireYear": null,
            "firstDigits": null,
            "giftCardAsDiscount": false,
            "giftCardCaption": null,
            "giftCardId": null,
            "giftCardName": null,
            "giftCardProvider": "presentCard",
            "group": "bankInvoice",
            "id": "D3DEECAB3C6C4B9EAF8EF4C1FE062FF3",
            "installments": 1,
            "koinUrl": "koinURL",
            "lastDigits": null,
            "parentAccountId": "5BC5C6B417FE432AB971B1D399F190C9",
            "paymentSystem": "6",
            "paymentSystemName": "Boleto Bancário",
            "redemptionCode": null,
            "referenceValue": 4450,
            "tid": null,
            "url": "https://luxstore.vtexpayments.com.br:443/BankIssuedInvoice/Transaction/418213DE29634837A63DD693A937A696/Payment/D3DEECAB3C6C4B9EAF8EF4C1FE062FF3/Installment/{Installment}",
            "value": 4450
          }
        ],
        "transactionId": "418213DE29634837A63DD693A937A696"
      }
    ]
  },
  "ratesAndBenefitsData": {
    "id": "ratesAndBenefitsData",
    "rateAndBenefitsIdentifiers": []
  },
  "roundingError": 0,
  "salesChannel": "1",
  "sellerOrderId": "00-v5195004lux-01",
  "sellers": [
    {
      "fulfillmentEndpoint": "http://fulfillment.vtexcommerce.com.br/api/fulfillment?an=accountName",
      "id": "1",
      "logo": "https://sellersLogo/images.png",
      "name": "Loja do Suporte"
    }
  ],
  "sequence": "502556",
  "shippingData": {
    "address": {
      "addressId": "-1425945657910",
      "addressType": "residential",
      "city": "Rio de Janeiro",
      "complement": "3",
      "country": "BRA",
      "entityId": "eabfb564-99d6-40d8-bd6c-bddbd4990aad",
      "geoCoordinates": [],
      "neighborhood": "Botafogo",
      "number": "300",
      "postalCode": "22250-040",
      "receiverName": "Rodrigo Cunha",
      "reference": null,
      "state": "RJ",
      "street": "Praia de Botafogo",
      "versionId": "e9c3bec2-125d-4b96-a021-316c3aa9f14f"
    },
    "id": "shippingData",
    "logisticsInfo": [
      {
        "addressId": "-1425945657910",
        "deliveryChannel": "delivery",
        "deliveryChannels": [
          {
            "id": "delivery",
            "stockBalance": 0
          }
        ],
        "deliveryCompany": "Todos os CEPS",
        "deliveryIds": [
          {
            "accountCarrierName": "recorrenciaqa",
            "courierId": "197a56f",
            "courierName": "Todos os CEPS",
            "dockId": "1",
            "kitItemDetails": [],
            "quantity": 1,
            "warehouseId": "1_1"
          }
        ],
        "deliveryWindow": null,
        "entityId": "eabfb564-99d6-40d8-bd6c-bddbd4990aad",
        "itemIndex": 0,
        "listPrice": 1160,
        "lockTTL": "10d",
        "pickupPointId": "1_VTEX-RJ",
        "pickupStoreInfo": {
          "additionalInfo": null,
          "address": null,
          "dockId": null,
          "friendlyName": null,
          "isPickupStore": false
        },
        "polygonName": "region196",
        "price": 1160,
        "selectedSla": "Normal",
        "sellingPrice": 1160,
        "shippingEstimate": "5bd",
        "shippingEstimateDate": "2019-02-04T20:33:46.4595004+00:00",
        "shipsTo": [
          "BRA"
        ],
        "slas": [
          {
            "deliveryChannel": "delivery",
            "deliveryWindow": null,
            "id": "Normal",
            "lockTTL": "12d",
            "name": "Normal",
            "pickupDistance": 0,
            "pickupPointId": "store34",
            "pickupStoreInfo": {
              "additionalInfo": null,
              "address": null,
              "dockId": null,
              "friendlyName": null,
              "isPickupStore": false
            },
            "polygonName": null,
            "price": 1160,
            "shippingEstimate": "5bd",
            "transitTime": "3d"
          },
          {
            "deliveryChannel": "delivery",
            "deliveryWindow": null,
            "id": "Expressa",
            "lockTTL": "12d",
            "name": "Expressa",
            "pickupDistance": 0,
            "pickupPointId": "1_VTEX-RJ",
            "pickupStoreInfo": {
              "additionalInfo": null,
              "address": null,
              "dockId": null,
              "friendlyName": null,
              "isPickupStore": false
            },
            "polygonName": null,
            "price": 1160,
            "shippingEstimate": "5bd",
            "transitTime": "3d"
          },
          {
            "deliveryChannel": "delivery",
            "deliveryWindow": null,
            "id": "Quebra Kit",
            "lockTTL": "12d",
            "name": "Quebra Kit",
            "pickupDistance": 0,
            "pickupPointId": "1_VTEX-RJ",
            "pickupStoreInfo": {
              "additionalInfo": null,
              "address": null,
              "dockId": null,
              "friendlyName": null,
              "isPickupStore": false
            },
            "polygonName": null,
            "price": 1392,
            "shippingEstimate": "2bd",
            "transitTime": "3d"
          },
          {
            "deliveryChannel": "delivery",
            "deliveryWindow": null,
            "id": "Sob Encomenda",
            "lockTTL": "12d",
            "name": "Sob Encomenda",
            "pickupDistance": 0,
            "pickupPointId": "1_VTEX-RJ",
            "pickupStoreInfo": {
              "additionalInfo": null,
              "address": null,
              "dockId": null,
              "friendlyName": null,
              "isPickupStore": false
            },
            "polygonName": null,
            "price": 1392,
            "shippingEstimate": "32bd",
            "transitTime": "3d"
          }
        ],
        "transitTime": "3d",
        "versionId": "e9c3bec2-125d-4b96-a021-316c3aa9f14f"
      }
    ],
    "selectedAddresses": [
      {
        "addressId": "-1425945657910",
        "addressType": "residential",
        "city": "Rio de Janeiro",
        "complement": "10",
        "country": "BRA",
        "entityId": "eabfb564-99d6-40d8-bd6c-bddbd4990aad",
        "geoCoordinates": [],
        "neighborhood": "Botafogo",
        "number": "518",
        "postalCode": "22250-040",
        "receiverName": "Rodrigo Cunha",
        "reference": null,
        "state": "RJ",
        "street": "Praia de Botafogo",
        "versionId": "e9c3bec2-125d-4b96-a021-316c3aa9f14f"
      }
    ],
    "trackingHints": null
  },
  "status": "handling",
  "statusDescription": "Preparando Entrega",
  "storePreferencesData": {
    "countryCode": "BRA",
    "currencyCode": "BRL",
    "currencyFormatInfo": {
      "CurrencyDecimalDigits": 2,
      "CurrencyDecimalSeparator": ",",
      "CurrencyGroupSeparator": ".",
      "CurrencyGroupSize": 3,
      "StartsWithCurrencySymbol": true
    },
    "currencyLocale": 1046,
    "currencySymbol": "R$",
    "timeZone": "E. South America Standard Time"
  },
  "totals": [
    {
      "id": "Items",
      "name": "Total dos Itens",
      "value": 3290
    },
    {
      "id": "Discounts",
      "name": "Total dos Descontos",
      "value": 0
    },
    {
      "id": "Shipping",
      "name": "Total do Frete",
      "value": 1160
    },
    {
      "id": "Tax",
      "name": "Total da Taxa",
      "value": 0
    },
    {
      "id": "Change",
      "name": "Total das mudanças",
      "value": -3290
    }
  ],
  "value": 1160
}

GET List orders

{{baseUrl}}/api/oms/pvt/orders

HEADERS

Content-Type

QUERY PARAMS

f_creationDate

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders?f_creationDate=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/oms/pvt/orders" {:headers {:accept ""
                                                                        :content-type ""}
                                                              :query-params {:f_creationDate ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders?f_creationDate="
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders?f_creationDate="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders?f_creationDate=");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders?f_creationDate="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/oms/pvt/orders?f_creationDate= HTTP/1.1
Accept: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/oms/pvt/orders?f_creationDate=")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders?f_creationDate="))
    .header("accept", "")
    .header("content-type", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders?f_creationDate=")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/oms/pvt/orders?f_creationDate=")
  .header("accept", "")
  .header("content-type", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/oms/pvt/orders?f_creationDate=');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders',
  params: {f_creationDate: ''},
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders?f_creationDate=';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders?f_creationDate=',
  method: 'GET',
  headers: {
    accept: '',
    'content-type': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders?f_creationDate=")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders?f_creationDate=',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders',
  qs: {f_creationDate: ''},
  headers: {accept: '', 'content-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/oms/pvt/orders');

req.query({
  f_creationDate: ''
});

req.headers({
  accept: '',
  'content-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders',
  params: {f_creationDate: ''},
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders?f_creationDate=';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders?f_creationDate="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders?f_creationDate=" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders?f_creationDate=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/oms/pvt/orders?f_creationDate=', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'f_creationDate' => ''
]);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/pvt/orders');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'f_creationDate' => ''
]));

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders?f_creationDate=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders?f_creationDate=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("GET", "/baseUrl/api/oms/pvt/orders?f_creationDate=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders"

querystring = {"f_creationDate":""}

headers = {
    "accept": "",
    "content-type": ""
}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders"

queryString <- list(f_creationDate = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders?f_creationDate=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''
request["content-type"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/oms/pvt/orders') do |req|
  req.headers['accept'] = ''
  req.params['f_creationDate'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders";

    let querystring = [
        ("f_creationDate", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/oms/pvt/orders?f_creationDate=' \
  --header 'accept: ' \
  --header 'content-type: '

http GET '{{baseUrl}}/api/oms/pvt/orders?f_creationDate=' \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --header 'content-type: ' \
  --output-document \
  - '{{baseUrl}}/api/oms/pvt/orders?f_creationDate='

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders?f_creationDate=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json; charset=utf-8

RESPONSE BODY json

{
  "facets": [],
  "list": [
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": "2019-02-07T21:29:54+00:00",
      "callCenterOperatorName": null,
      "clientName": "J C",
      "creationDate": "2019-02-04T10:29:11+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": " Lux Store 96 Sua Nota Fiscal foi emitida. Referente ao Pedido #v502559llux-01 Olá, J. Estamos empacotando seu produto para providenci",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": null,
      "orderId": "1306331686122-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": "Boleto Bancário",
      "salesChannel": "1",
      "sequence": "502559",
      "status": "invoiced",
      "statusDescription": "Faturado",
      "totalItems": 1,
      "totalValue": 7453,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2019-02-04T20:33:46+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": "2019-01-28T20:33:04+00:00",
      "callCenterOperatorName": null,
      "clientName": "Rodrigo VTEX",
      "creationDate": "2019-01-28T20:09:43+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": " Lux Store Seu pedido foi alterado! Pedido realizado em: 28/01/2019 Olá, Rodrigo. Seu pedido foi alterado. Seguem informações abaixo: ",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": null,
      "orderId": "v502556llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": "Boleto Bancário",
      "salesChannel": "1",
      "sequence": "502556",
      "status": "handling",
      "statusDescription": "Preparando Entrega",
      "totalItems": 1,
      "totalValue": 1160,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2019-01-31T12:36:30+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": "2019-01-24T12:36:01+00:00",
      "callCenterOperatorName": null,
      "clientName": "test test",
      "creationDate": "2019-01-24T12:35:19+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": " Lux Store 96 Sua Nota Fiscal foi emitida. Referente ao Pedido #v502553llux-01 Olá, test. Estamos empacotando seu produto para provide",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": null,
      "orderId": "v502553llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": "Mastercard",
      "salesChannel": "1",
      "sequence": "502554",
      "status": "ready-for-handling",
      "statusDescription": "Pronto para o manuseio",
      "totalItems": 1,
      "totalValue": 10150,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2019-01-30T16:40:55+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": "2019-01-23T16:40:27+00:00",
      "callCenterOperatorName": null,
      "clientName": "test test",
      "creationDate": "2019-01-23T16:39:45+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": " Lux Store 96 Seu pagamento foi aprovado. Referente ao Pedido #v502550llux-01 Olá, test. Estamos providenciando a emissão da Nota Fisc",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": null,
      "orderId": "v502550llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": "Mastercard",
      "salesChannel": "1",
      "sequence": "502551",
      "status": "ready-for-handling",
      "statusDescription": "Pronto para o manuseio",
      "totalItems": 1,
      "totalValue": 10150,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2019-01-30T16:35:30+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": "2019-01-23T16:35:04+00:00",
      "callCenterOperatorName": null,
      "clientName": "test test",
      "creationDate": "2019-01-23T16:34:20+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": " Lux Store 96 Seu pagamento foi aprovado. Referente ao Pedido #v502547llux-01 Olá, test. Estamos providenciando a emissão da Nota Fisc",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": null,
      "orderId": "v502547llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": "Mastercard",
      "salesChannel": "1",
      "sequence": "502548",
      "status": "ready-for-handling",
      "statusDescription": "Pronto para o manuseio",
      "totalItems": 1,
      "totalValue": 10150,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "test test",
      "creationDate": "2018-12-28T18:15:28+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": " Lux Store 96 Seu pedido foi cancelado. Referente ao Pedido #v502544llux-01 Resumo Itens R$ 89,90 Total R$ 89,90 Produto Alavanca De M",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": null,
      "orderId": "v502544llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": "Boleto Bancário",
      "salesChannel": "1",
      "sequence": "502544",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 1,
      "totalValue": 8990,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "Douglas Rodrigues",
      "creationDate": "2018-12-18T18:48:17+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": " Lux Store 96 Seu pedido foi cancelado. Referente ao Pedido #v502541llux-01 Resumo Itens R$ 32,90 Total R$ 32,90 Produto Bay Max L 1 u",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": null,
      "orderId": "v502541llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": "Boleto Bancário",
      "salesChannel": "1",
      "sequence": "502541",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 1,
      "totalValue": 3290,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2018-12-19T18:22:26+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": "2018-12-12T18:22:22+00:00",
      "callCenterOperatorName": null,
      "clientName": "test test",
      "creationDate": "2018-12-12T18:21:47+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": " Lux Store 96 Seu pagamento foi aprovado. Referente ao Pedido #v502538llux-01 Olá, test. Estamos providenciando a emissão da Nota Fisc",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": null,
      "orderId": "v502538llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": "Mastercard",
      "salesChannel": "1",
      "sequence": "502538",
      "status": "ready-for-handling",
      "statusDescription": "Pronto para o manuseio",
      "totalItems": 1,
      "totalValue": 8990,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "SCP",
      "authorizedDate": "2018-11-30T17:34:42+00:00",
      "callCenterOperatorName": null,
      "clientName": "roberta grecco",
      "creationDate": "2018-11-30T17:34:01+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": "cancelamento teste shp ",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "880102018018-01",
      "orderId": "SCP-880102018018-01",
      "orderIsComplete": true,
      "origin": "Fulfillment",
      "paymentNames": "",
      "salesChannel": "1",
      "sequence": "502537",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 1,
      "totalValue": 1250,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "SCP",
      "authorizedDate": "2018-11-30T17:29:22+00:00",
      "callCenterOperatorName": null,
      "clientName": "roberta grecco",
      "creationDate": "2018-11-30T17:28:35+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "880091692043-01",
      "orderId": "SCP-880091692043-01",
      "orderIsComplete": true,
      "origin": "Fulfillment",
      "paymentNames": "",
      "salesChannel": "1",
      "sequence": "502536",
      "status": "invoiced",
      "statusDescription": "Faturado",
      "totalItems": 1,
      "totalValue": 1250,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "SCP",
      "authorizedDate": "2018-11-30T17:18:44+00:00",
      "callCenterOperatorName": null,
      "clientName": "roberta grecco",
      "creationDate": "2018-11-30T17:18:00+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": "Teste de cancelamento do ShopFácil ",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "880091058221-01",
      "orderId": "SCP-880091058221-01",
      "orderIsComplete": true,
      "origin": "Fulfillment",
      "paymentNames": "",
      "salesChannel": "1",
      "sequence": "502535",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 1,
      "totalValue": 1250,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2018-12-07T17:11:39+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "SCP",
      "authorizedDate": "2018-11-30T17:11:42+00:00",
      "callCenterOperatorName": null,
      "clientName": "roberta grecco",
      "creationDate": "2018-11-30T17:10:59+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "880090643370-01",
      "orderId": "SCP-880090643370-01",
      "orderIsComplete": true,
      "origin": "Fulfillment",
      "paymentNames": "",
      "salesChannel": "1",
      "sequence": "502534",
      "status": "ready-for-handling",
      "statusDescription": "Pronto para o manuseio",
      "totalItems": 1,
      "totalValue": 1250,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "SCP",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "roberta grecco",
      "creationDate": "2018-11-30T17:10:45+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "880090622238-01",
      "orderId": "SCP-880090622238-01",
      "orderIsComplete": true,
      "origin": "Fulfillment",
      "paymentNames": "",
      "salesChannel": "1",
      "sequence": "502533",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 1,
      "totalValue": 1250,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "MNC",
      "authorizedDate": "2018-11-20T21:13:06+00:00",
      "callCenterOperatorName": null,
      "clientName": "Carlos VTEX",
      "creationDate": "2018-11-20T21:09:01+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "877730530419-01",
      "orderId": "MNC-877730530419-01",
      "orderIsComplete": true,
      "origin": "Fulfillment",
      "paymentNames": "",
      "salesChannel": "1",
      "sequence": "502532",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 1,
      "totalValue": 11150,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2018-11-23T16:58:48+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "SCP",
      "authorizedDate": "2018-11-16T16:58:53+00:00",
      "callCenterOperatorName": null,
      "clientName": "roberta grecco",
      "creationDate": "2018-11-16T16:58:18+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "876733475998-01",
      "orderId": "SCP-876733475998-01",
      "orderIsComplete": true,
      "origin": "Fulfillment",
      "paymentNames": "",
      "salesChannel": "1",
      "sequence": "502531",
      "status": "ready-for-handling",
      "statusDescription": "Pronto para o manuseio",
      "totalItems": 1,
      "totalValue": 1250,
      "workflowInErrorState": false,
      "workflowInRetry": false
    }
  ],
  "paging": {
    "currentPage": 1,
    "pages": 6,
    "perPage": 15,
    "total": 84
  },
  "stats": {
    "stats": {
      "totalItems": {
        "Count": 84,
        "Facets": {
          "currencyCode": {
            "BRL": {
              "Count": 84,
              "Facets": null,
              "Max": 89,
              "Mean": 2.2261904761904763,
              "Min": 1,
              "Missing": 0,
              "StdDev": 9.660940100525016,
              "Sum": 187,
              "SumOfSquares": 8163
            }
          },
          "origin": {
            "Fulfillment": {
              "Count": 68,
              "Facets": null,
              "Max": 1,
              "Mean": 1,
              "Min": 1,
              "Missing": 0,
              "StdDev": 0,
              "Sum": 68,
              "SumOfSquares": 68
            },
            "Marketplace": {
              "Count": 16,
              "Facets": null,
              "Max": 89,
              "Mean": 7.4375,
              "Min": 1,
              "Missing": 0,
              "StdDev": 21.92401651157926,
              "Sum": 119,
              "SumOfSquares": 8095
            }
          }
        },
        "Max": 89,
        "Mean": 2.2261904761904763,
        "Min": 1,
        "Missing": 0,
        "StdDev": 9.660940100525016,
        "Sum": 187,
        "SumOfSquares": 8163
      },
      "totalValue": {
        "Count": 84,
        "Facets": {
          "currencyCode": {
            "BRL": {
              "Count": 84,
              "Facets": null,
              "Max": 21526180,
              "Mean": 262672.75,
              "Min": 1160,
              "Missing": 0,
              "StdDev": 2348087.3869179883,
              "Sum": 22064511,
              "SumOfSquares": 463417439039853
            }
          },
          "origin": {
            "Fulfillment": {
              "Count": 68,
              "Facets": null,
              "Max": 11150,
              "Mean": 1395.5882352941176,
              "Min": 1250,
              "Missing": 0,
              "StdDev": 1200.5513439298484,
              "Sum": 94900,
              "SumOfSquares": 229010000
            },
            "Marketplace": {
              "Count": 16,
              "Facets": null,
              "Max": 21526180,
              "Mean": 1373100.6875,
              "Min": 1160,
              "Missing": 0,
              "StdDev": 5374326.141087491,
              "Sum": 21969611,
              "SumOfSquares": 463417210029853
            }
          }
        },
        "Max": 21526180,
        "Mean": 262672.75,
        "Min": 1160,
        "Missing": 0,
        "StdDev": 2348087.3869179883,
        "Sum": 22064511,
        "SumOfSquares": 463417439039853
      }
    }
  }
}

POST Register change on order

{{baseUrl}}/api/oms/pvt/orders/:orderId/changes

HEADERS

Content-Type

QUERY PARAMS

orderId

BODY json

{
  "discountValue": 0,
  "incrementValue": 0,
  "itemsAdded": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "itemsRemoved": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "reason": "",
  "requestId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes" {:headers {:accept ""}
                                                                                :content-type :json
                                                                                :form-params {:discountValue 0
                                                                                              :incrementValue 0
                                                                                              :itemsAdded [{:id ""
                                                                                                            :price 0
                                                                                                            :quantity 0}]
                                                                                              :itemsRemoved [{:id ""
                                                                                                              :price 0
                                                                                                              :quantity 0}]
                                                                                              :reason ""
                                                                                              :requestId ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}
reqBody = "{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId/changes"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId/changes");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
request.AddParameter("", "{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes"

	payload := strings.NewReader("{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/oms/pvt/orders/:orderId/changes HTTP/1.1
Content-Type: 
Accept: 
Host: example.com
Content-Length: 262

{
  "discountValue": 0,
  "incrementValue": 0,
  "itemsAdded": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "itemsRemoved": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "reason": "",
  "requestId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .setBody("{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId/changes"))
    .header("content-type", "")
    .header("accept", "")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/changes")
  .post(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/oms/pvt/orders/:orderId/changes")
  .header("content-type", "")
  .header("accept", "")
  .body("{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  discountValue: 0,
  incrementValue: 0,
  itemsAdded: [
    {
      id: '',
      price: 0,
      quantity: 0
    }
  ],
  itemsRemoved: [
    {
      id: '',
      price: 0,
      quantity: 0
    }
  ],
  reason: '',
  requestId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes',
  headers: {'content-type': '', accept: ''},
  data: {
    discountValue: 0,
    incrementValue: 0,
    itemsAdded: [{id: '', price: 0, quantity: 0}],
    itemsRemoved: [{id: '', price: 0, quantity: 0}],
    reason: '',
    requestId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes';
const options = {
  method: 'POST',
  headers: {'content-type': '', accept: ''},
  body: '{"discountValue":0,"incrementValue":0,"itemsAdded":[{"id":"","price":0,"quantity":0}],"itemsRemoved":[{"id":"","price":0,"quantity":0}],"reason":"","requestId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes',
  method: 'POST',
  headers: {
    'content-type': '',
    accept: ''
  },
  processData: false,
  data: '{\n  "discountValue": 0,\n  "incrementValue": 0,\n  "itemsAdded": [\n    {\n      "id": "",\n      "price": 0,\n      "quantity": 0\n    }\n  ],\n  "itemsRemoved": [\n    {\n      "id": "",\n      "price": 0,\n      "quantity": 0\n    }\n  ],\n  "reason": "",\n  "requestId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/changes")
  .post(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId/changes',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  discountValue: 0,
  incrementValue: 0,
  itemsAdded: [{id: '', price: 0, quantity: 0}],
  itemsRemoved: [{id: '', price: 0, quantity: 0}],
  reason: '',
  requestId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes',
  headers: {'content-type': '', accept: ''},
  body: {
    discountValue: 0,
    incrementValue: 0,
    itemsAdded: [{id: '', price: 0, quantity: 0}],
    itemsRemoved: [{id: '', price: 0, quantity: 0}],
    reason: '',
    requestId: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes');

req.headers({
  'content-type': '',
  accept: ''
});

req.type('json');
req.send({
  discountValue: 0,
  incrementValue: 0,
  itemsAdded: [
    {
      id: '',
      price: 0,
      quantity: 0
    }
  ],
  itemsRemoved: [
    {
      id: '',
      price: 0,
      quantity: 0
    }
  ],
  reason: '',
  requestId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes',
  headers: {'content-type': '', accept: ''},
  data: {
    discountValue: 0,
    incrementValue: 0,
    itemsAdded: [{id: '', price: 0, quantity: 0}],
    itemsRemoved: [{id: '', price: 0, quantity: 0}],
    reason: '',
    requestId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes';
const options = {
  method: 'POST',
  headers: {'content-type': '', accept: ''},
  body: '{"discountValue":0,"incrementValue":0,"itemsAdded":[{"id":"","price":0,"quantity":0}],"itemsRemoved":[{"id":"","price":0,"quantity":0}],"reason":"","requestId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };
NSDictionary *parameters = @{ @"discountValue": @0,
                              @"incrementValue": @0,
                              @"itemsAdded": @[ @{ @"id": @"", @"price": @0, @"quantity": @0 } ],
                              @"itemsRemoved": @[ @{ @"id": @"", @"price": @0, @"quantity": @0 } ],
                              @"reason": @"",
                              @"requestId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId/changes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'discountValue' => 0,
    'incrementValue' => 0,
    'itemsAdded' => [
        [
                'id' => '',
                'price' => 0,
                'quantity' => 0
        ]
    ],
    'itemsRemoved' => [
        [
                'id' => '',
                'price' => 0,
                'quantity' => 0
        ]
    ],
    'reason' => '',
    'requestId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes', [
  'body' => '{
  "discountValue": 0,
  "incrementValue": 0,
  "itemsAdded": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "itemsRemoved": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "reason": "",
  "requestId": ""
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/changes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'discountValue' => 0,
  'incrementValue' => 0,
  'itemsAdded' => [
    [
        'id' => '',
        'price' => 0,
        'quantity' => 0
    ]
  ],
  'itemsRemoved' => [
    [
        'id' => '',
        'price' => 0,
        'quantity' => 0
    ]
  ],
  'reason' => '',
  'requestId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'discountValue' => 0,
  'incrementValue' => 0,
  'itemsAdded' => [
    [
        'id' => '',
        'price' => 0,
        'quantity' => 0
    ]
  ],
  'itemsRemoved' => [
    [
        'id' => '',
        'price' => 0,
        'quantity' => 0
    ]
  ],
  'reason' => '',
  'requestId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/changes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes' -Method POST -Headers $headers -ContentType '' -Body '{
  "discountValue": 0,
  "incrementValue": 0,
  "itemsAdded": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "itemsRemoved": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "reason": "",
  "requestId": ""
}'

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/changes' -Method POST -Headers $headers -ContentType '' -Body '{
  "discountValue": 0,
  "incrementValue": 0,
  "itemsAdded": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "itemsRemoved": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "reason": "",
  "requestId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}"

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("POST", "/baseUrl/api/oms/pvt/orders/:orderId/changes", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes"

payload = {
    "discountValue": 0,
    "incrementValue": 0,
    "itemsAdded": [
        {
            "id": "",
            "price": 0,
            "quantity": 0
        }
    ],
    "itemsRemoved": [
        {
            "id": "",
            "price": 0,
            "quantity": 0
        }
    ],
    "reason": "",
    "requestId": ""
}
headers = {
    "content-type": "",
    "accept": ""
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes"

payload <- "{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId/changes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = ''
request["accept"] = ''
request.body = "{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/oms/pvt/orders/:orderId/changes') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"discountValue\": 0,\n  \"incrementValue\": 0,\n  \"itemsAdded\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"itemsRemoved\": [\n    {\n      \"id\": \"\",\n      \"price\": 0,\n      \"quantity\": 0\n    }\n  ],\n  \"reason\": \"\",\n  \"requestId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes";

    let payload = json!({
        "discountValue": 0,
        "incrementValue": 0,
        "itemsAdded": (
            json!({
                "id": "",
                "price": 0,
                "quantity": 0
            })
        ),
        "itemsRemoved": (
            json!({
                "id": "",
                "price": 0,
                "quantity": 0
            })
        ),
        "reason": "",
        "requestId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId/changes \
  --header 'accept: ' \
  --header 'content-type: ' \
  --data '{
  "discountValue": 0,
  "incrementValue": 0,
  "itemsAdded": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "itemsRemoved": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "reason": "",
  "requestId": ""
}'

echo '{
  "discountValue": 0,
  "incrementValue": 0,
  "itemsAdded": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "itemsRemoved": [
    {
      "id": "",
      "price": 0,
      "quantity": 0
    }
  ],
  "reason": "",
  "requestId": ""
}' |  \
  http POST {{baseUrl}}/api/oms/pvt/orders/:orderId/changes \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'content-type: ' \
  --header 'accept: ' \
  --body-data '{\n  "discountValue": 0,\n  "incrementValue": 0,\n  "itemsAdded": [\n    {\n      "id": "",\n      "price": 0,\n      "quantity": 0\n    }\n  ],\n  "itemsRemoved": [\n    {\n      "id": "",\n      "price": 0,\n      "quantity": 0\n    }\n  ],\n  "reason": "",\n  "requestId": ""\n}' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId/changes

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]
let parameters = [
  "discountValue": 0,
  "incrementValue": 0,
  "itemsAdded": [
    [
      "id": "",
      "price": 0,
      "quantity": 0
    ]
  ],
  "itemsRemoved": [
    [
      "id": "",
      "price": 0,
      "quantity": 0
    ]
  ],
  "reason": "",
  "requestId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId/changes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "date": "2019-02-08T13:54:33.6868469+00:00",
  "orderId": "v502538llux-01",
  "receipt": "535d4581-a2a2-4fd2-a206-1c61eae91b1e"
}

POST Start handling order

{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling

HEADERS

Content-Type

QUERY PARAMS

orderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling" {:headers {:accept ""
                                                                                                 :content-type ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/oms/pvt/orders/:orderId/start-handling HTTP/1.1
Accept: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling"))
    .header("accept", "")
    .header("content-type", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling")
  .post(null)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling")
  .header("accept", "")
  .header("content-type", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling';
const options = {method: 'POST', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling")
  .post(null)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId/start-handling',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling',
  headers: {accept: '', 'content-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling');

req.headers({
  accept: '',
  'content-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling';
const options = {method: 'POST', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling');
$request->setRequestMethod('POST');
$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling' -Method POST -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/api/oms/pvt/orders/:orderId/start-handling", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling"

headers = {
    "accept": "",
    "content-type": ""
}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/oms/pvt/orders/:orderId/start-handling') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId/start-handling")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "error": {
    "code": "1",
    "exception": null,
    "message": "Acesso não autorizado"
  }
}

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "error": {
    "code": "OMS003",
    "exception": null,
    "message": "Order status should be ready-for-handling to perform this action"
  }
}

GET Retrieve payment transaction

{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction

HEADERS

Content-Type

QUERY PARAMS

orderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction" {:headers {:accept ""
                                                                                                     :content-type ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction");
var request = new RestRequest("", Method.Get);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/oms/pvt/orders/:orderId/payment-transaction HTTP/1.1
Accept: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction"))
    .header("accept", "")
    .header("content-type", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction")
  .header("accept", "")
  .header("content-type", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction',
  method: 'GET',
  headers: {
    accept: '',
    'content-type': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction")
  .get()
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId/payment-transaction',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction',
  headers: {accept: '', 'content-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction');

req.headers({
  accept: '',
  'content-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction';
const options = {method: 'GET', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction');
$request->setMethod(HTTP_METH_GET);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction');
$request->setRequestMethod('GET');
$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction' -Method GET -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("GET", "/baseUrl/api/oms/pvt/orders/:orderId/payment-transaction", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction"

headers = {
    "accept": "",
    "content-type": ""
}

response = requests.get(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["accept"] = ''
request["content-type"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/oms/pvt/orders/:orderId/payment-transaction') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction \
  --header 'accept: ' \
  --header 'content-type: '

http GET {{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'accept: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId/payment-transaction")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "isActive": true,
  "merchantName": "LUXSTORE",
  "payments": [
    {
      "cardHolder": null,
      "cardNumber": null,
      "connectorResponses": {
        "Message": "logMessage",
        "ReturnCode": "200",
        "Tid": "101770752",
        "authId": "170852"
      },
      "cvv2": null,
      "dueDate": null,
      "expireMonth": null,
      "expireYear": null,
      "firstDigits": "412341",
      "giftCardCaption": null,
      "giftCardId": null,
      "giftCardName": null,
      "group": "creditCard",
      "id": "721CBE1090324D12ABE301FE33DE775A",
      "installments": 1,
      "lastDigits": "4123",
      "paymentSystem": "4",
      "paymentSystemName": "Mastercard",
      "redemptionCode": null,
      "referenceValue": 10150,
      "tid": "101770752",
      "url": null,
      "value": 10150
    }
  ],
  "status": "Finished",
  "transactionId": "CB452D77E7D04099A4DB0479087B1D2C"
}

POST Send payment notification

{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification

HEADERS

Content-Type

QUERY PARAMS

orderId

paymentId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "accept: ");
headers = curl_slist_append(headers, "content-type: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification" {:headers {:accept ""
                                                                                                                           :content-type ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification"
headers = HTTP::Headers{
  "accept" => ""
  "content-type" => ""
}

response = HTTP::Client.post url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification"),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification");
var request = new RestRequest("", Method.Post);
request.AddHeader("accept", "");
request.AddHeader("content-type", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification"

	req, _ := http.NewRequest("POST", url, nil)

	req.Header.Add("accept", "")
	req.Header.Add("content-type", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification HTTP/1.1
Accept: 
Content-Type: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification")
  .setHeader("accept", "")
  .setHeader("content-type", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification"))
    .header("accept", "")
    .header("content-type", "")
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification")
  .post(null)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification")
  .header("accept", "")
  .header("content-type", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification');
xhr.setRequestHeader('accept', '');
xhr.setRequestHeader('content-type', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification';
const options = {method: 'POST', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification',
  method: 'POST',
  headers: {
    accept: '',
    'content-type': ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification")
  .post(null)
  .addHeader("accept", "")
  .addHeader("content-type", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification',
  headers: {
    accept: '',
    'content-type': ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification',
  headers: {accept: '', 'content-type': ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification');

req.headers({
  accept: '',
  'content-type': ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification',
  headers: {accept: '', 'content-type': ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification';
const options = {method: 'POST', headers: {accept: '', 'content-type': ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"accept": @"",
                           @"content-type": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification" in
let headers = Header.add_list (Header.init ()) [
  ("accept", "");
  ("content-type", "");
] in

Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification');
$request->setRequestMethod('POST');
$request->setHeaders([
  'accept' => '',
  'content-type' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification' -Method POST -Headers $headers

$headers=@{}
$headers.Add("accept", "")
$headers.Add("content-type", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification' -Method POST -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'accept': "",
    'content-type': ""
}

conn.request("POST", "/baseUrl/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification"

headers = {
    "accept": "",
    "content-type": ""
}

response = requests.post(url, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["accept"] = ''
request["content-type"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.post('/baseUrl/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification') do |req|
  req.headers['accept'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification";

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("accept", "".parse().unwrap());
    headers.insert("content-type", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification \
  --header 'accept: ' \
  --header 'content-type: '

http POST {{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification \
  accept:'' \
  content-type:''

wget --quiet \
  --method POST \
  --header 'accept: ' \
  --header 'content-type: ' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification

import Foundation

let headers = [
  "accept": "",
  "content-type": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId/payments/:paymentId/payment-notification")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

PUT Update order tracking status

{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking

HEADERS

Content-Type

QUERY PARAMS

orderId

invoiceNumber

BODY json

{
  "deliveredDate": "",
  "events": [
    {
      "city": "",
      "date": "",
      "description": "",
      "state": ""
    }
  ],
  "isDelivered": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking" {:headers {:accept ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:deliveredDate ""
                                                                                                                     :events [{:city ""
                                                                                                                               :date ""
                                                                                                                               :description ""
                                                                                                                               :state ""}]
                                                                                                                     :isDelivered false}})

require "http/client"

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking"
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}
reqBody = "{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking"),
    Headers =
    {
        { "accept", "" },
    },
    Content = new StringContent("{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
request.AddParameter("", "{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking"

	payload := strings.NewReader("{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking HTTP/1.1
Content-Type: 
Accept: 
Host: example.com
Content-Length: 159

{
  "deliveredDate": "",
  "events": [
    {
      "city": "",
      "date": "",
      "description": "",
      "state": ""
    }
  ],
  "isDelivered": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .setBody("{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking"))
    .header("content-type", "")
    .header("accept", "")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking")
  .put(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking")
  .header("content-type", "")
  .header("accept", "")
  .body("{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}")
  .asString();

const data = JSON.stringify({
  deliveredDate: '',
  events: [
    {
      city: '',
      date: '',
      description: '',
      state: ''
    }
  ],
  isDelivered: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking',
  headers: {'content-type': '', accept: ''},
  data: {
    deliveredDate: '',
    events: [{city: '', date: '', description: '', state: ''}],
    isDelivered: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking';
const options = {
  method: 'PUT',
  headers: {'content-type': '', accept: ''},
  body: '{"deliveredDate":"","events":[{"city":"","date":"","description":"","state":""}],"isDelivered":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking',
  method: 'PUT',
  headers: {
    'content-type': '',
    accept: ''
  },
  processData: false,
  data: '{\n  "deliveredDate": "",\n  "events": [\n    {\n      "city": "",\n      "date": "",\n      "description": "",\n      "state": ""\n    }\n  ],\n  "isDelivered": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking")
  .put(body)
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  deliveredDate: '',
  events: [{city: '', date: '', description: '', state: ''}],
  isDelivered: false
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking',
  headers: {'content-type': '', accept: ''},
  body: {
    deliveredDate: '',
    events: [{city: '', date: '', description: '', state: ''}],
    isDelivered: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking');

req.headers({
  'content-type': '',
  accept: ''
});

req.type('json');
req.send({
  deliveredDate: '',
  events: [
    {
      city: '',
      date: '',
      description: '',
      state: ''
    }
  ],
  isDelivered: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking',
  headers: {'content-type': '', accept: ''},
  data: {
    deliveredDate: '',
    events: [{city: '', date: '', description: '', state: ''}],
    isDelivered: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking';
const options = {
  method: 'PUT',
  headers: {'content-type': '', accept: ''},
  body: '{"deliveredDate":"","events":[{"city":"","date":"","description":"","state":""}],"isDelivered":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };
NSDictionary *parameters = @{ @"deliveredDate": @"",
                              @"events": @[ @{ @"city": @"", @"date": @"", @"description": @"", @"state": @"" } ],
                              @"isDelivered": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'deliveredDate' => '',
    'events' => [
        [
                'city' => '',
                'date' => '',
                'description' => '',
                'state' => ''
        ]
    ],
    'isDelivered' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking', [
  'body' => '{
  "deliveredDate": "",
  "events": [
    {
      "city": "",
      "date": "",
      "description": "",
      "state": ""
    }
  ],
  "isDelivered": false
}',
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'deliveredDate' => '',
  'events' => [
    [
        'city' => '',
        'date' => '',
        'description' => '',
        'state' => ''
    ]
  ],
  'isDelivered' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'deliveredDate' => '',
  'events' => [
    [
        'city' => '',
        'date' => '',
        'description' => '',
        'state' => ''
    ]
  ],
  'isDelivered' => null
]));
$request->setRequestUrl('{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking' -Method PUT -Headers $headers -ContentType '' -Body '{
  "deliveredDate": "",
  "events": [
    {
      "city": "",
      "date": "",
      "description": "",
      "state": ""
    }
  ],
  "isDelivered": false
}'

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking' -Method PUT -Headers $headers -ContentType '' -Body '{
  "deliveredDate": "",
  "events": [
    {
      "city": "",
      "date": "",
      "description": "",
      "state": ""
    }
  ],
  "isDelivered": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}"

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("PUT", "/baseUrl/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking"

payload = {
    "deliveredDate": "",
    "events": [
        {
            "city": "",
            "date": "",
            "description": "",
            "state": ""
        }
    ],
    "isDelivered": False
}
headers = {
    "content-type": "",
    "accept": ""
}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking"

payload <- "{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = ''
request["accept"] = ''
request.body = "{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking') do |req|
  req.headers['accept'] = ''
  req.body = "{\n  \"deliveredDate\": \"\",\n  \"events\": [\n    {\n      \"city\": \"\",\n      \"date\": \"\",\n      \"description\": \"\",\n      \"state\": \"\"\n    }\n  ],\n  \"isDelivered\": false\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking";

    let payload = json!({
        "deliveredDate": "",
        "events": (
            json!({
                "city": "",
                "date": "",
                "description": "",
                "state": ""
            })
        ),
        "isDelivered": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking \
  --header 'accept: ' \
  --header 'content-type: ' \
  --data '{
  "deliveredDate": "",
  "events": [
    {
      "city": "",
      "date": "",
      "description": "",
      "state": ""
    }
  ],
  "isDelivered": false
}'

echo '{
  "deliveredDate": "",
  "events": [
    {
      "city": "",
      "date": "",
      "description": "",
      "state": ""
    }
  ],
  "isDelivered": false
}' |  \
  http PUT {{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking \
  accept:'' \
  content-type:''

wget --quiet \
  --method PUT \
  --header 'content-type: ' \
  --header 'accept: ' \
  --body-data '{\n  "deliveredDate": "",\n  "events": [\n    {\n      "city": "",\n      "date": "",\n      "description": "",\n      "state": ""\n    }\n  ],\n  "isDelivered": false\n}' \
  --output-document \
  - {{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]
let parameters = [
  "deliveredDate": "",
  "events": [
    [
      "city": "",
      "date": "",
      "description": "",
      "state": ""
    ]
  ],
  "isDelivered": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/pvt/orders/:orderId/invoice/:invoiceNumber/tracking")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json; charset=utf-8

RESPONSE BODY json

{
  "date": "2017-03-29T18:04:31.0521233+00:00",
  "orderId": "v501245lspt-01",
  "receipt": "f67d33a8029c42ce9a8f07fc17f54449"
}

GET Retrieve user order details

{{baseUrl}}/api/oms/user/orders/:orderId

HEADERS

Content-Type

QUERY PARAMS

clientEmail

orderId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/oms/user/orders/:orderId" {:headers {:content-type ""
                                                                                  :accept ""}
                                                                        :query-params {:clientEmail ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail="
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/oms/user/orders/:orderId?clientEmail= HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail="))
    .header("content-type", "")
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=")
  .header("content-type", "")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/user/orders/:orderId',
  params: {clientEmail: ''},
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/user/orders/:orderId?clientEmail=',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/user/orders/:orderId',
  qs: {clientEmail: ''},
  headers: {'content-type': '', accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/oms/user/orders/:orderId');

req.query({
  clientEmail: ''
});

req.headers({
  'content-type': '',
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/user/orders/:orderId',
  params: {clientEmail: ''},
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/user/orders/:orderId');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'clientEmail' => ''
]);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/user/orders/:orderId');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'clientEmail' => ''
]));

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/oms/user/orders/:orderId?clientEmail=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/user/orders/:orderId"

querystring = {"clientEmail":""}

headers = {
    "content-type": "",
    "accept": ""
}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/user/orders/:orderId"

queryString <- list(clientEmail = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/oms/user/orders/:orderId') do |req|
  req.headers['accept'] = ''
  req.params['clientEmail'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/user/orders/:orderId";

    let querystring = [
        ("clientEmail", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=' \
  --header 'accept: ' \
  --header 'content-type: '

http GET '{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=' \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail='

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/user/orders/:orderId?clientEmail=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "affiliateId": "GHB",
  "allowCancellation": true,
  "allowEdition": false,
  "authorizedDate": "2019-01-28T20:33:04+00:00",
  "callCenterOperatorData": null,
  "cancelReason": "The size was too big.",
  "cancellationData": {
    "CancellationDate": "2022-10--05T15:40:33",
    "Reason": "Item was too big in the client.",
    "RequestedByPaymentNotification": false,
    "RequestedBySellerNotification": false,
    "RequestedBySystem": false,
    "RequestedByUser": true
  },
  "changesAttachment": {
    "changesData": [
      {
        "discountValue": 3290,
        "incrementValue": 0,
        "itemsAdded": [],
        "itemsRemoved": [
          {
            "id": "1234568358",
            "name": "Bay Max L",
            "price": 3290,
            "quantity": 1,
            "unitMultiplier": null
          }
        ],
        "reason": "Blah",
        "receipt": {
          "date": "2019-02-06T20:46:04.4003606+00:00",
          "orderId": "v502556llux-01",
          "receipt": "029f9ab8-751a-4b1e-bf81-7dd25d14b49b"
        }
      }
    ],
    "id": "changeAttachment"
  },
  "checkedInPickupPointId": "storeNameExample_901",
  "clientPreferencesData": {
    "locale": "en-US",
    "optinNewsLetter": false
  },
  "clientProfileData": {
    "corporateDocument": null,
    "corporateName": null,
    "corporatePhone": null,
    "customerClass": null,
    "document": "11047867702",
    "documentType": "cpf",
    "email": "rodrigo.cunha@vtex.com.br",
    "firstName": "Rodrigo",
    "id": "clientProfileData",
    "isCorporate": false,
    "lastName": "Cunha",
    "phone": "+5521972321094",
    "stateInscription": null,
    "tradeName": null,
    "userProfileId": "5a3692de-358a-4bea-8885-044bce33bb93"
  },
  "commercialConditionData": null,
  "creationDate": "2019-01-28T20:09:43.899958+00:00",
  "customData": null,
  "followUpEmail": "7bf3a59bbc56402c810bda9521ba449e@ct.vtex.com.br",
  "giftRegistryData": null,
  "hostname": "luxstore",
  "invoiceData": null,
  "invoicedDate": null,
  "isCheckedIn": false,
  "isCompleted": true,
  "itemMetadata": {
    "Items": [
      {
        "AssemblyOptions": [
          {
            "Composition": {},
            "Id": "vtex.subscription.plan-ana",
            "InputValues": {
              "vtex.subscription.key.frequency": {
                "Domain": [
                  "4 month",
                  "1 month"
                ],
                "MaximumNumberOfCharacters": 8
              }
            },
            "Name": "vtex.subscription.plan-ana",
            "Required": false
          }
        ],
        "DetailUrl": "/catfood/p",
        "Ean": "43673557",
        "Id": "18",
        "ImageUrl": "http://store.vteximg.com.br/ids/155392-55-55/AlconKOI.jpg?v=635918402228600000",
        "Name": "Cat food",
        "ProductId": "6",
        "RefId": "105",
        "Seller": "1",
        "SkuName": "Cat food"
      }
    ]
  },
  "items": [
    {
      "additionalInfo": {
        "brandId": "2000023",
        "brandName": "VTEX",
        "categoriesIds": "/1/",
        "commercialConditionId": "5",
        "dimension": {
          "cubicweight": 0.7031,
          "height": 15,
          "length": 15,
          "weight": 15,
          "width": 15
        },
        "offeringInfo": null,
        "offeringType": null,
        "offeringTypeId": null,
        "productClusterId": "135,142"
      },
      "assemblies": [],
      "attachmentOfferings": [
        {
          "name": "vtex.subscription.weekly",
          "required": false,
          "schema": {
            "vtex.subscription.key.frequency": {
              "Domain": [
                "1 week",
                " 2 week",
                " 3 week",
                " 4 week"
              ],
              "MaximumNumberOfCharacters": 7
            }
          }
        }
      ],
      "attachments": [],
      "bundleItems": [],
      "callCenterOperator": "callCenterOp5473869",
      "commission": 0,
      "components": [],
      "costPrice": 52,
      "detailUrl": "/bay-max-9429485/p",
      "ean": "3256873",
      "freightCommission": 0,
      "id": "1234568358",
      "imageUrl": "http://luxstore.vteximg.com.br/arquivos/ids/159263-55-55/image-cc1aed75cbfa424a85a94900be3eacec.jpg?v=636795432619830000",
      "isGift": false,
      "itemAttachment": {
        "content": {},
        "name": null
      },
      "listPrice": 3290,
      "lockId": "00-v502556llux-01",
      "manualPrice": null,
      "measurementUnit": "un",
      "name": "Bay Max L",
      "offerings": [],
      "params": [],
      "parentAssemblyBinding": null,
      "parentItemIndex": null,
      "preSaleDate": null,
      "price": 3290,
      "priceDefinitions": {
        "calculatedSellingPrice": 99,
        "sellingPrices": [
          {
            "quantity": 1,
            "value": 99
          }
        ],
        "total": 99
      },
      "priceTags": [],
      "priceValidUntil": null,
      "productId": "9429485",
      "quantity": 1,
      "refId": "BIGHEROBML",
      "rewardValue": 0,
      "seller": "1",
      "sellerSku": "1234568358",
      "sellingPrice": 3290,
      "serialNumbers": "3",
      "shippingPrice": null,
      "tax": 0,
      "taxCode": null,
      "uniqueId": "87F0945396994B349158C7D9C9941442",
      "unitMultiplier": 1
    }
  ],
  "lastChange": "2019-02-06T20:46:11.7010747+00:00",
  "lastMessage": null,
  "marketingData": {
    "coupon": "sale",
    "id": "marketingData",
    "marketingTags": [
      "vtex-subscription"
    ],
    "utmCampaign": "christmas",
    "utmMedium": "utm medium name",
    "utmPartner": "utm partner name",
    "utmSource": "fb",
    "utmiCampaign": " ",
    "utmiPart": " ",
    "utmipage": " "
  },
  "marketplace": {
    "baseURL": "http://oms.vtexinternal.com.br/api/oms?an=luxstore",
    "isCertified": null,
    "name": "luxstore"
  },
  "marketplaceItems": [],
  "marketplaceOrderId": "",
  "marketplaceServicesEndpoint": "http://oms.vtexinternal.com.br/api/oms?an=luxstore",
  "merchantName": "luxstore",
  "openTextField": null,
  "orderFormId": "caae7471333e403f959fa5fd66951340",
  "orderGroup": "v502556lspt",
  "orderId": "1172452900788-01",
  "origin": "Marketplace",
  "packageAttachment": {
    "packages": []
  },
  "paymentData": {
    "giftCards": [],
    "transactions": [
      {
        "isActive": true,
        "merchantName": "luxstore",
        "payments": [
          {
            "accountId": "5BC5C6B417FE432AB971B1D399F190C9",
            "bankIssuedInvoiceBarCodeNumber": "325349573975945245345439573421443986734065",
            "bankIssuedInvoiceBarCodeType": "i25",
            "bankIssuedInvoiceIdentificationNumber": "23797770100000019003099260100022107500729050",
            "bankIssuedInvoiceIdentificationNumberFormatted": "32534.95739 75945.24534 54395.734214 5",
            "billingAddress": {},
            "cardHolder": null,
            "cardNumber": null,
            "connectorResponses": {
              "Message": "logMessage",
              "ReturnCode": "200",
              "Tid": "94857956",
              "authId": "857956"
            },
            "cvv2": null,
            "dueDate": "2019-02-02",
            "expireMonth": null,
            "expireYear": null,
            "firstDigits": null,
            "giftCardAsDiscount": false,
            "giftCardCaption": null,
            "giftCardId": null,
            "giftCardName": null,
            "giftCardProvider": "presentCard",
            "group": "bankInvoice",
            "id": "D3DEECAB3C6C4B9EAF8EF4C1FE062FF3",
            "installments": 1,
            "koinUrl": "koinURL",
            "lastDigits": null,
            "parentAccountId": "5BC5C6B417FE432AB971B1D399F190C9",
            "paymentSystem": "6",
            "paymentSystemName": "Boleto Bancário",
            "redemptionCode": null,
            "referenceValue": 4450,
            "tid": null,
            "url": "https://luxstore.vtexpayments.com.br:443/BankIssuedInvoice/Transaction/418213DE29634837A63DD693A937A696/Payment/D3DEECAB3C6C4B9EAF8EF4C1FE062FF3/Installment/{Installment}",
            "value": 4450
          }
        ],
        "transactionId": "418213DE29634837A63DD693A937A696"
      }
    ]
  },
  "ratesAndBenefitsData": {
    "id": "ratesAndBenefitsData",
    "rateAndBenefitsIdentifiers": []
  },
  "roundingError": 0,
  "salesChannel": "1",
  "sellerOrderId": "00-v502556llux-01",
  "sellers": [
    {
      "fulfillmentEndpoint": "http://fulfillment.vtexcommerce.com.br/api/fulfillment?an=accountName",
      "id": "1",
      "logo": "https://sellersLogo/images.png",
      "name": "Lux Store"
    }
  ],
  "sequence": "502556",
  "shippingData": {
    "address": {
      "addressId": "-1425945657910",
      "addressType": "residential",
      "city": "Rio de Janeiro",
      "complement": "10",
      "country": "BRA",
      "entityId": "eabfb564-99d6-40d8-bd6c-bddbd4990aad",
      "geoCoordinates": [],
      "neighborhood": "Botafogo",
      "number": "518",
      "postalCode": "22250-040",
      "receiverName": "Rodrigo Cunha",
      "reference": null,
      "state": "RJ",
      "street": "Praia de Botafogo",
      "versionId": "e9c3bec2-125d-4b96-a021-316c3aa9f14f"
    },
    "id": "shippingData",
    "logisticsInfo": [
      {
        "addressId": "-1425945657910",
        "deliveryChannel": "delivery",
        "deliveryChannels": [
          {
            "id": "delivery",
            "stockBalance": 0
          }
        ],
        "deliveryCompany": "Todos os CEPS",
        "deliveryIds": [
          {
            "accountCarrierName": "recorrenciaqa",
            "courierId": "197a56f",
            "courierName": "Todos os CEPS",
            "dockId": "1",
            "kitItemDetails": [],
            "quantity": 1,
            "warehouseId": "1_1"
          }
        ],
        "deliveryWindow": null,
        "entityId": "eabfb564-99d6-40d8-bd6c-bddbd4990aad",
        "itemIndex": 0,
        "listPrice": 1160,
        "lockTTL": "10d",
        "pickupPointId": "1_VTEX-RJ",
        "pickupStoreInfo": {
          "additionalInfo": null,
          "address": null,
          "dockId": null,
          "friendlyName": null,
          "isPickupStore": false
        },
        "polygonName": null,
        "price": 1160,
        "selectedSla": "Normal",
        "sellingPrice": 1160,
        "shippingEstimate": "5bd",
        "shippingEstimateDate": "2019-02-04T20:33:46.4595004+00:00",
        "shipsTo": [
          "BRA"
        ],
        "slas": [
          {
            "deliveryChannel": "delivery",
            "deliveryWindow": null,
            "id": "Normal",
            "lockTTL": "12d",
            "name": "Normal",
            "pickupDistance": 0,
            "pickupPointId": "1_VTEX-RJ",
            "pickupStoreInfo": {
              "additionalInfo": null,
              "address": null,
              "dockId": null,
              "friendlyName": null,
              "isPickupStore": false
            },
            "polygonName": "region196",
            "price": 1160,
            "shippingEstimate": "5bd",
            "transitTime": "3d"
          },
          {
            "deliveryChannel": "delivery",
            "deliveryWindow": null,
            "id": "Expressa",
            "lockTTL": "12d",
            "name": "Expressa",
            "pickupDistance": 0,
            "pickupPointId": "1_VTEX-RJ",
            "pickupStoreInfo": {
              "additionalInfo": null,
              "address": null,
              "dockId": null,
              "friendlyName": null,
              "isPickupStore": false
            },
            "polygonName": null,
            "price": 1160,
            "shippingEstimate": "5bd",
            "transitTime": "3d"
          },
          {
            "deliveryChannel": "delivery",
            "deliveryWindow": null,
            "id": "Quebra Kit",
            "lockTTL": "12d",
            "name": "Quebra Kit",
            "pickupDistance": 0,
            "pickupPointId": "1_VTEX-RJ",
            "pickupStoreInfo": {
              "additionalInfo": null,
              "address": null,
              "dockId": null,
              "friendlyName": null,
              "isPickupStore": false
            },
            "polygonName": null,
            "price": 1392,
            "shippingEstimate": "2bd",
            "transitTime": "3d"
          },
          {
            "deliveryChannel": "delivery",
            "deliveryWindow": null,
            "id": "Sob Encomenda",
            "lockTTL": "12d",
            "name": "Sob Encomenda",
            "pickupDistance": 0,
            "pickupPointId": "1_VTEX-RJ",
            "pickupStoreInfo": {
              "additionalInfo": null,
              "address": null,
              "dockId": null,
              "friendlyName": null,
              "isPickupStore": false
            },
            "polygonName": null,
            "price": 1392,
            "shippingEstimate": "32bd",
            "transitTime": "3d"
          }
        ],
        "transitTime": "3d",
        "versionId": "e9c3bec2-125d-4b96-a021-316c3aa9f14f"
      }
    ],
    "selectedAddresses": [
      {
        "addressId": "-1425945657910",
        "addressType": "residential",
        "city": "Rio de Janeiro",
        "complement": "10",
        "country": "BRA",
        "entityId": "eabfb564-99d6-40d8-bd6c-bddbd4990aad",
        "geoCoordinates": [],
        "neighborhood": "Botafogo",
        "number": "518",
        "postalCode": "22250-040",
        "receiverName": "Rodrigo Cunha",
        "reference": null,
        "state": "RJ",
        "street": "Praia de Botafogo",
        "versionId": "e9c3bec2-125d-4b96-a021-316c3aa9f14f"
      }
    ],
    "trackingHints": null
  },
  "status": "handling",
  "statusDescription": "Preparando Entrega",
  "storePreferencesData": {
    "countryCode": "BRA",
    "currencyCode": "BRL",
    "currencyFormatInfo": {
      "CurrencyDecimalDigits": 2,
      "CurrencyDecimalSeparator": ",",
      "CurrencyGroupSeparator": ".",
      "CurrencyGroupSize": 3,
      "StartsWithCurrencySymbol": true
    },
    "currencyLocale": 1046,
    "currencySymbol": "R$",
    "timeZone": "E. South America Standard Time"
  },
  "subscriptionData": {
    "SubscriptionGroupId": "A64AC73C0FB8693A7ADB4AC69CA4FD5F",
    "Subscriptions": [
      {
        "ExecutionCount": 724,
        "ItemIndex": 0,
        "Plan": {
          "frequency": {
            "interval": 1,
            "periodicity": "DAILY"
          },
          "type": "RECURRING_PAYMENT",
          "validity": {
            "begin": "2022-01-10T00:00:00.0000000+00:00",
            "end": "2024-02-03T00:00:00.0000000+00:00"
          }
        },
        "PriceAtSubscriptionDate": 100
      }
    ]
  },
  "taxData": {
    "areTaxesDesignatedByMarketplace": true,
    "taxInfoCollection": [
      {
        "itemIndex": 0,
        "priceTags": [
          {
            "isPercentual": false,
            "name": "Taxes (Magazine Luisa)",
            "rawValue": "COLOCAR_O_VALOR_SEM_DECIMAL"
          }
        ],
        "sku": "COLOCAR_O_SKUID"
      }
    ]
  },
  "totals": [
    {
      "id": "Items",
      "name": "Total dos Itens",
      "value": 3290
    },
    {
      "id": "Discounts",
      "name": "Total dos Descontos",
      "value": 0
    },
    {
      "id": "Shipping",
      "name": "Total do Frete",
      "value": 1160
    },
    {
      "id": "Tax",
      "name": "Total da Taxa",
      "value": 0
    },
    {
      "id": "Change",
      "name": "Total das mudanças",
      "value": -3290
    }
  ],
  "value": 1160
}

GET Retrieve user's orders

{{baseUrl}}/api/oms/user/orders

HEADERS

Content-Type

QUERY PARAMS

clientEmail

page

per_page

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: ");
headers = curl_slist_append(headers, "accept: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/api/oms/user/orders" {:headers {:content-type ""
                                                                         :accept ""}
                                                               :query-params {:clientEmail ""
                                                                              :page ""
                                                                              :per_page ""}})

require "http/client"

url = "{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page="
headers = HTTP::Headers{
  "content-type" => ""
  "accept" => ""
}

response = HTTP::Client.get url, headers: headers
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page="),
    Headers =
    {
        { "accept", "" },
    },
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "");
request.AddHeader("accept", "");
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page="

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("content-type", "")
	req.Header.Add("accept", "")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/api/oms/user/orders?clientEmail=&page=&per_page= HTTP/1.1
Content-Type: 
Accept: 
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=")
  .setHeader("content-type", "")
  .setHeader("accept", "")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page="))
    .header("content-type", "")
    .header("accept", "")
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=")
  .header("content-type", "")
  .header("accept", "")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=');
xhr.setRequestHeader('content-type', '');
xhr.setRequestHeader('accept', '');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/user/orders',
  params: {clientEmail: '', page: '', per_page: ''},
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=',
  method: 'GET',
  headers: {
    'content-type': '',
    accept: ''
  }
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=")
  .get()
  .addHeader("content-type", "")
  .addHeader("accept", "")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/api/oms/user/orders?clientEmail=&page=&per_page=',
  headers: {
    'content-type': '',
    accept: ''
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/user/orders',
  qs: {clientEmail: '', page: '', per_page: ''},
  headers: {'content-type': '', accept: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/api/oms/user/orders');

req.query({
  clientEmail: '',
  page: '',
  per_page: ''
});

req.headers({
  'content-type': '',
  accept: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/api/oms/user/orders',
  params: {clientEmail: '', page: '', per_page: ''},
  headers: {'content-type': '', accept: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=';
const options = {method: 'GET', headers: {'content-type': '', accept: ''}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"",
                           @"accept": @"" };

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page="]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[request setAllHTTPHeaderFields:headers];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=" in
let headers = Header.add_list (Header.init ()) [
  ("content-type", "");
  ("accept", "");
] in

Client.call ~headers `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "accept: ",
    "content-type: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=', [
  'headers' => [
    'accept' => '',
    'content-type' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/api/oms/user/orders');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'clientEmail' => '',
  'page' => '',
  'per_page' => ''
]);

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/api/oms/user/orders');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'clientEmail' => '',
  'page' => '',
  'per_page' => ''
]));

$request->setHeaders([
  'content-type' => '',
  'accept' => ''
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=' -Method GET -Headers $headers

$headers=@{}
$headers.Add("content-type", "")
$headers.Add("accept", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=' -Method GET -Headers $headers

import http.client

conn = http.client.HTTPSConnection("example.com")

headers = {
    'content-type': "",
    'accept': ""
}

conn.request("GET", "/baseUrl/api/oms/user/orders?clientEmail=&page=&per_page=", headers=headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/api/oms/user/orders"

querystring = {"clientEmail":"","page":"","per_page":""}

headers = {
    "content-type": "",
    "accept": ""
}

response = requests.get(url, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/api/oms/user/orders"

queryString <- list(
  clientEmail = "",
  page = "",
  per_page = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["content-type"] = ''
request["accept"] = ''

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/api/oms/user/orders') do |req|
  req.headers['accept'] = ''
  req.params['clientEmail'] = ''
  req.params['page'] = ''
  req.params['per_page'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/api/oms/user/orders";

    let querystring = [
        ("clientEmail", ""),
        ("page", ""),
        ("per_page", ""),
    ];

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "".parse().unwrap());
    headers.insert("accept", "".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .headers(headers)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=' \
  --header 'accept: ' \
  --header 'content-type: '

http GET '{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=' \
  accept:'' \
  content-type:''

wget --quiet \
  --method GET \
  --header 'content-type: ' \
  --header 'accept: ' \
  --output-document \
  - '{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page='

import Foundation

let headers = [
  "content-type": "",
  "accept": ""
]

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/api/oms/user/orders?clientEmail=&page=&per_page=")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "facets": [],
  "list": [
    {
      "ShippingEstimatedDate": "2019-02-04T20:33:46+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": "2019-01-28T20:33:04+00:00",
      "callCenterOperatorName": null,
      "clientName": "Cunha VTEX",
      "creationDate": "2019-01-28T20:09:43+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": " Lux Store Seu pedido foi alterado! Pedido realizado em: 28/01/2019 Olá, Rodrigo. Seu pedido foi alterado. Seguem informações abaixo: ",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": null,
      "orderId": "v502556llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": "Boleto Bancário",
      "salesChannel": "1",
      "sequence": "502556",
      "status": "handling",
      "statusDescription": "Preparando Entrega",
      "totalItems": 1,
      "totalValue": 1160,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "Cunha VTEX",
      "creationDate": "2018-08-28T17:42:40+00:00",
      "currencyCode": "BRL",
      "items": null,
      "lastMessageUnread": " Lux Store 96 Seu pedido foi cancelado. Referente ao Pedido #v502449llux-02 Resumo Itens R$ 1.178,98 Entrega R$ 6,90 Total R$ 1.185,88",
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": null,
      "orderId": "v502449llux-02",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": "Promissory",
      "salesChannel": "1",
      "sequence": "502452",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 12,
      "totalValue": 118588,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "Cunha VTEX",
      "creationDate": "2018-08-28T17:42:28.9171556+00:00",
      "currencyCode": null,
      "items": [
        {
          "description": "Mangueira Reservatório Ao Cavalete",
          "ean": null,
          "id": "195",
          "price": 7390,
          "productId": "134",
          "quantity": 1,
          "refId": "TE3121110",
          "seller": "1",
          "sellingPrice": 7390
        },
        {
          "description": "Mangueira Filtro",
          "ean": null,
          "id": "238",
          "price": 5190,
          "productId": "162",
          "quantity": 1,
          "refId": "XC459N610CA",
          "seller": "1",
          "sellingPrice": 5190
        }
      ],
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "",
      "orderId": "v502449llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": null,
      "salesChannel": "1",
      "sequence": "502449",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 0,
      "totalValue": 21526180,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2017-07-29T19:24:20.7444363+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "Cunha VTEX",
      "creationDate": "2017-07-25T23:17:36.7963248+00:00",
      "currencyCode": null,
      "items": [
        {
          "description": "Aquecedor Britania 1500 Branco",
          "ean": "1235567890143",
          "id": "1234568212",
          "price": 35599,
          "productId": "1000200",
          "quantity": 1,
          "refId": "branquinho",
          "seller": "1",
          "sellingPrice": 35599
        }
      ],
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "",
      "orderId": "v502058llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": null,
      "salesChannel": "1",
      "sequence": "502058",
      "status": "invoiced",
      "statusDescription": "Faturado",
      "totalItems": 0,
      "totalValue": 35599,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2017-06-27T13:59:49.7705236+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "Cunha VTEX",
      "creationDate": "2017-06-26T16:57:58.9986524+00:00",
      "currencyCode": null,
      "items": [
        {
          "description": "Boneco do Mário",
          "ean": "bonecomario",
          "id": "1234568183",
          "price": 150363,
          "productId": "1000257",
          "quantity": 1,
          "refId": "bonecomario",
          "seller": "1",
          "sellingPrice": 150363
        },
        {
          "description": "Camiseta GG",
          "ean": null,
          "id": "1234567894",
          "price": 899,
          "productId": "1000187",
          "quantity": 1,
          "refId": "abc1234",
          "seller": "1",
          "sellingPrice": 899
        }
      ],
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "",
      "orderId": "v501538llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": null,
      "salesChannel": "1",
      "sequence": "501538",
      "status": "invoiced",
      "statusDescription": "Faturado",
      "totalItems": 0,
      "totalValue": 151262,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2016-12-02T08:00:00+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "Cunha VTEX",
      "creationDate": "2016-11-21T19:57:54.0415289+00:00",
      "currencyCode": null,
      "items": [
        {
          "description": "Camiseta GG",
          "ean": null,
          "id": "1234567894",
          "price": 899,
          "productId": "1000187",
          "quantity": 2,
          "refId": "abc1234",
          "seller": "1",
          "sellingPrice": 899
        }
      ],
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "",
      "orderId": "v501020llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": null,
      "salesChannel": "1",
      "sequence": "501020",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 0,
      "totalValue": 3190,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2016-10-10T14:23:17.1897068+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "Cunha VTEX",
      "creationDate": "2016-10-10T17:19:30.8562035+00:00",
      "currencyCode": null,
      "items": [
        {
          "description": "SMARTPHONE SAMSUNG GALAXY S7 FLAT SM-G930FZDLZTO 32GB DOURADO TELA 5.1\" 4G CÂMERA 12 MP",
          "ean": null,
          "id": "1234568028",
          "price": 299000,
          "productId": "1000203",
          "quantity": 1,
          "refId": "testefnac",
          "seller": "1",
          "sellingPrice": 299000
        }
      ],
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "",
      "orderId": "v500973llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": null,
      "salesChannel": "1",
      "sequence": "500973",
      "status": "handling",
      "statusDescription": "Preparando Entrega",
      "totalItems": 0,
      "totalValue": 299900,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": "2016-10-10T14:13:34.4927265+00:00",
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "Cunha VTEX",
      "creationDate": "2016-10-10T17:07:59.0889392+00:00",
      "currencyCode": null,
      "items": [
        {
          "description": "Camiseta GG",
          "ean": null,
          "id": "1234567894",
          "price": 899,
          "productId": "1000187",
          "quantity": 1,
          "refId": "abc1234",
          "seller": "1",
          "sellingPrice": 899
        }
      ],
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "",
      "orderId": "v500970llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": null,
      "salesChannel": "1",
      "sequence": "500970",
      "status": "invoiced",
      "statusDescription": "Faturado",
      "totalItems": 0,
      "totalValue": 1799,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "Cunha VTEX",
      "creationDate": "2016-08-17T18:35:04.8659804+00:00",
      "currencyCode": null,
      "items": [
        {
          "description": "Botin Futbol Adidas 11Questra Fg Cesped Hombre Absolut - M",
          "ean": "absolutm",
          "id": "549",
          "price": 1000,
          "productId": "9",
          "quantity": 1,
          "refId": null,
          "seller": "1",
          "sellingPrice": 1000
        }
      ],
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "",
      "orderId": "v500890llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": null,
      "salesChannel": "1",
      "sequence": "500890",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 0,
      "totalValue": 1000,
      "workflowInErrorState": false,
      "workflowInRetry": false
    },
    {
      "ShippingEstimatedDate": null,
      "ShippingEstimatedDateMax": null,
      "ShippingEstimatedDateMin": null,
      "affiliateId": "",
      "authorizedDate": null,
      "callCenterOperatorName": null,
      "clientName": "Cunha VTEX",
      "creationDate": "2016-07-29T00:20:47.7736718+00:00",
      "currencyCode": null,
      "items": [
        {
          "description": "Rooibos Lavanda - Pouch - 50gr",
          "ean": "198",
          "id": "98",
          "price": 5200,
          "productId": "1000025",
          "quantity": 1,
          "refId": "10098",
          "seller": "1",
          "sellingPrice": 5200
        }
      ],
      "lastMessageUnread": null,
      "listId": null,
      "listType": null,
      "marketPlaceOrderId": "",
      "orderId": "v500838llux-01",
      "orderIsComplete": true,
      "origin": "Marketplace",
      "paymentNames": null,
      "salesChannel": "1",
      "sequence": "500838",
      "status": "canceled",
      "statusDescription": "Cancelado",
      "totalItems": 0,
      "totalValue": 6200,
      "workflowInErrorState": false,
      "workflowInRetry": false
    }
  ],
  "paging": {
    "currentPage": 1,
    "pages": 10,
    "perPage": 2,
    "total": 19
  },
  "stats": {
    "stats": {
      "totalItems": {
        "Count": 19,
        "Facets": {},
        "Max": 0,
        "Mean": 0,
        "Min": 0,
        "Missing": 0,
        "StdDev": 0,
        "Sum": 0,
        "SumOfSquares": 0
      },
      "totalValue": {
        "Count": 19,
        "Facets": {},
        "Max": 0,
        "Mean": 0,
        "Min": 0,
        "Missing": 0,
        "StdDev": 0,
        "Sum": 0,
        "SumOfSquares": 0
      }
    }
  }
}

Orders API

Orders APIv1.0

Seu pagamento foi aprovado.

Pagamento