From availability check to reserved order

BASE="${FILMO_BASE_URL:-https://app.filmo.io}"
curl -sS "$BASE/api/v1/account" \
  -H "Authorization: Bearer $FILMO_API_KEY"

import { filmo } from "./filmo-client.mjs";

const res = await filmo("GET", "/api/v1/account");
if (!res.ok) throw new Error("getAccount " + res.status + " " + res.body?.code);

const { timezone, currency, addons, trial, apiKey } = res.body.data;
console.log({ timezone, currency, addons, trial: trial.active, scopes: apiKey.scopes });

from filmo_client import filmo

status, body, _ = filmo("GET", "/api/v1/account")
if status != 200:
    raise RuntimeError(f"getAccount {status} {(body or {}).get('code')}")

account = body["data"]
print(account["timezone"], account["currency"], account["addons"],
      account["trial"]["active"], account["apiKey"]["scopes"])

BASE="${FILMO_BASE_URL:-https://app.filmo.io}"
curl -sS -X POST "$BASE/api/v1/availability/check" \
  -H "Authorization: Bearer $FILMO_API_KEY" \
  -H "Content-Type: application/json" \
  --data @- <<'JSON'
{
  "startDate": "2026-11-02T09:00:00+01:00",
  "endDate": "2026-11-04T18:00:00+01:00",
  "items": [
    { "itemId": "ITEM_ID_1", "quantity": 2 },
    { "itemId": "ITEM_ID_2" }
  ]
}
JSON

import { filmo } from "./filmo-client.mjs";

const TTL_MS = 60_000;
const cache = new Map(); // "start|end|item|variant|quantity" -> { at, entry }
const keyOf = (start, end, i) => [start, end, i.itemId, i.variantId ?? "", i.quantity ?? 1].join("|");

// What the visitor may see: no order numbers, no stock figures of the business.
function toPublic(item, entry) {
  if ("error" in entry) return { itemId: item.itemId, state: "unknown" };
  if (entry.status === "ok") return { itemId: item.itemId, state: "available" };
  return {
    itemId: item.itemId,
    state: entry.status === "partial" ? "partial" : "unavailable",
    maxQuantity: Math.max(0, (item.quantity ?? 1) - entry.shortfall),
  };
}

// items: [{ itemId, quantity, variantId? }] for ONE date range.
// Returns { mode: "live", results } or { mode: "quote" } when you should not promise anything.
export async function checkRange(start, end, items) {
  const entries = new Array(items.length);
  const missing = [];
  items.forEach((item, index) => {
    const hit = cache.get(keyOf(start, end, item));
    if (hit && Date.now() - hit.at < TTL_MS) entries[index] = hit.entry;
    else missing.push(index);
  });

  try {
    for (let from = 0; from < missing.length; from += 100) {
      const slice = missing.slice(from, from + 100); // at most 100 items per query
      const res = await filmo("POST", "/api/v1/availability/check", {
        retries: 0, // never make a visitor wait out a 429
        body: { startDate: start, endDate: end, items: slice.map((index) => items[index]) },
      });
      if (!res.ok) return { mode: "quote", reason: res.status };
      slice.forEach((index, n) => {
        // One entry per requested item, in request order.
        cache.set(keyOf(start, end, items[index]), { at: Date.now(), entry: res.body.data[n] });
        entries[index] = res.body.data[n];
      });
    }
  } catch {
    return { mode: "quote", reason: "network" };
  }
  return { mode: "live", results: entries.map((entry, i) => toPublic(items[i], entry)) };
}

import time

from filmo_client import filmo

TTL = 60  # seconds
cache = {}  # "start|end|item|variant|quantity" -> (stored_at, entry)


def key_of(start, end, item):
    return "|".join([start, end, item["itemId"], item.get("variantId", ""), str(item.get("quantity", 1))])


# What the visitor may see: no order numbers, no stock figures of the business.
def to_public(item, entry):
    if "error" in entry:
        return {"itemId": item["itemId"], "state": "unknown"}
    if entry["status"] == "ok":
        return {"itemId": item["itemId"], "state": "available"}
    return {
        "itemId": item["itemId"],
        "state": "partial" if entry["status"] == "partial" else "unavailable",
        "maxQuantity": max(0, item.get("quantity", 1) - entry["shortfall"]),
    }


# items: [{"itemId", "quantity", "variantId"?}] for ONE date range.
# Returns {"mode": "live", "results": [...]} or {"mode": "quote"} when you should not promise anything.
def check_range(start, end, items):
    entries = [None] * len(items)
    missing = []
    for index, item in enumerate(items):
        hit = cache.get(key_of(start, end, item))
        if hit and time.monotonic() - hit[0] < TTL:
            entries[index] = hit[1]
        else:
            missing.append(index)

    try:
        for offset in range(0, len(missing), 100):  # at most 100 items per query
            chunk = missing[offset:offset + 100]
            status, body, _ = filmo(
                "POST", "/api/v1/availability/check",
                body={"startDate": start, "endDate": end, "items": [items[i] for i in chunk]},
                retries=0,  # never make a visitor wait out a 429
            )
            if status != 200:
                return {"mode": "quote", "reason": status}
            for n, index in enumerate(chunk):
                # One entry per requested item, in request order.
                cache[key_of(start, end, items[index])] = (time.monotonic(), body["data"][n])
                entries[index] = body["data"][n]
    except Exception:
        return {"mode": "quote", "reason": "network"}
    return {"mode": "live", "results": [to_public(items[i], e) for i, e in enumerate(entries)]}

