Check Asset Availability Before You Reserve
Check whether a Capital Asset can be reserved for your dates, or how much Collateral is available on checkout day.
Example use case
You're preparing for a trade show. You need a display monitor from January 14 through January 17 and 100 tote bags from the warehouse on January 14.
What you'll end up with
The monitor's availability under its reservation policy and a count of the tote bags available on checkout day.
Before you start
Have a workspace API key and the IDs of two Active Assets your workspace owns or that are currently shared with it. In ExhibitDay, find them on the Assets page in the top menu.
Good to know
A Single-Unit Capital Asset tracks one item, like a display monitor. A Collateral / Multi-Quantity Item tracks units, like tote bags or brochures. You check them in different ways.
At a glance
Time to try
About 5 minutes
Effect on your data
Read-only
Endpoints
1
The check leaves reservations and inventory unchanged. ExhibitDay checks availability and access again when you save a reservation.
How it works
- For the Capital Asset, supply the inclusive checkout and return dates. Read the availability result and its reservation policy.
- For the Collateral item, supply the checkout date. Compare your planned quantity with the count at the Storage Location you'll use.
Check the monitor and tote bags
Step 1: Check a Capital Asset for a period
Send asset_type_id=1 with start_date and end_date. Use the dates the monitor will be out of storage, including setup or return days as needed.
curl -X GET "https://api.exhibitday.com/v1/assets/availability?asset_id=12345&asset_type_id=1&start_date=2030-01-14&end_date=2030-01-17" -H "Authorization: Bearer YOUR_API_KEY"
Example response (shortened)
{
"asset_reservation_policy_id": 2,
"is_available_under_reservation_policy": true,
"overlapping_reservation_count": 1,
"policy_conflict_count": 0
}
Check: The existing reservation returns the monitor on January 14, when you want to check it out. The dates overlap, but the Moderate policy allows that day. Use is_available_under_reservation_policy to decide whether the proposed period passes the check. Coordinate any same-day handoff with the team.
| Capital Asset reservation policy | Which days an existing reservation blocks |
|---|---|
| 1 · Strict | Every day from checkout through return, including both dates. |
| 2 · Moderate | Only the days between checkout and return. A one- or two-day reservation blocks no days. |
| 3 · Liberal | No days. Check the overlap count and coordinate with the people using the Asset. |
To see the setting in ExhibitDay, open the Capital Asset and select Reservation Policy.
Step 2: Check a Collateral quantity on checkout day
Send asset_type_id=2 and as_of_date for the day you need the tote bags. Leave out start_date and end_date. Collateral uses the Liberal reservation policy, so compare the quantity in storage with what you need. If you omit as_of_date, the API uses today in your workspace time zone.
curl -X GET "https://api.exhibitday.com/v1/assets/availability?asset_id=67890&asset_type_id=2&as_of_date=2030-01-14" -H "Authorization: Bearer YOUR_API_KEY"
Example response (shortened)
{
"as_of_date": "2030-01-14",
"quantity_available_in_storage": 125,
"storage_locations": [
{ "id": 2001, "name": "Main Warehouse", "quantity_available_in_storage": 80 },
{ "id": 2002, "name": "Office", "quantity_available_in_storage": 45 }
]
}
Check: There are 125 bags across both locations, but only 80 at the Main Warehouse. Plan for the remaining 20 before you reserve. To check the warehouse on its own, add storage_location_id=2001. Use a Storage Location that belongs to the workspace that owns the Asset.
Try it
Before running the example
| Variable | What to put in it | Required? |
|---|---|---|
EXHIBITDAY_API_KEY | Your workspace API key. | Yes |
EXHIBITDAY_CAPITAL_ASSET_ID | The Capital Asset ID. | Yes |
EXHIBITDAY_CAPITAL_START_DATE | The proposed Capital checkout date in YYYY-MM-DD format. | Yes |
EXHIBITDAY_CAPITAL_RETURN_DATE | The proposed Capital return date in YYYY-MM-DD format, on or after checkout. | Yes |
EXHIBITDAY_COLLATERAL_ASSET_ID | The Collateral item ID. | Yes |
EXHIBITDAY_COLLATERAL_CHECKOUT_DATE | The day you need the units, in YYYY-MM-DD format. | Yes |
The complete example runs both checks and prints the two responses. To check just one type, use the corresponding request above.
Bash
export EXHIBITDAY_API_KEY='YOUR_API_KEY'
export EXHIBITDAY_CAPITAL_ASSET_ID='12345'
export EXHIBITDAY_CAPITAL_START_DATE='2030-01-14'
export EXHIBITDAY_CAPITAL_RETURN_DATE='2030-01-17'
export EXHIBITDAY_COLLATERAL_ASSET_ID='67890'
export EXHIBITDAY_COLLATERAL_CHECKOUT_DATE='2030-01-14'
PowerShell
$env:EXHIBITDAY_API_KEY = 'YOUR_API_KEY'
$env:EXHIBITDAY_CAPITAL_ASSET_ID = '12345'
$env:EXHIBITDAY_CAPITAL_START_DATE = '2030-01-14'
$env:EXHIBITDAY_CAPITAL_RETURN_DATE = '2030-01-17'
$env:EXHIBITDAY_COLLATERAL_ASSET_ID = '67890'
$env:EXHIBITDAY_COLLATERAL_CHECKOUT_DATE = '2030-01-14'
Complete example program
#!/usr/bin/env bash
# Requires Bash, curl and Python3. No API key is written into the program.
python3 - <<'EXHIBITDAY_PY'
# Python 3; standard library only. Set EXHIBITDAY_API_KEY before running.
import http.client
import json
import os
import re
import time
import urllib.error
import urllib.parse
import urllib.request
BASE = "https://api.exhibitday.com/v1"
SPEC = json.loads("{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}")
API_KEY = os.environ["EXHIBITDAY_API_KEY"]
if any(ord(char) < 32 or ord(char) > 126 for char in API_KEY):
raise RuntimeError("Use the API key as one ASCII header value without control characters")
if not API_KEY.strip():
raise RuntimeError("Set EXHIBITDAY_API_KEY")
def decode_json(text):
if SPEC["preserveNumbers"]:
# Quote JSON NUMBER tokens, never text inside a JSON string, to keep CSV decimals exact.
text = re.sub(r'"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?',
lambda m: m[0] if m[0].startswith('"') else json.dumps(m[0]), text)
return json.loads(text)
from pathlib import Path
# This terminal version uses curl for HTTP and Python's standard library for JSON/CSV.
import subprocess
import tempfile
def transport(method, url, headers, data):
with tempfile.TemporaryDirectory(prefix="exhibitday-guide-") as directory:
folder = Path(directory)
# curl may leave no output file for a valid bodyless304 response.
(folder / "body").write_bytes(b"")
command = ["curl", "--disable", "--silent", "--show-error", "--request", method, "--url", url,
"--max-time", "30", "--dump-header", str(folder / "headers"),
"--output", str(folder / "body"), "--write-out", "%{http_code}"]
for name, value in headers.items():
command += ["--header", name + ": " + value]
if data is not None:
(folder / "request").write_bytes(data)
command += ["--data-binary", "@" + str(folder / "request")]
result = subprocess.run(command, capture_output=True, text=True)
if result.returncode:
raise urllib.error.URLError(result.stderr.strip())
response_headers = {}
blocks = (folder / "headers").read_text(encoding="iso-8859-1").replace("\r\n", "\n").strip().split("\n\n")
for line in blocks[-1].splitlines()[1:]:
name, separator, value = line.partition(":")
if separator:
response_headers[name] = value.strip()
return int(result.stdout), (folder / "body").read_bytes(), response_headers
class ApiError(RuntimeError):
"""An API error response. Branch on error_code (and status), never on the message text.
uncertain is True when a PATCH or DELETE got no response or a server error: it may or may not have been applied."""
def __init__(self, status, body, uncertain=False):
self.status = status
self.uncertain = uncertain
self.error_code = body.get("error_code") if isinstance(body, dict) else None
super().__init__(f"{body.get('error_code')} {body.get('error_params')}: {body.get('errors')} (request {body.get('request_id')})"
if isinstance(body, dict) else "HTTP " + str(status) if status else "No response")
def call(name, params=None, body=None, key=None):
route = SPEC["requests"][name]
headers = {"Authorization": "Bearer " + API_KEY, "Accept": "application/json"}
if route["method"] == "POST":
if not key: raise RuntimeError("Save a create key before sending POST")
headers["Idempotency-Key"] = key
data = None if body is None else json.dumps(body).encode("utf-8")
if data is not None:
headers["Content-Type"] = "application/json"
query = urllib.parse.urlencode(params or {})
url = BASE + route["path"] + ("?" + query if query else "")
# Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
# server error is never resent blindly: it may already have been applied, so the caller reads the record first.
resend = route["method"] == "GET"
for attempt in range(5):
try:
status, raw, response_headers = transport(route["method"], url, headers, data)
except (urllib.error.URLError, TimeoutError, ConnectionError, http.client.HTTPException):
if not resend:
raise ApiError(0, None, uncertain=True)
if attempt == 4:
raise
time.sleep(2 ** attempt)
continue
response_headers = {k.lower(): v for k, v in response_headers.items()}
result = None
if status != 304 and raw:
try:
result = decode_json(raw.decode("utf-8"))
except (ValueError, UnicodeError):
if status < 400:
raise RuntimeError("Expected a JSON success response")
if status >= 500 and not resend:
raise ApiError(status, result, uncertain=True)
retry = resend and (status == 429 or status >= 500)
if retry:
if attempt == 4:
raise RuntimeError("Retry limit reached; check the request outcome before starting a new create")
delay = response_headers.get("retry-after", str(2 ** attempt))
time.sleep(max(0, float(delay)))
continue
if status >= 400:
raise ApiError(status, result)
return {"status": status, "body": result, "headers": response_headers, "raw": raw}
raise RuntimeError("Retry limit reached")
def positive_id(value):
if not re.fullmatch(r"[1-9][0-9]*", value) or int(value) > 9223372036854775807: raise RuntimeError("Use a positive record ID")
return value
def print_value(value):
print(value if isinstance(value, str) else json.dumps(value, ensure_ascii=False))
def required(name):
value = os.environ.get(name)
if value is None or not value.strip(): raise RuntimeError("Set " + name)
return value
def main():
capital_id = positive_id(required("EXHIBITDAY_CAPITAL_ASSET_ID"))
collateral_id = positive_id(required("EXHIBITDAY_COLLATERAL_ASSET_ID"))
capital_start = required("EXHIBITDAY_CAPITAL_START_DATE")
capital_return = required("EXHIBITDAY_CAPITAL_RETURN_DATE")
collateral_date = required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE")
capital_response = call("capital", {"asset_id": capital_id, "asset_type_id": "1", "start_date": capital_start, "end_date": capital_return}, None, None)
print_value(capital_response["raw"].decode("utf-8"))
collateral_response = call("collateral", {"asset_id": collateral_id, "asset_type_id": "2", "as_of_date": collateral_date}, None, None)
print_value(collateral_response["raw"].decode("utf-8"))
if __name__ == "__main__":
main()
EXHIBITDAY_PY
// Server-side Node.js with fetch; built-in modules only. Set EXHIBITDAY_API_KEY.
const BASE = "https://api.exhibitday.com/v1";
const SPEC = JSON.parse("{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}");
const API_KEY = process.env.EXHIBITDAY_API_KEY;
if (!API_KEY || !API_KEY.trim()) throw new Error("Set EXHIBITDAY_API_KEY");
if (/[^\x20-\x7e]/.test(API_KEY)) throw new Error("Use the API key as one ASCII header value without control characters");
const sleep = milliseconds => new Promise(resolve => setTimeout(resolve, milliseconds));
function decodeJson(text) {
if (SPEC.preserveNumbers) {
// Keep raw JSON number tokens exact for CSV; quoted JSON strings remain unchanged.
text = text.replace(/"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g,
token => token.startsWith('"') ? token : JSON.stringify(token));
}
return JSON.parse(text);
}
// An API error response. Branch on errorCode (and status), never on the message text.
// uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
class ApiError extends Error {
constructor(status, result, uncertain = false) {
super(result ? JSON.stringify({ error_code: result.error_code, errors: result.errors,
error_params: result.error_params, request_id: result.request_id }) : status ? "HTTP " + status : "No response");
this.status = status;
this.errorCode = result ? result.error_code : undefined;
this.uncertain = uncertain;
}
}
async function call(name, params = {}, body = null, key = null) {
const route = SPEC.requests[name];
const headers = { Authorization: "Bearer " + API_KEY, Accept: "application/json" };
if (route.method === "POST") {
if (!key) throw new Error("Save a create key before sending POST");
headers["Idempotency-Key"] = key;
}
const data = body === null ? undefined : JSON.stringify(body);
if (data !== undefined) headers["Content-Type"] = "application/json";
const query = new URLSearchParams(params).toString();
const url = BASE + route.path + (query ? "?" + query : "");
// Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
// server error is never resent blindly: it may already have been applied, so the caller reads the record first.
const resend = route.method === "GET";
for (let attempt = 0; attempt < 5; attempt++) {
const controller = new AbortController();
const timer = setTimeout(() => controller.abort(), 30000);
let response, raw;
try {
response = await fetch(url, { method: route.method, headers, body: data, signal: controller.signal, redirect: "error" });
raw = await response.text();
} catch (error) {
if (!resend) throw new ApiError(0, null, true);
if (attempt === 4) throw error;
await sleep(1000 * 2 ** attempt);
continue;
} finally { clearTimeout(timer); }
const resultHeaders = {};
response.headers.forEach((value, name) => { resultHeaders[name.toLowerCase()] = value; });
let result = null;
if (response.status !== 304 && raw) {
try { result = decodeJson(raw); }
catch (error) { if (response.status < 400) throw new Error("Expected a JSON success response"); }
}
if (response.status >= 500 && !resend) throw new ApiError(response.status, result, true);
const retry = resend && (response.status === 429 || response.status >= 500);
if (retry) {
if (attempt === 4) throw new Error("Retry limit reached; check the outcome before starting a new create");
const requested = Number(resultHeaders["retry-after"]);
await sleep(1000 * (Number.isFinite(requested) && requested >= 0 ? requested : 2 ** attempt));
continue;
}
if (response.status >= 400) throw new ApiError(response.status, result);
return { status: response.status, body: result, headers: resultHeaders, raw };
}
throw new Error("Retry limit reached");
}
function positive_id(value) { if (!/^[1-9][0-9]*$/.test(value) || BigInt(value) > 9223372036854775807n) throw new Error("Use a positive record ID"); return value; }
function print_value(value) { console.log(typeof value === "string" ? value : JSON.stringify(value)); }
function required(name) { const value = process.env[name]; if (value === undefined || !value.trim()) throw new Error("Set " + name); return value; }
async function main() {
let capital_id = positive_id(required("EXHIBITDAY_CAPITAL_ASSET_ID"));
let collateral_id = positive_id(required("EXHIBITDAY_COLLATERAL_ASSET_ID"));
let capital_start = required("EXHIBITDAY_CAPITAL_START_DATE");
let capital_return = required("EXHIBITDAY_CAPITAL_RETURN_DATE");
let collateral_date = required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE");
let capital_response = await call("capital", {"asset_id": capital_id, "asset_type_id": "1", "start_date": capital_start, "end_date": capital_return}, null, null);
print_value(capital_response.raw);
let collateral_response = await call("collateral", {"asset_id": collateral_id, "asset_type_id": "2", "as_of_date": collateral_date}, null, null);
print_value(collateral_response.raw);
}
if (require.main === module) main().catch(error => { console.error(error.message); process.exitCode = 1; });
module.exports = { main };
# Python 3; standard library only. Set EXHIBITDAY_API_KEY before running.
import http.client
import json
import os
import re
import time
import urllib.error
import urllib.parse
import urllib.request
BASE = "https://api.exhibitday.com/v1"
SPEC = json.loads("{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}")
API_KEY = os.environ["EXHIBITDAY_API_KEY"]
if any(ord(char) < 32 or ord(char) > 126 for char in API_KEY):
raise RuntimeError("Use the API key as one ASCII header value without control characters")
if not API_KEY.strip():
raise RuntimeError("Set EXHIBITDAY_API_KEY")
def decode_json(text):
if SPEC["preserveNumbers"]:
# Quote JSON NUMBER tokens, never text inside a JSON string, to keep CSV decimals exact.
text = re.sub(r'"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?',
lambda m: m[0] if m[0].startswith('"') else json.dumps(m[0]), text)
return json.loads(text)
class NoRedirect(urllib.request.HTTPRedirectHandler):
def redirect_request(self, request, file, code, message, headers, new_url):
return None
OPENER = urllib.request.build_opener(NoRedirect())
def transport(method, url, headers, data):
request = urllib.request.Request(url, data=data, headers=headers, method=method)
try:
with OPENER.open(request, timeout=30) as response:
return response.status, response.read(), dict(response.headers)
except urllib.error.HTTPError as response:
try:
return response.code, response.read(), dict(response.headers)
finally:
response.close()
class ApiError(RuntimeError):
"""An API error response. Branch on error_code (and status), never on the message text.
uncertain is True when a PATCH or DELETE got no response or a server error: it may or may not have been applied."""
def __init__(self, status, body, uncertain=False):
self.status = status
self.uncertain = uncertain
self.error_code = body.get("error_code") if isinstance(body, dict) else None
super().__init__(f"{body.get('error_code')} {body.get('error_params')}: {body.get('errors')} (request {body.get('request_id')})"
if isinstance(body, dict) else "HTTP " + str(status) if status else "No response")
def call(name, params=None, body=None, key=None):
route = SPEC["requests"][name]
headers = {"Authorization": "Bearer " + API_KEY, "Accept": "application/json"}
if route["method"] == "POST":
if not key: raise RuntimeError("Save a create key before sending POST")
headers["Idempotency-Key"] = key
data = None if body is None else json.dumps(body).encode("utf-8")
if data is not None:
headers["Content-Type"] = "application/json"
query = urllib.parse.urlencode(params or {})
url = BASE + route["path"] + ("?" + query if query else "")
# Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
# server error is never resent blindly: it may already have been applied, so the caller reads the record first.
resend = route["method"] == "GET"
for attempt in range(5):
try:
status, raw, response_headers = transport(route["method"], url, headers, data)
except (urllib.error.URLError, TimeoutError, ConnectionError, http.client.HTTPException):
if not resend:
raise ApiError(0, None, uncertain=True)
if attempt == 4:
raise
time.sleep(2 ** attempt)
continue
response_headers = {k.lower(): v for k, v in response_headers.items()}
result = None
if status != 304 and raw:
try:
result = decode_json(raw.decode("utf-8"))
except (ValueError, UnicodeError):
if status < 400:
raise RuntimeError("Expected a JSON success response")
if status >= 500 and not resend:
raise ApiError(status, result, uncertain=True)
retry = resend and (status == 429 or status >= 500)
if retry:
if attempt == 4:
raise RuntimeError("Retry limit reached; check the request outcome before starting a new create")
delay = response_headers.get("retry-after", str(2 ** attempt))
time.sleep(max(0, float(delay)))
continue
if status >= 400:
raise ApiError(status, result)
return {"status": status, "body": result, "headers": response_headers, "raw": raw}
raise RuntimeError("Retry limit reached")
def positive_id(value):
if not re.fullmatch(r"[1-9][0-9]*", value) or int(value) > 9223372036854775807: raise RuntimeError("Use a positive record ID")
return value
def print_value(value):
print(value if isinstance(value, str) else json.dumps(value, ensure_ascii=False))
def required(name):
value = os.environ.get(name)
if value is None or not value.strip(): raise RuntimeError("Set " + name)
return value
def main():
capital_id = positive_id(required("EXHIBITDAY_CAPITAL_ASSET_ID"))
collateral_id = positive_id(required("EXHIBITDAY_COLLATERAL_ASSET_ID"))
capital_start = required("EXHIBITDAY_CAPITAL_START_DATE")
capital_return = required("EXHIBITDAY_CAPITAL_RETURN_DATE")
collateral_date = required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE")
capital_response = call("capital", {"asset_id": capital_id, "asset_type_id": "1", "start_date": capital_start, "end_date": capital_return}, None, None)
print_value(capital_response["raw"].decode("utf-8"))
collateral_response = call("collateral", {"asset_id": collateral_id, "asset_type_id": "2", "as_of_date": collateral_date}, None, None)
print_value(collateral_response["raw"].decode("utf-8"))
if __name__ == "__main__":
main()
// .NET 8 console program; standard library only. Set EXHIBITDAY_API_KEY.
#nullable disable
using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Threading.Tasks;
class Program
{
static readonly string BaseUrl = "https://api.exhibitday.com/v1";
static readonly JsonNode Spec = JsonNode.Parse("{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}");
static readonly string ApiKey = HeaderKey(Required("EXHIBITDAY_API_KEY"));
static string HeaderKey(string value) { if(value.Any(c=>c<32||c>126))throw new Exception("Use the API key as one ASCII header value without control characters");return value; }
static readonly HttpClient Client = new HttpClient(new HttpClientHandler { AllowAutoRedirect = false }) { Timeout = TimeSpan.FromSeconds(30) };
internal static Func<HttpRequestMessage, Task<HttpResponseMessage>> Send = request => Client.SendAsync(request);
sealed class Result { public int Status; public JsonNode Body; public Dictionary<string, string> Headers; public string Raw; }
// An API error response. Branch on ErrorCode (and Status), never on the message text.
// Uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
sealed class ApiException : Exception
{
public int Status { get; }
public string ErrorCode { get; }
public bool Uncertain { get; }
public ApiException(int status, string errorCode, string message, bool uncertain = false) : base(message) { Status = status; ErrorCode = errorCode; Uncertain = uncertain; }
}
static string Required(string name)
{ var value = Environment.GetEnvironmentVariable(name); return string.IsNullOrWhiteSpace(value) ? throw new Exception("Set " + name) : value; }
static string Text(JsonNode value) => value == null ? "" :
value is JsonValue scalar && scalar.TryGetValue<string>(out var text) ? text : value.ToJsonString();
static JsonObject Query(params (string Key, string Value)[] values)
{ var result = new JsonObject(); foreach (var value in values) result[value.Key] = value.Value; return result; }
static async Task<Result> Call(string name, JsonObject query = null, JsonNode body = null,
string key = null)
{
var route = Spec["requests"][name];
var method = Text(route["method"]);
var headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
{ ["Authorization"] = "Bearer " + ApiKey, ["Accept"] = "application/json" };
if (method == "POST") { if (string.IsNullOrEmpty(key)) throw new Exception("Save a create key before sending POST"); headers["Idempotency-Key"] = key; }
var data = body?.ToJsonString();
var suffix = query == null ? "" : string.Join("&", query.Select(p => Uri.EscapeDataString(p.Key) + "=" + Uri.EscapeDataString(Text(p.Value))));
var url = BaseUrl + Text(route["path"]) + (suffix.Length == 0 ? "" : "?" + suffix);
// Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
// server error is never resent blindly: it may already have been applied, so the caller reads the record first.
var resend = method == "GET";
for (var attempt = 0; attempt < 5; attempt++)
{
using var request = new HttpRequestMessage(new HttpMethod(method), url);
foreach (var header in headers) request.Headers.TryAddWithoutValidation(header.Key, header.Value);
if (data != null) request.Content = new StringContent(data, Encoding.UTF8, "application/json");
HttpResponseMessage response;
string raw;
try { response = await Send(request); }
catch (Exception error) when (error is HttpRequestException || error is TaskCanceledException)
{ if (!resend) throw new ApiException(0, null, "No response", true); if (attempt == 4) throw; await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt))); continue; }
using (response)
{
try { raw = await response.Content.ReadAsStringAsync(); }
catch (Exception error) when (error is HttpRequestException || error is TaskCanceledException)
{ if (!resend) throw new ApiException(0, null, "No response", true); if (attempt == 4) throw; await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt))); continue; }
var status = (int)response.StatusCode;
var resultHeaders = response.Headers.Concat(response.Content.Headers)
.ToDictionary(h => h.Key.ToLowerInvariant(), h => string.Join(", ", h.Value));
JsonNode result = null;
if (status != 304 && raw.Length > 0)
{
try { result = JsonNode.Parse(raw); }
catch (JsonException) { if (status < 400) throw new Exception("Expected a JSON success response"); }
}
var errorBody = result as JsonObject;
if (status >= 500 && !resend) throw new ApiException(status, errorBody == null ? null : Text(errorBody["error_code"]), "HTTP " + status, true);
var retry = resend && (status == 429 || status >= 500);
if (retry)
{
if (attempt == 4) throw new Exception("Retry limit reached; check the outcome before starting a new create");
var seconds = Math.Pow(2, attempt);
if (resultHeaders.TryGetValue("retry-after", out var requested) &&
double.TryParse(requested, NumberStyles.Float, CultureInfo.InvariantCulture, out var delay) &&
double.IsFinite(delay) && delay >= 0) seconds = delay;
await Task.Delay(TimeSpan.FromSeconds(seconds)); continue;
}
if (status >= 400) throw new ApiException(status, errorBody == null ? null : Text(errorBody["error_code"]), errorBody == null ? "HTTP " + status :
$"{Text(errorBody["error_code"])} {errorBody["error_params"]}: {errorBody["errors"]} (request {Text(errorBody["request_id"])})");
return new Result { Status = status, Body = result, Headers = resultHeaders, Raw = raw };
}
}
throw new Exception("Retry limit reached");
}
static string PositiveId(string value) { if(string.IsNullOrEmpty(value)||value[0]=='0'||!value.All(c=>c>='0'&&c<='9')||!long.TryParse(value,NumberStyles.None,CultureInfo.InvariantCulture,out var id)||id<=0)throw new Exception("Use a positive record ID");return value; }
static void PrintValue(object value) => Console.WriteLine(value is string text ? text : JsonSerializer.Serialize(value));
internal static async Task Run()
{
var capital_id = PositiveId(Required("EXHIBITDAY_CAPITAL_ASSET_ID"));
var collateral_id = PositiveId(Required("EXHIBITDAY_COLLATERAL_ASSET_ID"));
var capital_start = Required("EXHIBITDAY_CAPITAL_START_DATE");
var capital_return = Required("EXHIBITDAY_CAPITAL_RETURN_DATE");
var collateral_date = Required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE");
var capital_response = await Call("capital", new JsonObject { ["asset_id"] = capital_id, ["asset_type_id"] = "1", ["start_date"] = capital_start, ["end_date"] = capital_return }, null, null);
PrintValue(capital_response.Raw);
var collateral_response = await Call("collateral", new JsonObject { ["asset_id"] = collateral_id, ["asset_type_id"] = "2", ["as_of_date"] = collateral_date }, null, null);
PrintValue(collateral_response.Raw);
}
static Task Main() => Run();
}
// Java 11+ with Gson on the classpath. Set EXHIBITDAY_API_KEY; save as Main.java.
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.ToNumberPolicy;
import java.io.*;
import java.net.*;
import java.net.http.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.time.*;
import java.util.*;
public class Main {
static final Gson JSON = new GsonBuilder().setObjectToNumberStrategy(ToNumberPolicy.LAZILY_PARSED_NUMBER).create();
static final String BASE = "https://api.exhibitday.com/v1";
static final Map<String,Object> SPEC = JSON.fromJson("{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}", Map.class);
static final String API_KEY = headerKey(required("EXHIBITDAY_API_KEY"));
static String headerKey(String value){if(value.chars().anyMatch(c->c<32||c>126))throw new IllegalArgumentException("Use the API key as one ASCII header value without control characters");return value;}
static final HttpClient CLIENT = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(30)).followRedirects(HttpClient.Redirect.NEVER).build();
interface RequestSender { HttpResponse<String> send(HttpRequest request)throws IOException,InterruptedException; }
static RequestSender SEND=request->CLIENT.send(request,HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
static class Result { int status; Object body; Map<String,String> headers; String raw;
Result(int s, Object b, Map<String,String> h,String r) {status=s;body=b;headers=h;raw=r;} }
// An API error response. Branch on errorCode (and status), never on the message text.
// uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
static class ApiException extends IllegalStateException { final int status; final String errorCode; final boolean uncertain;
ApiException(int status,Object errorCode,String message) {this(status,errorCode,message,false);}
ApiException(int status,Object errorCode,String message,boolean uncertain) {super(message);this.status=status;this.errorCode=errorCode==null?null:String.valueOf(errorCode);this.uncertain=uncertain;} }
static String required(String name) {String value=System.getenv(name);if(value==null||value.trim().isEmpty())throw new IllegalArgumentException("Set "+name);return value;}
static String env(String name,String fallback) {String value=System.getenv(name);return value==null||value.isEmpty()?fallback:value;}
static String text(Object value) {return value==null?"":value.toString();}
@SuppressWarnings("unchecked") static Map<String,Object> obj(Object value) {return value==null?new LinkedHashMap<>(): (Map<String,Object>)value;}
@SuppressWarnings("unchecked") static List<Object> list(Object value) {return value==null?Collections.emptyList():(List<Object>)value;}
static Map<String,Object> map(Object... pairs) {Map<String,Object> result=new LinkedHashMap<>();for(int i=0;i<pairs.length;i+=2)result.put((String)pairs[i],pairs[i+1]);return result;}
static void pause(double seconds) {try {Thread.sleep((long)(Math.max(0,seconds)*1000));}catch(InterruptedException error){Thread.currentThread().interrupt();throw new RuntimeException(error);}}
static Result call(String name,Map<String,Object> query,Object body,String key) {
Map<String,Object> route=obj(obj(SPEC.get("requests")).get(name));String method=text(route.get("method"));
Map<String,Object> headers=map("Authorization","Bearer " + API_KEY,"Accept","application/json");
if(method.equals("POST")){if(key==null||key.isEmpty())throw new IllegalArgumentException("Save a create key before sending POST");headers.put("Idempotency-Key",key);}
String data=body==null?null:JSON.toJson(body);if(data!=null)headers.put("Content-Type","application/json");
StringJoiner queryString=new StringJoiner("&");
if(query!=null)query.forEach((k,v)->queryString.add(URLEncoder.encode(k,StandardCharsets.UTF_8)+"="+URLEncoder.encode(text(v),StandardCharsets.UTF_8)));
String url=BASE+text(route.get("path"))+(queryString.length()==0?"":"?"+queryString);
// Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
// server error is never resent blindly: it may already have been applied, so the caller reads the record first.
boolean resend=method.equals("GET");
for(int attempt=0;attempt<5;attempt++) {
HttpRequest.Builder request=HttpRequest.newBuilder(URI.create(url)).timeout(Duration.ofSeconds(30));
headers.forEach((k,v)->request.header(k,text(v)));
request.method(method,data==null?HttpRequest.BodyPublishers.noBody():HttpRequest.BodyPublishers.ofString(data,StandardCharsets.UTF_8));
HttpResponse<String> response;
try {response=SEND.send(request.build());}
catch(InterruptedException error){Thread.currentThread().interrupt();throw new RuntimeException(error);}
catch(IOException error){if(!resend)throw new ApiException(0,null,"No response",true);if(attempt==4)throw new RuntimeException(error);pause(Math.pow(2,attempt));continue;}
int status=response.statusCode();Object parsed=null;
if(status!=304&&!response.body().isEmpty()) {
try {parsed=JSON.fromJson(response.body(),Object.class);}
catch(RuntimeException error){if(status<400)throw new IllegalStateException("Expected a JSON success response",error);}
}
Map<String,String> responseHeaders=new HashMap<>();response.headers().map().forEach((k,v)->responseHeaders.put(k.toLowerCase(Locale.ROOT),String.join(", ",v)));
if(status>=500&&!resend)throw new ApiException(status,obj(parsed).get("error_code"),"HTTP "+status,true);
boolean retry=resend&&(status==429||status>=500);
if(retry) {
if(attempt==4)throw new IllegalStateException("Retry limit reached; check the outcome before starting a new create");
double seconds=Math.pow(2,attempt);
try {double value=Double.parseDouble(responseHeaders.get("retry-after"));if(Double.isFinite(value)&&value>=0)seconds=value;}catch(Exception ignored){}
pause(seconds);continue;
}
if(status>=400)throw new ApiException(status,obj(parsed).get("error_code"),"HTTP "+status+": "+obj(parsed).get("error_code")+" (request "+obj(parsed).get("request_id")+")");
return new Result(status,parsed,responseHeaders,response.body());
}
throw new IllegalStateException("Retry limit reached");
}
static String positive_id(String value){try{if(value==null||!value.matches("[1-9][0-9]*")||Long.parseLong(value)<=0)throw new IllegalArgumentException();return value;}catch(RuntimeException error){throw new IllegalArgumentException("Use a positive record ID");}}
static void print_value(Object value){try{String text=value instanceof String?(String)value:JSON.toJson(value);System.out.write((text+"\n").getBytes(StandardCharsets.UTF_8));}catch(IOException error){throw new UncheckedIOException(error);}}
static void run()throws Exception {
String capital_id = positive_id(required("EXHIBITDAY_CAPITAL_ASSET_ID"));
String collateral_id = positive_id(required("EXHIBITDAY_COLLATERAL_ASSET_ID"));
String capital_start = required("EXHIBITDAY_CAPITAL_START_DATE");
String capital_return = required("EXHIBITDAY_CAPITAL_RETURN_DATE");
String collateral_date = required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE");
Result capital_response = call("capital", map("asset_id", capital_id, "asset_type_id", "1", "start_date", capital_start, "end_date", capital_return), null, null);
print_value(capital_response.raw);
Result collateral_response = call("collateral", map("asset_id", collateral_id, "asset_type_id", "2", "as_of_date", collateral_date), null, null);
print_value(collateral_response.raw);
}
public static void main(String[] args)throws Exception {run();}
}
<?php
// PHP 8.1+ with the cURL extension. Set EXHIBITDAY_API_KEY before running.
declare(strict_types=1);
const BASE = 'https://api.exhibitday.com/v1';
const SPEC = '{"preserveNumbers":true,"requests":{"capital":{"method":"GET","path":"/assets/availability"},"collateral":{"method":"GET","path":"/assets/availability"}}}';
$spec = json_decode(SPEC, true, 512, JSON_THROW_ON_ERROR);
$apiKey = required('EXHIBITDAY_API_KEY');
if(preg_match('/[^\x20-\x7e]/',$apiKey))throw new RuntimeException('Use the API key as one ASCII header value without control characters');
if (trim($apiKey) === '') throw new RuntimeException('Set EXHIBITDAY_API_KEY');
function required(string $name, bool $allowEmpty = false): string {
$value = getenv($name);
if ($value === false || (!$allowEmpty && $value === '')) {
throw new RuntimeException('Set ' . $name);
}
return $value;
}
function optional(string $name, string $fallback): string {
$value = getenv($name);
return $value === false ? $fallback : $value;
}
function decodeJson(string $text): mixed {
global $spec;
if ($spec['preserveNumbers']) {
// Quote NUMBER tokens without changing digits inside JSON strings; CSV decimals stay exact.
$pattern = <<<'JSON_NUMBER'
~"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?~
JSON_NUMBER;
$text = preg_replace_callback($pattern, static function (array $match): string {
return str_starts_with($match[0], '"') ? $match[0] : json_encode($match[0], JSON_THROW_ON_ERROR);
}, $text);
if ($text === null) throw new RuntimeException('Unable to preserve decimal tokens');
}
return json_decode($text, true, 512, JSON_THROW_ON_ERROR);
}
function nativeTransport(string $method, string $url, array $headers, ?string $data): array {
$responseHeaders = [];
$handle = curl_init($url);
if ($handle === false) throw new RuntimeException('Unable to initialize cURL');
$headerLines = [];
foreach ($headers as $name => $value) $headerLines[] = $name . ': ' . $value;
$options = [CURLOPT_CUSTOMREQUEST => $method, CURLOPT_RETURNTRANSFER => true, CURLOPT_FOLLOWLOCATION => false,
CURLOPT_CONNECTTIMEOUT => 30, CURLOPT_TIMEOUT => 30, CURLOPT_HTTPHEADER => $headerLines,
CURLOPT_HEADERFUNCTION => static function ($handle, string $line) use (&$responseHeaders): int {
if (str_starts_with($line, 'HTTP/')) $responseHeaders = [];
$separator = strpos($line, ':');
if ($separator !== false) {
$responseHeaders[strtolower(trim(substr($line, 0, $separator)))] = trim(substr($line, $separator + 1));
}
return strlen($line);
}];
if ($data !== null) $options[CURLOPT_POSTFIELDS] = $data;
try {
curl_setopt_array($handle, $options);
$raw = curl_exec($handle);
if ($raw === false) throw new RuntimeException('Network request failed: ' . curl_error($handle));
return [(int)curl_getinfo($handle, CURLINFO_RESPONSE_CODE), $raw, $responseHeaders];
} finally {
curl_close($handle);
}
}
function retryDelay(array $headers, int $attempt): float {
$value = $headers['retry-after'] ?? '';
if (is_numeric($value)) return max(0.0, (float)$value);
$date = $value === '' ? false : strtotime($value);
return $date === false ? (float)(2 ** $attempt) : max(0.0, (float)($date - time()));
}
// An API error response. Branch on errorCode (and status), never on the message text.
// $uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
final class ApiException extends RuntimeException {
public function __construct(public readonly int $status, public readonly ?string $errorCode, string $message, public readonly bool $uncertain = false) {
parent::__construct($message);
}
}
function call(string $name, array $params = [], mixed $body = null, ?string $key = null): array {
global $spec, $apiKey, $transport;
$route = $spec['requests'][$name];
$headers = ['Authorization' => 'Bearer ' . $apiKey, 'Accept' => 'application/json'];
if ($route['method'] === 'POST') {
if ($key === null || $key === '') throw new RuntimeException('Save a create key before sending POST');
$headers['Idempotency-Key'] = $key; // ONCE, before retries.
}
$data = $body === null ? null : json_encode($body, JSON_THROW_ON_ERROR);
if ($data !== null) $headers['Content-Type'] = 'application/json';
$query = http_build_query($params, '', '&', PHP_QUERY_RFC3986);
$url = BASE . $route['path'] . ($query === '' ? '' : '?' . $query);
// Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
// server error is never resent blindly: it may already have been applied, so the caller reads the record first.
$resend = $route['method'] === 'GET';
for ($attempt = 0; $attempt < 5; $attempt++) {
try {
[$status, $raw, $responseHeaders] = $transport($route['method'], $url, $headers, $data);
} catch (RuntimeException $error) {
if (!$resend) throw new ApiException(0, null, 'No response', true);
if ($attempt === 4) throw $error;
usleep((int)((2 ** $attempt) * 1000000));
continue;
}
$responseHeaders = array_change_key_case($responseHeaders, CASE_LOWER);
$result = null;
if ($status !== 304 && $raw !== '') {
try { $result = decodeJson($raw); }
catch (JsonException $error) {
if ($status < 400) throw new RuntimeException('Expected a JSON success response', 0, $error);
}
}
if ($status >= 500 && !$resend) {
throw new ApiException($status, is_array($result) && isset($result['error_code']) ? (string)$result['error_code'] : null, 'HTTP ' . $status, true);
}
$retry = $resend && ($status === 429 || $status >= 500);
if ($retry) {
if ($attempt === 4) throw new RuntimeException('Retry limit reached; check the outcome before starting a new create');
usleep((int)(retryDelay($responseHeaders, $attempt) * 1000000));
continue;
}
if ($status >= 400) {
if (!is_array($result)) throw new ApiException($status, null, 'HTTP ' . $status);
throw new ApiException($status, isset($result['error_code']) ? (string)$result['error_code'] : null, json_encode(['error_code' => $result['error_code'] ?? null,
'error_params' => $result['error_params'] ?? null, 'errors' => $result['errors'] ?? null,
'request_id' => $result['request_id'] ?? null], JSON_THROW_ON_ERROR));
}
return ['status' => $status, 'body' => $result, 'headers' => $responseHeaders, 'raw' => $raw];
}
throw new RuntimeException('Retry limit reached');
}
$transport = Closure::fromCallable('nativeTransport');
function positive_id(string $value):string{if(!preg_match("/^[1-9][0-9]*$/D",$value)||strlen($value)>19||(strlen($value)===19&&strcmp($value,"9223372036854775807")>0))throw new RuntimeException("Use a positive record ID");return $value;}
function print_value(mixed $value):void{echo (is_string($value)?$value:json_encode($value,JSON_THROW_ON_ERROR))."\n";}
function main():void {
$capital_id = positive_id(required('EXHIBITDAY_CAPITAL_ASSET_ID'));
$collateral_id = positive_id(required('EXHIBITDAY_COLLATERAL_ASSET_ID'));
$capital_start = required('EXHIBITDAY_CAPITAL_START_DATE');
$capital_return = required('EXHIBITDAY_CAPITAL_RETURN_DATE');
$collateral_date = required('EXHIBITDAY_COLLATERAL_CHECKOUT_DATE');
$capital_response = call('capital', ['asset_id' => $capital_id, 'asset_type_id' => '1', 'start_date' => $capital_start, 'end_date' => $capital_return], null, null);
print_value($capital_response["raw"]);
$collateral_response = call('collateral', ['asset_id' => $collateral_id, 'asset_type_id' => '2', 'as_of_date' => $collateral_date], null, null);
print_value($collateral_response["raw"]);
}
if (realpath($_SERVER['SCRIPT_FILENAME'] ?? '') === __FILE__) main();
# Ruby 3.1+; standard library only. Set EXHIBITDAY_API_KEY before running.
require 'net/http'
require 'json'
require 'uri'
require 'csv'
require 'fileutils'
require 'securerandom'
require 'date'
require 'time'
require 'timeout'
BASE = 'https://api.exhibitday.com/v1'
SPEC = JSON.parse('{"preserveNumbers":true,"requests":{"capital":{"method":"GET","path":"/assets/availability"},"collateral":{"method":"GET","path":"/assets/availability"}}}')
API_KEY = ENV.fetch('EXHIBITDAY_API_KEY')
raise 'Use the API key as one ASCII header value without control characters' if API_KEY.each_codepoint.any?{|point|point<32||point>126}
def decode_json(text)
if SPEC.fetch('preserveNumbers')
# Preserve JSON NUMBER lexemes for CSV, without replacing digits inside JSON strings.
text = text.gsub(/"(?:\\.|[^"\\])*"|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/) do |token|
token.start_with?('"') ? token : JSON.generate(token)
end
end
JSON.parse(text)
end
def transport(method, url, headers, data)
uri = URI(url)
request_type = { 'GET' => Net::HTTP::Get, 'POST' => Net::HTTP::Post,
'PATCH' => Net::HTTP::Patch, 'DELETE' => Net::HTTP::Delete }.fetch(method)
request = request_type.new(uri.request_uri, headers)
request.body = data unless data.nil?
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = uri.scheme == 'https'
http.open_timeout = http.read_timeout = http.write_timeout = 30
http.max_retries = 0 # The outer loop owns the bounded retry policy.
response = http.start { |client| client.request(request) }
[response.code.to_i, response.body.to_s, response.each_header.to_h]
end
def retry_delay(headers, attempt)
value = headers['retry-after']
return 2**attempt if value.nil? || value.empty?
begin
[Float(value), 0].max
rescue ArgumentError, TypeError
begin
[Time.httpdate(value) - Time.now, 0].max
rescue ArgumentError
2**attempt
end
end
end
# An API error response. Branch on error_code (and status), never on the message text.
# uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
class ApiError < RuntimeError
attr_reader :status, :error_code, :uncertain
def initialize(status, error_code, message, uncertain = false)
super(message)
@status = status
@error_code = error_code
@uncertain = uncertain
end
end
def call(name, params = {}, body = nil, key = nil)
route = SPEC.fetch('requests').fetch(name)
headers = { 'Authorization' => 'Bearer ' + API_KEY, 'Accept' => 'application/json' }
if route.fetch('method') == 'POST'
headers['Idempotency-Key'] = key || raise('Save a create key before sending POST') # ONCE before retries.
end
data = body.nil? ? nil : JSON.generate(body)
headers['Content-Type'] = 'application/json' unless data.nil?
query = URI.encode_www_form(params)
url = BASE + route.fetch('path') + (query.empty? ? '' : '?' + query)
# Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
# server error is never resent blindly: it may already have been applied, so the caller reads the record first.
resend = route.fetch('method') == 'GET'
5.times do |attempt|
begin
status, raw, response_headers = transport(route.fetch('method'), url, headers, data)
rescue IOError, SystemCallError, Timeout::Error, SocketError
raise ApiError.new(0, nil, 'No response', true) unless resend
raise if attempt == 4
sleep(2**attempt)
next
end
response_headers = response_headers.transform_keys(&:downcase)
result = nil
unless status == 304 || raw.empty?
begin
result = decode_json(raw)
rescue JSON::ParserError, EncodingError
raise 'Expected a JSON success response' if status < 400
end
end
if status >= 500 && !resend
raise ApiError.new(status, result.is_a?(Hash) ? result['error_code'] : nil, "HTTP #{status}", true)
end
transient = resend && (status == 429 || (500..599).cover?(status))
if transient
raise 'Retry limit reached; check the outcome before starting a new create' if attempt == 4
sleep(retry_delay(response_headers, attempt))
next
end
if status >= 400
raise ApiError.new(status, nil, "HTTP #{status}") unless result.is_a?(Hash)
raise ApiError.new(status, result['error_code'], "#{result['error_code']} #{result['error_params'].inspect}: #{result['errors'].inspect} (request #{result['request_id']})")
end
return { status: status, body: result, headers: response_headers, raw: raw }
end
raise 'Retry limit reached'
end
def positive_id(value)
raise "Use a positive record ID" unless /\A[1-9][0-9]*\z/.match?(value) && Integer(value)<=9223372036854775807
value
end
def print_value(value)
STDOUT.binmode.write((value.is_a?(String)?value:JSON.generate(value))+"\n")
end
def required(name)
value=ENV[name]
raise "Set #{name}" if value.nil? || value.strip.empty?
value
end
def main
capital_id = positive_id(required('EXHIBITDAY_CAPITAL_ASSET_ID'))
collateral_id = positive_id(required('EXHIBITDAY_COLLATERAL_ASSET_ID'))
capital_start = required('EXHIBITDAY_CAPITAL_START_DATE')
capital_return = required('EXHIBITDAY_CAPITAL_RETURN_DATE')
collateral_date = required('EXHIBITDAY_COLLATERAL_CHECKOUT_DATE')
capital_response = call('capital', {'asset_id' => capital_id, 'asset_type_id' => '1', 'start_date' => capital_start, 'end_date' => capital_return}, nil, nil)
print_value(capital_response.fetch(:raw))
collateral_response = call('collateral', {'asset_id' => collateral_id, 'asset_type_id' => '2', 'as_of_date' => collateral_date}, nil, nil)
print_value(collateral_response.fetch(:raw))
end
main if $PROGRAM_NAME == __FILE__
// Go 1.18+; standard library only. Set EXHIBITDAY_API_KEY.
package main
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"os"
"strconv"
"strings"
"time"
)
const base = "https://api.exhibitday.com/v1"
const specification = "{\"preserveNumbers\":true,\"requests\":{\"capital\":{\"method\":\"GET\",\"path\":\"/assets/availability\"},\"collateral\":{\"method\":\"GET\",\"path\":\"/assets/availability\"}}}"
var spec map[string]any
var apiKey string
var client = &http.Client{Timeout: 30 * time.Second, CheckRedirect: func(req *http.Request, via []*http.Request) error { return http.ErrUseLastResponse }}
var send = client.Do
type result struct { status int; body any; headers http.Header; raw []byte }
// An API error response (raised with panic). Branch on code (and status), never on the message text.
// uncertain is true when a PATCH or DELETE got no response or a server error: it may or may not have been applied.
type apiError struct { status int; code string; message string; uncertain bool }
func (failure apiError) Error() string { return failure.message }
func required(name string) string {
value := os.Getenv(name); if strings.TrimSpace(value) == "" { panic("Set " + name) }; return value
}
func text(value any) string { if value == nil { return "" }; return fmt.Sprint(value) }
func object(value any) map[string]any { if value == nil { return map[string]any{} }; return value.(map[string]any) }
func array(value any) []any { if value == nil { return nil }; return value.([]any) }
func decode(raw []byte) (any, error) {
var value any
decoder := json.NewDecoder(bytes.NewReader(raw)); decoder.UseNumber() // keeps exact decimal tokens
err := decoder.Decode(&value); return value, err
}
func call(name string, query map[string]string, body any, key string) result {
route := object(object(spec["requests"])[name]); method := text(route["method"])
headers := map[string]string{"Authorization": "Bearer " + apiKey, "Accept": "application/json"}
if method == "POST" { if key == "" { panic("Save a create key before sending POST") }; headers["Idempotency-Key"] = key } // before retry loop
var data []byte
if body != nil { var err error; data, err = json.Marshal(body); if err != nil { panic(err) }; headers["Content-Type"] = "application/json" }
values := url.Values{}; for k,v := range query { values.Set(k,v) }
address := base + text(route["path"]); if len(values) > 0 { address += "?" + values.Encode() }
// Only GET has automatic retries in this workflow. A PATCH or DELETE that got no response or a
// server error is never resent blindly: it may already have been applied, so the caller reads the record first.
resend := method == "GET"
for attempt := 0; attempt < 5; attempt++ {
request, err := http.NewRequest(method, address, bytes.NewReader(data)); if err != nil { panic(err) }
for k,v := range headers { request.Header.Set(k,v) }
response, err := send(request)
if err != nil { if !resend { panic(apiError{0, "", "No response", true}) }; if attempt == 4 { panic(err) }; time.Sleep(time.Second*time.Duration(1<<attempt)); continue }
raw, readErr := io.ReadAll(response.Body); response.Body.Close()
if readErr != nil { if !resend { panic(apiError{0, "", "No response", true}) }; if attempt == 4 { panic(readErr) }; time.Sleep(time.Second*time.Duration(1<<attempt)); continue }
var parsed any
if response.StatusCode != 304 && len(raw)>0 {
parsed, err = decode(raw)
if err != nil && response.StatusCode < 400 { panic("Expected a JSON success response") }
}
errorBody, _ := parsed.(map[string]any)
if response.StatusCode >= 500 && !resend { panic(apiError{response.StatusCode, text(errorBody["error_code"]), fmt.Sprintf("HTTP %d", response.StatusCode), true}) }
retry := resend && (response.StatusCode == 429 || response.StatusCode >= 500)
if retry {
if attempt == 4 { panic("Retry limit reached; check the outcome before starting a new create") }
seconds := float64(int64(1)<<attempt)
if value, err := strconv.ParseFloat(response.Header.Get("Retry-After"),64); err == nil && value >= 0 { seconds = value }
time.Sleep(time.Duration(seconds*float64(time.Second))); continue
}
if response.StatusCode >= 400 { panic(apiError{response.StatusCode, text(errorBody["error_code"]), fmt.Sprintf("HTTP %d: %v (request %v)",response.StatusCode,errorBody["error_code"],errorBody["request_id"]), false}) }
return result{response.StatusCode, parsed, response.Header, raw}
}
panic("Retry limit reached")
}
func positive_id(value string)string{valid:=len(value)>0&&value[0]!='0';for _,ch:=range value{valid=valid&&ch>='0'&&ch<='9'};id,err:=strconv.ParseInt(value,10,64);if !valid||err!=nil||id<=0{panic("Use a positive record ID")};return value}
func print_value(value any){if result,ok:=value.(string);ok{fmt.Println(result);return};raw,err:=json.Marshal(value);if err!=nil{panic(err)};fmt.Println(string(raw))}
func workflow() {
capital_id := positive_id(required("EXHIBITDAY_CAPITAL_ASSET_ID"))
collateral_id := positive_id(required("EXHIBITDAY_COLLATERAL_ASSET_ID"))
capital_start := required("EXHIBITDAY_CAPITAL_START_DATE")
capital_return := required("EXHIBITDAY_CAPITAL_RETURN_DATE")
collateral_date := required("EXHIBITDAY_COLLATERAL_CHECKOUT_DATE")
capital_response := call("capital", map[string]string{"asset_id": capital_id, "asset_type_id": "1", "start_date": capital_start, "end_date": capital_return}, nil, "")
print_value(string(capital_response.raw))
collateral_response := call("collateral", map[string]string{"asset_id": collateral_id, "asset_type_id": "2", "as_of_date": collateral_date}, nil, "")
print_value(string(collateral_response.raw))
}
func header_key(value string)string{for _,ch:=range value{if ch<32||ch>126{panic("Use the API key as one ASCII header value without control characters")}};return value}
func main(){apiKey=header_key(required("EXHIBITDAY_API_KEY"));if err:=json.Unmarshal([]byte(specification),&spec);err!=nil{panic(err)};workflow()}
Example response
{
"asset_id": 12345,
"asset_type_id": 1,
"is_advisory": true,
"is_asset_owned_by_this_workspace": true,
"start_date": "2030-01-14",
"end_date": "2030-01-17",
"as_of_date": null,
"asset_reservation_policy_id": 2,
"is_available_under_reservation_policy": true,
"overlapping_reservation_count": 1,
"policy_conflict_count": 0,
"is_requested_period_unchanged": false,
"quantity_available_in_storage": null,
"projected_future_balance": null,
"storage_locations": null
}
{
"status_code": 400,
"status": "Bad Request",
"message": "HTTP method override is not supported.",
"error_code": "invalid_request",
"errors": [
"Send the documented HTTP method directly. X-HTTP-Method-Override cannot change a request's HTTP method."
],
"error_params": [
"X-HTTP-Method-Override"
],
"request_id": "0123456789abcdef0123456789abcdef"
}
{
"status_code": 401,
"status": "Unauthorized",
"message": "No API key was provided. Send your key in the Authorization header as 'Bearer YOUR_API_KEY'. Alternatively, you can use the api_key parameter.",
"error_code": "missing_api_key",
"errors": [
"Copy the key from Workspace Settings > API & Integrations > API Access in ExhibitDay."
],
"error_params": [
"api_key"
],
"request_id": "0123456789abcdef0123456789abcdef"
}
{
"status_code": 401,
"status": "Unauthorized",
"message": "The API key is not valid. Check that you copied the whole key from Workspace Settings > API & Integrations > API Access, then send it in the Authorization header as 'Bearer YOUR_API_KEY'. Alternatively, you can use the api_key parameter.",
"error_code": "invalid_api_key",
"errors": [
"Check that you sent the whole key. If it was regenerated, use the current key from Workspace Settings > API & Integrations > API Access."
],
"error_params": [
"api_key"
],
"request_id": "0123456789abcdef0123456789abcdef"
}
{
"status_code": 401,
"status": "Unauthorized",
"message": "Access to the ExhibitDay API is not enabled for your workspace. Please contact support@exhibitday.com to enable API Access. Once access is enabled, send your key in the Authorization header as 'Bearer YOUR_API_KEY'.",
"error_code": "api_access_disabled",
"errors": [
"Nothing was read or changed."
],
"error_params": [
"api_key"
],
"request_id": "0123456789abcdef0123456789abcdef"
}
{
"status_code": 404,
"status": "Not Found",
"message": "Asset not found. Invalid Asset ID: 12345.",
"error_code": "not_found",
"errors": [
"Asset not found. Invalid Asset ID: 12345."
],
"error_params": [],
"request_id": "0123456789abcdef0123456789abcdef"
}
{
"status_code": 429,
"status": "Too Many Requests",
"message": "Error 429 - Too Many Requests",
"error_code": "rate_limited",
"errors": [
"Error 429 - Too Many Requests"
],
"error_params": [],
"request_id": "0123456789abcdef0123456789abcdef"
}
{
"status_code": 500,
"status": "Unexpected Internal Error",
"message": "An unexpected error occurred. Please try again later.",
"error_code": "internal_error",
"errors": [
"An unexpected error occurred. Please try again later."
],
"error_params": [],
"request_id": "0123456789abcdef0123456789abcdef"
}
{
"status_code": 500,
"status": "Unexpected Internal Error",
"message": "An unexpected error occurred. Please try again later.",
"error_code": "internal_error",
"errors": [
"Check whether your change was saved before trying again."
],
"error_params": [],
"request_id": "0123456789abcdef0123456789abcdef"
}
The curl example uses Bash, curl and Python 3. Node.js needs version 18 or later (save as .cjs). Python uses its standard library. C# needs a .NET 8 console project (Program.cs). Java needs Java 11 or later and Gson 2.14.0 (Main.java). PHP needs PHP 8.1 or later with cURL. Ruby 3.1 or later and Go 1.18 or later use their standard libraries.
Things to keep in mind
- Collateral availability includes inventory adjustments, Event checkouts and scheduled returns. A scheduled return adds units back from its return date. Confirm physical stock when your plan depends on that return. Negative quantities are returned as recorded.
projected_future_balanceincludes future inventory movements. Usequantity_available_in_storagewith your chosenas_of_datefor the checkout decision.- When editing an existing reservation, pass its accessible ID in
excluded_reservation_id. This excludes the reservation's current allocation. An unchanged Capital period can still pass under the existing save rule. For Collateral, both its checkout and its scheduled return are excluded.
If a request fails
For a validation error, check the Asset type and its date fields. If the Asset can't be found, check that it's Active and still owned by or shared with the workspace for the key you're using.