BASE="${FILMO_BASE_URL:-https://app.filmo.io}"
curl -sS -X POST "$BASE/api/v1/orders" \
  -H "Authorization: Bearer $FILMO_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: booking-1042-order" \
  --data @- <<JSON
{
  "contactId": "$CONTACT_ID",
  "startDate": "2026-11-02T09:00:00+01:00",
  "endDate": "2026-11-04T18:00:00+01:00",
  "lines": [
    { "itemId": "ITEM_ID_1", "quantity": 2 },
    { "itemId": "ITEM_ID_2", "quantity": 1 }
  ]
}
JSON

// order.mjs
import { filmo } from "./filmo-client.mjs";

// booking: { id, orderId?, contactId, start, end, lines: [{ itemId, quantity, variantId? }] }
// booking.id is YOUR id of the booking; both keys derive from it.
export async function createBookingOrder(booking) {
  if (booking.orderId) return { ok: true }; // created before: skip straight to the reserve
  const res = await filmo("POST", "/api/v1/orders", {
    idempotencyKey: "booking-" + booking.id + "-order",
    body: { contactId: booking.contactId, startDate: booking.start, endDate: booking.end, lines: booking.lines },
  });
  if (!res.ok) {
    return { ok: false, outcome: res.status === 400 ? "invalid" : "retry-later", problem: res.body };
  }
  booking.orderId = res.body.data.id; // save it now, before reserving
  return { ok: true };
}

# order.py
from filmo_client import filmo


# booking: {"id", "order_id"?, "contact_id", "start", "end", "lines": [{"itemId", "quantity", "variantId"?}]}
# booking["id"] is YOUR id of the booking; both keys derive from it.
def create_booking_order(booking):
    if booking.get("order_id"):
        return {"ok": True}  # created before: skip straight to the reserve
    status, body, _ = filmo(
        "POST", "/api/v1/orders",
        body={
            "contactId": booking["contact_id"],
            "startDate": booking["start"],
            "endDate": booking["end"],
            "lines": booking["lines"],
        },
        idempotency_key="booking-" + booking["id"] + "-order",
    )
    if status != 201:
        return {"ok": False, "outcome": "invalid" if status == 400 else "retry-later", "problem": body}
    booking["order_id"] = body["data"]["id"]  # save it now, before reserving
    return {"ok": True}

BASE="${FILMO_BASE_URL:-https://app.filmo.io}"
curl -sS -X POST "$BASE/api/v1/orders/$ORDER_ID/reserve" \
  -H "Authorization: Bearer $FILMO_API_KEY" \
  -H "Idempotency-Key: booking-1042-reserve"

// order.mjs, continued
export async function reserveBookingOrder(booking) {
  const res = await filmo("POST", "/api/v1/orders/" + booking.orderId + "/reserve", {
    idempotencyKey: "booking-" + booking.id + "-reserve",
  });
  if (res.ok) return { outcome: "reserved", tasksCreated: res.body.meta.tasksCreated };
  if (res.status === 409 && res.body?.code === "insufficient_stock") {
    // Nothing was reserved; the order is still a draft.
    const short = res.body.errors.map(({ path, itemId, requested, available, shortfall }) => ({
      path, itemId, requested, available, shortfall,
    }));
    return { outcome: "short", short };
  }
  return { outcome: "retry-later", problem: res.body };
}

export async function book(booking) {
  const created = await createBookingOrder(booking);
  if (!created.ok) return created;
  return { orderId: booking.orderId, ...(await reserveBookingOrder(booking)) };
}

# order.py, continued
def reserve_booking_order(booking):
    status, body, _ = filmo(
        "POST", "/api/v1/orders/" + booking["order_id"] + "/reserve",
        idempotency_key="booking-" + booking["id"] + "-reserve",
    )
    if status == 200:
        return {"outcome": "reserved", "tasks_created": body["meta"]["tasksCreated"]}
    if status == 409 and (body or {}).get("code") == "insufficient_stock":
        # Nothing was reserved; the order is still a draft.
        short = [
            {k: e.get(k) for k in ("path", "itemId", "requested", "available", "shortfall")}
            for e in body["errors"]
        ]
        return {"outcome": "short", "short": short}
    return {"outcome": "retry-later", "problem": body}


def book(booking):
    created = create_booking_order(booking)
    if not created["ok"]:
        return created
    return {"order_id": booking["order_id"], **reserve_booking_order(booking)}