Add Attendees and Their Travel Reservations to an Event

Register a person for an Event and record their hotel, then list everything for that person.

Example use case

Your team books travel elsewhere and wants to track who is attending an Event and where they will stay.

What you'll end up with

A Staff registration and a Hotel reservation tagged to the same person. The program prints the two record IDs after verifying them.

Before you start

Have a workspace API key, an Event in that workspace and a current active member or Resource ID. The Staff and Travel tabs must be visible and editable to save these records.

Good to know

This records travel in ExhibitDay. You make the hotel booking separately.

At a glance

Time to try

About 15 minutes

Effect on your data

Creates records

Endpoints

8

The program creates a Staff registration and a Hotel reservation and writes a private local journal.

How it works

  1. Choose the Event, person, hotel and local dates. The program checks the person and Hotel type.
  2. It adds and verifies the Staff registration before recording the Hotel reservation.
  3. It verifies the Hotel reservation and prints the two record IDs.

Register the person and record the Hotel

The examples below follow a person with no Staff registration for this Event. A resumed run skips creates it has already checked and saved in the journal.

Step 1: Confirm the workspace

Read the workspace summary so you know where the key can make changes.

curl -X GET "https://api.exhibitday.com/v1/references/workspace_info" -H "Authorization: Bearer YOUR_API_KEY"

Example response (shortened)

{
  "id": 98765
}

Check: Confirm id is the workspace you intend to use.

Step 2: Confirm the Event

Read the Event so you can confirm the destination for both records.

curl -X GET "https://api.exhibitday.com/v1/events/info?id=12345" -H "Authorization: Bearer YOUR_API_KEY"

Example response (shortened)

{
  "id": 12345,
  "name": "Spring Expo 2030"
}

Check: Confirm id and name identify the Event you want.

Step 3: Find the person

Read the workspace's people and Resources to find the person to register.

curl -X GET "https://api.exhibitday.com/v1/references/users_and_resources" -H "Authorization: Bearer YOUR_API_KEY"

Example response (shortened)

{
  "list_data": [
    {
      "id": "f45d4ec2-6d33-4c86-a516-459d21060001"
    }
  ]
}

Check: Use the selected id from list_data and keep the text exactly as returned.

Step 4: Confirm the Hotel type

Read the Travel types before using the Hotel choice.

curl -X GET "https://api.exhibitday.com/v1/references/travel_reservation_types" -H "Authorization: Bearer YOUR_API_KEY"

Example response (shortened)

{
  "list_data": [
    {
      "id": 6,
      "name": "Hotel"
    }
  ]
}

Check: Confirm the Hotel item in list_data has id 6.

Step 5: Look for an existing registration

Read all Staff pages for the Event and person to avoid a duplicate registration.

curl -X GET "https://api.exhibitday.com/v1/events/staff?filter_by_event_id=12345&filter_by_attendee_user_ids=f45d4ec2-6d33-4c86-a516-459d21060001&%24limit=100&%24offset=0" -H "Authorization: Bearer YOUR_API_KEY"

Example response (shortened)

{
  "records_found": 0,
  "total_records": 0,
  "has_more": false,
  "list_data": []
}

Check: This example has no matching Staff records. If you find one, review it before creating a registration.

Step 6: Add the registration

Create the Staff record when the person has no existing registration and the job has no saved acknowledgement.

curl -X POST "https://api.exhibitday.com/v1/events/staff" -H "Authorization: Bearer YOUR_API_KEY" -H "Idempotency-Key: YOUR_PERSISTED_STAFF_KEY" -H "Content-Type: application/json" --data-binary "{\"event_id\":12345,\"attendee_user_id\":\"f45d4ec2-6d33-4c86-a516-459d21060001\",\"registration_type\":\"Conference pass\",\"notify_attendee\":false}"

Example response (shortened)

{
  "id": 2001,
  "event_id": 12345,
  "attendee": {
    "id": "f45d4ec2-6d33-4c86-a516-459d21060001",
    "first_name": "Alex",
    "last_name": "Morgan",
    "display_name": "Alex Morgan",
    "email": "alex.morgan@example.invalid",
    "type": "user",
    "workspace_role": "team_member",
    "is_active": true
  }
}

Check: Keep the returned id and verify event_id and attendee.id. The record id is different from the person ID.

Step 7: Verify the registration

Read the filtered Staff list again before recording Travel.

curl -X GET "https://api.exhibitday.com/v1/events/staff?filter_by_event_id=12345&filter_by_attendee_user_ids=f45d4ec2-6d33-4c86-a516-459d21060001&%24limit=100&%24offset=0" -H "Authorization: Bearer YOUR_API_KEY"

Example response (shortened)

{
  "records_found": 1,
  "total_records": 1,
  "has_more": false,
  "list_data": [
    {
      "id": 2001,
      "event_id": 12345,
      "attendee": {
        "id": "f45d4ec2-6d33-4c86-a516-459d21060001",
        "first_name": "Alex",
        "last_name": "Morgan",
        "display_name": "Alex Morgan",
        "email": "alex.morgan@example.invalid",
        "type": "user",
        "workspace_role": "team_member",
        "is_active": true
      }
    }
  ]
}

Check: Find the registration id just returned or already acknowledged by this job.

Step 8: Record the Hotel and tag the traveler

Save a separate Hotel reservation with the selected person tagged.

curl -X POST "https://api.exhibitday.com/v1/events/travel_reservations" -H "Authorization: Bearer YOUR_API_KEY" -H "Idempotency-Key: YOUR_PERSISTED_TRAVEL_KEY" -H "Content-Type: application/json" --data-binary "{\"event_id\":12345,\"reservation_type_id\":6,\"origin_vendor_name\":\"Spring Expo Conference Hotel\",\"origin_checkin_date\":\"2030-01-14\",\"return_checkin_date\":\"2030-01-17\",\"tagged_user_ids\":[\"f45d4ec2-6d33-4c86-a516-459d21060001\"],\"notify_tagged_users\":false}"

Example response (shortened)

{
  "id": 3001,
  "event_id": 12345,
  "reservation_type_id": 6,
  "origin_vendor_name": "Spring Expo Conference Hotel",
  "origin_checkin_date": "2030-01-14",
  "return_checkin_date": "2030-01-17",
  "tagged_users": [
    {
      "id": "f45d4ec2-6d33-4c86-a516-459d21060001",
      "first_name": "Alex",
      "last_name": "Morgan",
      "display_name": "Alex Morgan",
      "email": "alex@example.invalid",
      "type": "user",
      "workspace_role": "team_member",
      "is_active": true
    }
  ]
}

Check: Keep the Travel id and check the Event, Hotel type, hotel name, dates and selected tag.

Step 9: Verify the Hotel reservation

Read all Travel pages for the Event and selected tag to confirm the reservation.

curl -X GET "https://api.exhibitday.com/v1/events/travel_reservations?filter_by_event_id=12345&filter_by_tagged_user_ids=f45d4ec2-6d33-4c86-a516-459d21060001&filter_by_tagged_user_ids_match_type=all&%24limit=100&%24offset=0" -H "Authorization: Bearer YOUR_API_KEY"

Example response (shortened)

{
  "records_found": 1,
  "total_records": 1,
  "has_more": false,
  "list_data": [
    {
      "id": 3001,
      "event_id": 12345,
      "reservation_type_id": 6,
      "origin_vendor_name": "Spring Expo Conference Hotel",
      "origin_checkin_date": "2030-01-14",
      "return_checkin_date": "2030-01-17",
      "tagged_users": [
        {
          "id": "f45d4ec2-6d33-4c86-a516-459d21060001",
          "first_name": "Alex",
          "last_name": "Morgan",
          "display_name": "Alex Morgan",
          "email": "alex@example.invalid",
          "type": "user",
          "workspace_role": "team_member",
          "is_active": true
        }
      ]
    }
  ]
}

Check: Find the Travel ID returned in Step 8 and verify the Hotel and its tag still match.

Defaults and tags

OptionWhat happens
Attendee role and attendance formatThe program omits attendee_role_id and attendance_format_id to use the person's configured role and the workspace's attendance default.
Hotel dates and booking statusUse local calendar dates. Omit booking_status_id for Not Specified.
NotificationsThe program sends notify_attendee and notify_tagged_users as false unless you opt in. The API defaults to true. New notifications depend on recipient eligibility and preferences.
Changing tags laterSending tagged_user_ids replaces the saved tags. Include everyone whose tag you want to keep.
Other records with tagsPlaybook activities and Misc. expenses & credits (/v1/events/misc_expenses_credits) take the same tagged_user_ids and notify_tagged_users fields, with the same rules.

Try it

Before running the example

VariableWhat to put in itRequired?
EXHIBITDAY_API_KEYYour workspace API key.Yes
EXHIBITDAY_EVENT_IDThe destination Event ID.Yes
EXHIBITDAY_PERSON_IDThe exact text ID from Users and Resources.Yes
EXHIBITDAY_HOTEL_NAMEA plain-text hotel name up to 125 UTF-16 code units, with no leading or trailing spaces.Yes
EXHIBITDAY_CHECKIN_DATEThe check-in date in YYYY-MM-DD format.Yes
EXHIBITDAY_CHECKOUT_DATEThe check-out date in YYYY-MM-DD format, on or after check-in.Yes
EXHIBITDAY_JOB_IDA stable ID for this logical job.Yes
EXHIBITDAY_JOURNALA private local path for this job's journal.Yes
EXHIBITDAY_JOB_MODEUse new for a new job. Use resume or omit it to continue the same job.No
EXHIBITDAY_PAGE_SIZEDefaults to 100.No
EXHIBITDAY_SEND_NOTIFICATIONSDefaults to false. Use true to allow eligible new notifications.No

Bash

export EXHIBITDAY_API_KEY='YOUR_API_KEY'
export EXHIBITDAY_EVENT_ID='12345'
export EXHIBITDAY_PERSON_ID='YOUR_PERSON_ID'
export EXHIBITDAY_HOTEL_NAME='Spring Expo Conference Hotel'
export EXHIBITDAY_CHECKIN_DATE='2030-01-14'
export EXHIBITDAY_CHECKOUT_DATE='2030-01-17'

PowerShell

$env:EXHIBITDAY_API_KEY = 'YOUR_API_KEY'
$env:EXHIBITDAY_EVENT_ID = '12345'
$env:EXHIBITDAY_PERSON_ID = 'YOUR_PERSON_ID'
$env:EXHIBITDAY_HOTEL_NAME = 'Spring Expo Conference Hotel'
$env:EXHIBITDAY_CHECKIN_DATE = '2030-01-14'
$env:EXHIBITDAY_CHECKOUT_DATE = '2030-01-17'

Use your own Event and person IDs, hotel and dates. Set a private journal path and job ID. Set EXHIBITDAY_JOB_MODE=new for a new job.

Then copy the complete example program below in your language and run it.

Complete example program

Code Samples
#!/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\":{\"workspace_binding\":{\"method\":\"GET\",\"path\":\"/references/workspace_info\"},\"people_choices\":{\"method\":\"GET\",\"path\":\"/references/users_and_resources\"},\"travel_choices\":{\"method\":\"GET\",\"path\":\"/references/travel_reservation_types\"},\"event_before\":{\"method\":\"GET\",\"path\":\"/events/info\"},\"find_staff\":{\"method\":\"GET\",\"path\":\"/events/staff\"},\"create_staff\":{\"method\":\"POST\",\"path\":\"/events/staff\"},\"create_travel\":{\"method\":\"POST\",\"path\":\"/events/travel_reservations\"},\"staff_readback\":{\"method\":\"GET\",\"path\":\"/events/staff\"},\"travel_readback\":{\"method\":\"GET\",\"path\":\"/events/travel_reservations\"}}}")
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("Persist a logical 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 add_offset(offset, received):
    result = int(offset) + received
    if received <= 0 or result > 2147483647: raise RuntimeError("Cannot advance this int32 offset; reconcile the query")
    return str(result)

def both(left,right):
    return left and right

def items(value):
    if not isinstance(value, list): raise RuntimeError("Expected a JSON array")
    return value

def count(value):
    return len(items(value))

def either(left, right):
    if not isinstance(left, bool) or not isinstance(right, bool): raise RuntimeError("Expected Boolean criteria")
    return left or right

def equal(left, right):
    return type(left) is type(right) and left == right

def field(value, name):
    if not isinstance(value, dict) or name not in value: raise RuntimeError("Missing response field: " + name)
    return value[name]

def is_empty(value):
    return count(value) == 0

def is_present(value):
    return value is not None and value != ""

"""Strict private client journal reference; no transport or application dependency."""
from pathlib import Path
import hashlib
import os
import re
import secrets
from urllib.parse import urlsplit

PREAMBLE=b'EXHIBITDAY-GUIDE-JOURNAL 1\n'

class JournalRefusal(RuntimeError):
    pass

def utf8(value):
    if not isinstance(value,str):raise JournalRefusal('Journal fields are exact strings')
    return value.encode('utf-8',errors='strict')

def strings(values):
    raw=bytearray()
    for value in values:
        item=utf8(value);raw.extend(str(len(item)).encode('ascii'));raw.extend(b':');raw.extend(item)
    return bytes(raw)

def read_strings(raw):
    values=[];offset=0
    while offset<len(raw):
        end=raw.find(b':',offset)
        if end<0:raise JournalRefusal('Incomplete journal string length')
        length=raw[offset:end]
        if not re.fullmatch(b'0|[1-9][0-9]*',length):raise JournalRefusal('Noncanonical journal string length')
        size=int(length);offset=end+1
        if size>len(raw)-offset:raise JournalRefusal('Incomplete journal string')
        values.append(raw[offset:offset+size].decode('utf-8',errors='strict'));offset+=size
    return values

def digest(raw):return hashlib.sha256(raw).hexdigest().upper()

def fingerprint(pairs):
    values=[]
    for name,value in sorted(pairs.items()):
        if not re.fullmatch('[A-Za-z0-9_.-]+',name):raise JournalRefusal('Fingerprint field names must be explicit ASCII identifiers')
        if name.lower() in ('api_key','exhibitday_api_key'):raise JournalRefusal('Never fingerprint the API key')
        values.extend((name,value))
    return digest(strings(values))

def frame(values):
    raw=strings(values)
    return str(len(raw)).encode('ascii')+b' '+digest(raw).encode('ascii')+b'\n'+raw+b'\n'

def decode(raw):
    if not raw.startswith(PREAMBLE):raise JournalRefusal('Unknown or incomplete journal version')
    offset=len(PREAMBLE);records=[]
    while offset<len(raw):
        end=raw.find(b'\n',offset)
        if end<0:raise JournalRefusal('Incomplete journal frame header; reconcile before retry')
        match=re.fullmatch(b'(0|[1-9][0-9]*) ([0-9A-F]{64})',raw[offset:end])
        if match is None:raise JournalRefusal('Invalid journal frame header')
        size=int(match[1]);offset=end+1
        if size>=len(raw)-offset:raise JournalRefusal('Incomplete journal frame; reconcile before retry')
        payload=raw[offset:offset+size];offset+=size
        if raw[offset:offset+1]!=b'\n' or digest(payload).encode('ascii')!=match[2]:raise JournalRefusal('Journal integrity check failed; reconcile before retry')
        records.append(read_strings(payload));offset+=1
    return records

class Journal:
    def __init__(self,path,base,workspace,slug,job,input_fingerprint,writes,mode="resume"):
        self.path=Path(path);self.lock=Path(str(self.path)+'.lock');self.fd=None;self.owned=False;self.identity=None;self.tainted=False;self.intents={};self.saved_values={}
        address=urlsplit(base)
        if address.scheme not in ('https','http')or not address.netloc or address.username is not None or address.query or address.fragment or not re.fullmatch('[a-z][a-z0-9-]*',slug):raise JournalRefusal('Use the actual API base and closed guide slug')
        if not job.strip() or not re.fullmatch('[1-9][0-9]*',workspace) or not re.fullmatch('[0-9A-F]{64}',input_fingerprint):raise JournalRefusal('Use an actual workspace, explicit stable job ID and exact input fingerprint')
        if mode not in ("new","resume"):raise JournalRefusal("Choose new or resume for this local job")
        self.allowed={};manifest=[]
        for step,method,route in writes:
            if not re.fullmatch('[a-z][a-z0-9_-]*',step)or step in self.allowed or method not in ('POST','PATCH','DELETE')or not re.fullmatch('/v1/[A-Za-z0-9_/-]+',route)or'//'in route:raise JournalRefusal('Use a closed unique write manifest')
            self.allowed[step]=(method,route);manifest.extend((step,method,route))
        if not self.allowed:raise JournalRefusal('Only write workflows need a restart journal')
        self.header=['H','1',base,workspace,slug,job,input_fingerprint,digest(strings(manifest))]
        strings(self.header)
        try:
            self.fd=os.open(self.lock,os.O_WRONLY|os.O_CREAT|os.O_EXCL,0o600);self.owned=True
        except FileExistsError:raise JournalRefusal('This journal is locked; do not run overlapping jobs or steal a stale lock')
        try:
            self.owner=secrets.token_hex(16);self.identity=os.fstat(self.fd)
            if os.write(self.fd,self.owner.encode('ascii'))!=len(self.owner):raise OSError('Incomplete lock identity write')
            os.fsync(self.fd)
            if self.path.is_symlink():raise JournalRefusal('Choose a private regular journal file')
            if mode=="resume" and not self.path.exists():raise JournalRefusal("Journal missing: stop and reconcile lost state before starting a new logical job")
            if mode=="new" and self.path.exists():raise JournalRefusal("A journal already exists; use resume for the same logical job")
            if mode=="new":
                with open(self.path,'xb',buffering=0)as target:
                    target.write(PREAMBLE+frame(self.header));os.fsync(target.fileno())
            records=decode(self.path.read_bytes())
            if not records or records[0]!=self.header:raise JournalRefusal('Journal workspace/base/guide/job/input binding differs')
            for record in records[1:]:self.apply(record)
            if any(step not in self.saved_values for step in self.intents):raise JournalRefusal('A saved before-send intent lacks an ACK; stop and reconcile its outcome before retry')
        except BaseException:
            self.close();raise

    def apply(self,record):
        if not record:raise JournalRefusal('Empty journal record')
        if record[0]=='I':
            if len(record)!=6:raise JournalRefusal('Invalid intent shape')
            _,step,method,path,request_fingerprint,key=record
            if not re.fullmatch('[a-z][a-z0-9_-]*',step)or step in self.intents or self.allowed.get(step)!=(method,path)or not re.fullmatch('[0-9A-F]{64}',request_fingerprint)or any(name not in self.saved_values for name in self.intents):raise JournalRefusal('Invalid, future or repeated journal intent')
            if method=='POST'and not re.fullmatch('[0-9a-f]{32}',key)or method!='POST'and key!='':raise JournalRefusal('Invalid persisted action key')
            self.intents[step]={'method':method,'path':path,'request_fingerprint':request_fingerprint,'idempotency_key':key}
        elif record[0]=='A':
            if len(record)<3:raise JournalRefusal('Invalid ACK shape')
            _,step,count,*pairs=record
            if not re.fullmatch('0|[1-9][0-9]*',count)or len(pairs)!=2*int(count)or step not in self.intents or step in self.saved_values:raise JournalRefusal('ACK without exactly one prior intent')
            names=pairs[::2]
            if names!=sorted(set(names))or any(not re.fullmatch('[a-z][a-z0-9_]*',name)or name in ('api_key','exhibitday_api_key')for name in names):raise JournalRefusal('ACK saved fields must be unique sorted secret-free identifiers')
            self.saved_values[step]=dict(zip(names,pairs[1::2]))
        else:raise JournalRefusal('Unknown journal transition')

    def append(self,record):
        # The reader commits state only after complete length/digest recognition.
        # A torn append is retained and refused, never silently truncated.
        self.require_active();raw=frame(record)
        try:
            with open(self.path,'ab',buffering=0)as target:
                view=memoryview(raw)
                while view:
                    written=target.write(view)
                    if not written:raise OSError('Journal write did not advance')
                    view=view[written:]
                os.fsync(target.fileno())
        except BaseException:
            self.tainted=True;raise

    def require_active(self):
        if not self.owned or self.fd is None or self.identity is None or self.tainted:raise JournalRefusal('The journal scope is closed or its IO outcome needs reconciliation')
        current=self.lock.stat(follow_symlinks=False)
        if current.st_dev!=self.identity.st_dev or current.st_ino!=self.identity.st_ino or self.lock.read_text(encoding='ascii')!=self.owner:raise JournalRefusal('The journal lock was replaced; stop without deleting it')
    def acknowledged(self,step):
        self.require_active();return step in self.saved_values
    def saved(self,step):
        self.require_active()
        if step not in self.saved_values:raise JournalRefusal('No acknowledged state exists for this step')
        return dict(self.saved_values[step])
    def begin(self,step,method,path,request_fingerprint):
        self.require_active()
        if step in self.intents:raise JournalRefusal('Never blindly repeat an existing action intent')
        key=secrets.token_hex(16)if method=='POST'else''
        record=['I',step,method,path,request_fingerprint,key]
        # Validate on an isolated state before touching the file.
        old=dict(self.intents)
        try:self.apply(record)
        finally:self.intents=old
        self.append(record);self.apply(record)
        return dict(self.intents[step])
    def acknowledge(self,step,saved):
        self.require_active()
        record=['A',step,str(len(saved))]
        for name,value in sorted(saved.items()):record.extend((name,value))
        old={name:dict(value)for name,value in self.saved_values.items()}
        try:self.apply(record);strings(record)
        finally:self.saved_values=old
        self.append(record);self.apply(record)
    def close(self):
        if self.owned:
            if self.tainted:
                os.close(self.fd);self.fd=None;self.owned=False
                return # Retain this lock after failed journal IO; manual reconciliation is required.
            try:self.require_active()
            except BaseException:
                os.close(self.fd);self.fd=None;self.owned=False;raise
            os.close(self.fd);self.fd=None;self.owned=False
            self.lock.unlink()
    def __enter__(self):return self
    def __exit__(self,*args):self.close()

def journal_values(value):
    if not isinstance(value, dict) or any(not isinstance(k, str) or not isinstance(v, str) for k,v in value.items()):
        raise JournalRefusal('Saved/fingerprint values must be exact string fields')
    return dict(value)

def journal_acknowledge(job, step, saved):
    job.acknowledge(step,journal_values(saved))

def journal_acknowledged(job, step):
    return job.acknowledged(step)

def journal_begin(job, step, method, path, request_fingerprint):
    return job.begin(step,method,path,request_fingerprint)

def journal_fingerprint(value):
    return fingerprint(journal_values(value))

def journal_saved(job, step):
    return job.saved(step)

def new_id_set():
    return set()

def not_value(value):
    if not isinstance(value, bool): raise RuntimeError("Expected a Boolean")
    return not value

def open_journal(path, base, workspace, slug, job, input_fingerprint, writes, mode):
    return Journal(path,base,workspace,slug,job,input_fingerprint,writes,mode)

def optional(name, fallback):
    value = os.environ.get(name)
    return fallback if value is None or value == "" else value

def page_size(value):
    if not re.fullmatch(r"[1-9][0-9]*", value) or int(value) > 2147483647: raise RuntimeError("Page size must be a positive int32")
    return value

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 remember_id(seen, value):
    if value in seen: return False
    seen.add(value)
    return True

def require_condition(value, message):
    if value is not True: raise RuntimeError(message)

def required(name):
    value = os.environ.get(name)
    if value is None or not value.strip(): raise RuntimeError("Set " + name)
    return value

def response_status(value):
    return str(value["status"])

def text(value):
    if value is None: return ""
    if isinstance(value, str): return value
    if isinstance(value, bool): return "true" if value else "false"
    if isinstance(value, int): return str(value)
    raise RuntimeError("Expected a scalar response value")

def validate_staff_travel_inputs(name, start, end):
    from datetime import date
    spaces = '\u0009\u000A\u000B\u000C\u000D\u0020\u0085\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u2028\u2029\u202F\u205F\u3000'
    for value, label, limit in ((name, 'EXHIBITDAY_HOTEL_NAME', 125),):
        utf8(value)
        if not value or value != value.strip(spaces):
            raise JournalRefusal('Remove whitespace at the start or end of ' + label)
        if len(value.encode('utf-16-le')) // 2 > limit:
            raise JournalRefusal(label + ' exceeds ' + str(limit) + ' UTF-16 code units')
    if any(ch in name for ch in '<>\r\n') or name.lower() == 'null':
        raise JournalRefusal('Use plain, single-line EXHIBITDAY_HOTEL_NAME text other than null')
    for value, label in ((start, 'EXHIBITDAY_CHECKIN_DATE'), (end, 'EXHIBITDAY_CHECKOUT_DATE')):
        try:
            valid = re.fullmatch(r'[0-9]{4}-[0-9]{2}-[0-9]{2}', value) and date.fromisoformat(value).year >= 1753
        except ValueError:
            valid = False
        if not valid:
            raise JournalRefusal(label + ' must be a calendar date in YYYY-MM-DD on or after 1753-01-01')
    if end < start:
        raise JournalRefusal('EXHIBITDAY_CHECKOUT_DATE must be on or after EXHIBITDAY_CHECKIN_DATE')


def main():
    travel_event_id = positive_id(required("EXHIBITDAY_EVENT_ID"))
    travel_person_id = required("EXHIBITDAY_PERSON_ID")
    travel_hotel = required("EXHIBITDAY_HOTEL_NAME")
    travel_checkin = required("EXHIBITDAY_CHECKIN_DATE")
    travel_checkout = required("EXHIBITDAY_CHECKOUT_DATE")
    travel_page_size = page_size(optional("EXHIBITDAY_PAGE_SIZE", "100"))
    travel_notify = optional("EXHIBITDAY_SEND_NOTIFICATIONS", "false")
    require_condition(either(equal(travel_notify, "true"), equal(travel_notify, "false")), "Use exact true or false for EXHIBITDAY_SEND_NOTIFICATIONS.")
    travel_journal_path = required("EXHIBITDAY_JOURNAL")
    travel_job_id = required("EXHIBITDAY_JOB_ID")
    travel_job_mode = optional("EXHIBITDAY_JOB_MODE", "resume")
    validate_staff_travel_inputs(travel_hotel, travel_checkin, travel_checkout)
    travel_workspace_response = call("workspace_binding", {}, None, None)
    require_condition(equal(response_status(travel_workspace_response), "200"), "Expected HTTP200. Keep any durable pending intent and reconcile this response before another write.")
    travel_workspace = travel_workspace_response["body"]
    travel_workspace_id = positive_id(text(field(travel_workspace, "id")))
    travel_event_response = call("event_before", {"id": travel_event_id}, None, None)
    require_condition(equal(response_status(travel_event_response), "200"), "Expected HTTP200. Keep any durable pending intent and reconcile this response before another write.")
    travel_event = travel_event_response["body"]
    require_condition(equal(text(field(travel_event, "id")), travel_event_id), "The Event read differs from the explicit selected Event.")
    travel_people_response = call("people_choices", {}, None, None)
    require_condition(equal(response_status(travel_people_response), "200"), "Expected HTTP200. Keep any durable pending intent and reconcile this response before another write.")
    travel_people = travel_people_response["body"]
    travel_person_found = ""
    for travel_person_choice in items(items(field(travel_people, "list_data"))):
        if equal(text(field(travel_person_choice, "id")), travel_person_id):
            require_condition(not_value(is_present(travel_person_found)), "The people reference returned the same selected person more than once.")
            travel_person_found = travel_person_id
    require_condition(equal(travel_person_found, travel_person_id), "Choose a current person or resource ID from References users_and_resources before creating Staff or Travel.")
    travel_types_response = call("travel_choices", {}, None, None)
    require_condition(equal(response_status(travel_types_response), "200"), "Expected HTTP200. Keep any durable pending intent and reconcile this response before another write.")
    travel_types = travel_types_response["body"]
    travel_hotel_type_found = ""
    for travel_type_choice in items(items(field(travel_types, "list_data"))):
        if equal(text(field(travel_type_choice, "id")), "6"):
            require_condition(both(equal(text(field(travel_type_choice, "name")), "Hotel"), not_value(is_present(travel_hotel_type_found))), "The current type6 reference is not one unambiguous Hotel choice.")
            travel_hotel_type_found = "6"
    require_condition(equal(travel_hotel_type_found, "6"), "This Hotel example requires the currently declared Hotel choice6; do not substitute a different type.")
    travel_staff_before_id = ""
    travel_staff_before_offset = "0"
    travel_staff_before_query = {"filter_by_event_id": travel_event_id, "filter_by_attendee_user_ids": travel_person_id, "$limit": travel_page_size}
    travel_staff_before_seen = new_id_set()
    while True:
        travel_staff_before_query["$offset"] = travel_staff_before_offset
        travel_staff_before_response = call("find_staff", travel_staff_before_query, None, None)
        require_condition(equal(response_status(travel_staff_before_response), "200"), "Expected HTTP200 for the current collection; stop and reconcile another response.")
        travel_staff_before_page = travel_staff_before_response["body"]
        travel_staff_before_rows = items(field(travel_staff_before_page, "list_data"))
        require_condition(equal(text(field(travel_staff_before_page, "records_found")), text(count(travel_staff_before_rows))), "records_found differs from this page's rows.")
        require_condition(is_present(text(field(travel_staff_before_page, "total_records"))), "The collection wrapper needs total_records.")
        require_condition(either(equal(field(travel_staff_before_page, "has_more"), True), equal(field(travel_staff_before_page, "has_more"), False)), "Expected a Boolean has_more value.")
        for travel_staff_before_record in items(travel_staff_before_rows):
            travel_staff_before_record_id = positive_id(text(field(travel_staff_before_record, "id")))
            require_condition(equal(text(field(travel_staff_before_record, "event_id")), travel_event_id), "A selected collection returned a row from another Event.")
            require_condition(equal(text(field(field(travel_staff_before_record, "attendee"), "id")), travel_person_id), "The Staff filter returned a registration for a different person.")
            if remember_id(travel_staff_before_seen, travel_staff_before_record_id):
                require_condition(not_value(is_present(travel_staff_before_id)), "More than one Staff record matches this person and Event. Stop for review; never choose the first.")
                travel_staff_before_id = travel_staff_before_record_id
        if equal(field(travel_staff_before_page, "has_more"), False):
            break
        require_condition(not_value(is_empty(travel_staff_before_rows)), "An empty page says has_more=true. Stop and reconcile the selected query.")
        travel_staff_before_offset = add_offset(travel_staff_before_offset, count(travel_staff_before_rows))
    travel_input_fingerprint = journal_fingerprint({"workflow_contract_sha256": "A4CE8A49EF9814D6F6F256BE0525D5A77FF09C69232E21624504C3C3DDA294AB", "event_id": travel_event_id, "user_id": travel_person_id, "hotel": travel_hotel, "checkin": travel_checkin, "checkout": travel_checkout, "notify": travel_notify, "page_size": travel_page_size})
    travel_job = open_journal(travel_journal_path, "https://api.exhibitday.com/v1", travel_workspace_id, "staff-travel-tags", travel_job_id, travel_input_fingerprint, [["create_staff", "POST", "/v1/events/staff"], ["create_travel", "POST", "/v1/events/travel_reservations"]], travel_job_mode)
    try:
        require_condition(either(not_value(journal_acknowledged(travel_job, "create_travel")), journal_acknowledged(travel_job, "create_staff")), "A Travel create is acknowledged before Staff. Stop and reconcile the saved state.")
        travel_staff_id = ""
        travel_reservation_id = ""
        if journal_acknowledged(travel_job, "create_staff"):
            travel_saved_staff = journal_saved(travel_job, "create_staff")
            travel_staff_id = positive_id(text(field(travel_saved_staff, "id")))
            require_condition(both(equal(text(field(travel_saved_staff, "event_id")), travel_event_id), both(equal(text(field(field(travel_saved_staff, "attendee"), "id")), travel_person_id), equal(text(field(travel_saved_staff, "id")), travel_staff_id))), "The Staff record differs from the captured ID, selected Event or person. Reconcile it; do not create a replacement.")
            require_condition(equal(travel_staff_before_id, travel_staff_id), "The acknowledged Staff entry is missing or changed. Review the current Staff list before continuing.")
        else:
            require_condition(not_value(is_present(travel_staff_before_id)), "This person already has a Staff entry without a saved acknowledgement for this job. Review that entry; do not add another registration.")
            travel_staff_fingerprint = journal_fingerprint({"event_id": travel_event_id, "user_id": travel_person_id, "registration_type": "Conference pass", "notify_attendee": travel_notify})
            travel_staff_intent = journal_begin(travel_job, "create_staff", "POST", "/v1/events/staff", travel_staff_fingerprint)
            travel_staff_create_response = call("create_staff", {}, {"event_id": travel_event_id, "attendee_user_id": travel_person_id, "registration_type": "Conference pass", "notify_attendee": equal(travel_notify, "true")}, text(field(travel_staff_intent, "idempotency_key")))
            require_condition(equal(response_status(travel_staff_create_response), "200"), "Expected HTTP200. Keep any durable pending intent and reconcile this response before another write.")
            travel_created_staff = travel_staff_create_response["body"]
            travel_staff_id = positive_id(text(field(travel_created_staff, "id")))
            require_condition(both(equal(text(field(travel_created_staff, "event_id")), travel_event_id), both(equal(text(field(field(travel_created_staff, "attendee"), "id")), travel_person_id), equal(text(field(travel_created_staff, "id")), travel_staff_id))), "The Staff record differs from the captured ID, selected Event or person. Reconcile it; do not create a replacement.")
            require_condition(equal(text(field(travel_created_staff, "registration_type")), "Conference pass"), "The Staff acknowledgement has a different registration type; preserve pending state and reconcile.")
            journal_acknowledge(travel_job, "create_staff", {"id": travel_staff_id, "event_id": travel_event_id, "user_id": travel_person_id})
        travel_staff_verify_id = ""
        travel_staff_verify_offset = "0"
        travel_staff_verify_query = {"filter_by_event_id": travel_event_id, "filter_by_attendee_user_ids": travel_person_id, "$limit": travel_page_size}
        travel_staff_verify_seen = new_id_set()
        while True:
            travel_staff_verify_query["$offset"] = travel_staff_verify_offset
            travel_staff_verify_response = call("staff_readback", travel_staff_verify_query, None, None)
            require_condition(equal(response_status(travel_staff_verify_response), "200"), "Expected HTTP200 for the current collection; stop and reconcile another response.")
            travel_staff_verify_page = travel_staff_verify_response["body"]
            travel_staff_verify_rows = items(field(travel_staff_verify_page, "list_data"))
            require_condition(equal(text(field(travel_staff_verify_page, "records_found")), text(count(travel_staff_verify_rows))), "records_found differs from this page's rows.")
            require_condition(is_present(text(field(travel_staff_verify_page, "total_records"))), "The collection wrapper needs total_records.")
            require_condition(either(equal(field(travel_staff_verify_page, "has_more"), True), equal(field(travel_staff_verify_page, "has_more"), False)), "Expected a Boolean has_more value.")
            for travel_staff_verify_record in items(travel_staff_verify_rows):
                travel_staff_verify_record_id = positive_id(text(field(travel_staff_verify_record, "id")))
                require_condition(equal(text(field(travel_staff_verify_record, "event_id")), travel_event_id), "A selected collection returned a row from another Event.")
                require_condition(equal(text(field(field(travel_staff_verify_record, "attendee"), "id")), travel_person_id), "The Staff filter returned a registration for a different person.")
                if remember_id(travel_staff_verify_seen, travel_staff_verify_record_id):
                    require_condition(not_value(is_present(travel_staff_verify_id)), "More than one Staff record matches this person and Event. Stop for review; never choose the first.")
                    travel_staff_verify_id = travel_staff_verify_record_id
            if equal(field(travel_staff_verify_page, "has_more"), False):
                break
            require_condition(not_value(is_empty(travel_staff_verify_rows)), "An empty page says has_more=true. Stop and reconcile the selected query.")
            travel_staff_verify_offset = add_offset(travel_staff_verify_offset, count(travel_staff_verify_rows))
        require_condition(equal(travel_staff_verify_id, travel_staff_id), "The captured Staff entry is not present in the complete current selected Event/person list. Stop before Travel creation.")
        if journal_acknowledged(travel_job, "create_travel"):
            travel_saved_reservation = journal_saved(travel_job, "create_travel")
            travel_reservation_id = positive_id(text(field(travel_saved_reservation, "id")))
            require_condition(both(equal(text(field(travel_saved_reservation, "event_id")), travel_event_id), equal(text(field(travel_saved_reservation, "user_id")), travel_person_id)), "Saved Travel state belongs to a different Event or person. Stop and reconcile.")
        else:
            travel_create_fingerprint = journal_fingerprint({"event_id": travel_event_id, "reservation_type_id": "6", "origin_vendor_name": travel_hotel, "origin_checkin_date": travel_checkin, "return_checkin_date": travel_checkout, "tagged_user_ids": travel_person_id, "notify_tagged_users": travel_notify})
            travel_create_intent = journal_begin(travel_job, "create_travel", "POST", "/v1/events/travel_reservations", travel_create_fingerprint)
            travel_create_response = call("create_travel", {}, {"event_id": travel_event_id, "reservation_type_id": "6", "origin_vendor_name": travel_hotel, "origin_checkin_date": travel_checkin, "return_checkin_date": travel_checkout, "tagged_user_ids": [travel_person_id], "notify_tagged_users": equal(travel_notify, "true")}, text(field(travel_create_intent, "idempotency_key")))
            require_condition(equal(response_status(travel_create_response), "200"), "Expected HTTP200. Keep any durable pending intent and reconcile this response before another write.")
            travel_created_reservation = travel_create_response["body"]
            travel_reservation_id = positive_id(text(field(travel_created_reservation, "id")))
            require_condition(both(both(both(both(both(equal(text(field(travel_created_reservation, "id")), travel_reservation_id), equal(text(field(travel_created_reservation, "event_id")), travel_event_id)), equal(text(field(travel_created_reservation, "reservation_type_id")), "6")), equal(text(field(travel_created_reservation, "origin_vendor_name")), travel_hotel)), equal(text(field(travel_created_reservation, "origin_checkin_date")), travel_checkin)), equal(text(field(travel_created_reservation, "return_checkin_date")), travel_checkout)), "The Hotel response differs from the captured ID, Event, type, vendor or dates. Keep pending state and reconcile; do not create another reservation.")
            travel_created_tags = items(field(travel_created_reservation, "tagged_users"))
            require_condition(equal(text(count(travel_created_tags)), "1"), "The Hotel acknowledgement must contain exactly the one selected tag before it can be saved as acknowledged.")
            for travel_created_tag in items(travel_created_tags):
                require_condition(equal(text(field(travel_created_tag, "id")), travel_person_id), "The acknowledged Hotel is tagged to a different person; keep pending state and reconcile.")
            journal_acknowledge(travel_job, "create_travel", {"id": travel_reservation_id, "event_id": travel_event_id, "user_id": travel_person_id})
        travel_final_id = ""
        travel_final_offset = "0"
        travel_final_query = {"filter_by_event_id": travel_event_id, "filter_by_tagged_user_ids": travel_person_id, "$limit": travel_page_size}
        travel_final_query["filter_by_tagged_user_ids_match_type"] = "all"
        while True:
            travel_final_query["$offset"] = travel_final_offset
            travel_final_response = call("travel_readback", travel_final_query, None, None)
            require_condition(equal(response_status(travel_final_response), "200"), "Expected HTTP200 for the current collection; stop and reconcile another response.")
            travel_final_page = travel_final_response["body"]
            travel_final_rows = items(field(travel_final_page, "list_data"))
            require_condition(equal(text(field(travel_final_page, "records_found")), text(count(travel_final_rows))), "records_found differs from this page's rows.")
            require_condition(is_present(text(field(travel_final_page, "total_records"))), "The collection wrapper needs total_records.")
            require_condition(either(equal(field(travel_final_page, "has_more"), True), equal(field(travel_final_page, "has_more"), False)), "Expected a Boolean has_more value.")
            for travel_final_record in items(travel_final_rows):
                travel_final_record_id = positive_id(text(field(travel_final_record, "id")))
                require_condition(equal(text(field(travel_final_record, "event_id")), travel_event_id), "A selected collection returned a row from another Event.")
                travel_final_person_found = ""
                travel_final_tags = items(field(travel_final_record, "tagged_users"))
                for travel_final_tag in items(travel_final_tags):
                    if equal(text(field(travel_final_tag, "id")), travel_person_id):
                        travel_final_person_found = "true"
                require_condition(equal(travel_final_person_found, "true"), "The all-tags filter returned a record without the selected person.")
                if equal(travel_final_record_id, travel_reservation_id):
                    require_condition(both(both(both(both(both(equal(text(field(travel_final_record, "id")), travel_reservation_id), equal(text(field(travel_final_record, "event_id")), travel_event_id)), equal(text(field(travel_final_record, "reservation_type_id")), "6")), equal(text(field(travel_final_record, "origin_vendor_name")), travel_hotel)), equal(text(field(travel_final_record, "origin_checkin_date")), travel_checkin)), equal(text(field(travel_final_record, "return_checkin_date")), travel_checkout)), "The Hotel response differs from the captured ID, Event, type, vendor or dates. Keep pending state and reconcile; do not create another reservation.")
                    require_condition(equal(text(count(travel_final_tags)), "1"), "The captured Hotel's tags changed; review them instead of silently restoring the original selection.")
                    travel_final_id = travel_final_record_id
            if equal(field(travel_final_page, "has_more"), False):
                break
            require_condition(not_value(is_empty(travel_final_rows)), "An empty page says has_more=true. Stop and reconcile the selected query.")
            travel_final_offset = add_offset(travel_final_offset, count(travel_final_rows))
        require_condition(equal(travel_final_id, travel_reservation_id), "The captured Hotel is missing from the complete current Event/person Travel list. Reconcile it; do not repeat the create or delete records automatically.")
        print_value({"event_id": travel_event_id, "user_id": travel_person_id, "staff_id": travel_staff_id, "travel_reservation_id": travel_reservation_id})
    finally:
        travel_job.close()


if __name__ == "__main__":
    main()

EXHIBITDAY_PY

Example response

{
  "list_type": "travel_reservation",
  "list_data": [
    {
      "id": 3001,
      "event_id": 12345,
      "event_name": "Spring Expo 2030",
      "reservation_type_id": 6,
      "booking_status_id": null,
      "book_by_date": null,
      "date_booked": null,
      "booking_url": null,
      "cancellation_instructions": null,
      "vehicle_drop_off_location": null,
      "reservation_number": null,
      "origin_vendor_name": "Spring Expo Conference Hotel",
      "origin_flight_number": null,
      "origin_reservation_item_info": null,
      "origin_checkin_location": null,
      "origin_checkin_date": "2030-01-14",
      "origin_checkin_time": null,
      "origin_reservation_details": null,
      "origin_destination_location": null,
      "origin_destination_date": null,
      "origin_destination_time": null,
      "origin_reservation_final_details": null,
      "return_vendor_name": null,
      "return_flight_number": null,
      "return_reservation_item_info": null,
      "return_checkin_location": null,
      "return_checkin_date": "2030-01-17",
      "return_checkin_time": null,
      "return_reservation_details": null,
      "return_destination_location": null,
      "return_destination_date": null,
      "return_destination_time": null,
      "return_reservation_final_details": null,
      "origin_vendor_address": null,
      "notes": "",
      "payment_status_id": 0,
      "payment_due_date": null,
      "next_payment_due_date": null,
      "payment_notes": null,
      "invoice_attachment": null,
      "reservation_type": "Hotel",
      "reservation_group": "Lodging",
      "booking_status": "Not Specified",
      "payment_status": {
        "id": 0,
        "name": "N/A"
      },
      "cost": {
        "amount": 0.00,
        "cost_center_breakdown": []
      },
      "tagged_users": [
        {
          "id": "f45d4ec2-6d33-4c86-a516-459d21060001",
          "first_name": "Alex",
          "last_name": "Morgan",
          "display_name": "Alex Morgan",
          "email": "alex@example.invalid",
          "type": "user",
          "workspace_role": "team_member",
          "is_active": true
        }
      ],
      "created_by": {
        "id": null,
        "first_name": "ExhibitDay",
        "last_name": "API",
        "display_name": "ExhibitDay API",
        "email": null,
        "type": null,
        "workspace_role": null,
        "is_active": true
      }
    }
  ],
  "records_found": 1,
  "total_records": 1,
  "has_more": false
}
Note: Verified Hotel reservation. The final Travel page contains the captured Hotel ID after separate Staff and Travel creates. The console prints only the captured IDs; this is the complete API response body.

Things to keep in mind

  • If the Event's Staff or Travel tab is hidden or locked, adding or changing these records returns HTTP 400 (not_allowed), and the message names the tab. Show or unlock the tab in ExhibitDay first.
  • This example saves the registration type Conference pass. To use a different registration label, change it consistently in the request, its check and its fingerprint.
  • New assignments require an eligible active member or Resource. Stored assignments can still match filters after a person becomes inactive or is removed.
  • Staff can match one or more person IDs. Travel can match any or all selected tags.
  • Keep the same filters on every page. Other changes to the list can move rows between requests.

If a run stops

  • Keep the journal private. It records what the program tried to save and which save it confirmed.
  • To continue a run with no unresolved save, use EXHIBITDAY_JOB_MODE=resume with the same job ID, journal path and inputs.
  • Each save is separate. The Staff registration can remain if the Travel save stops.
  • A resumed run skips creates the journal already checked and verifies the saved records.
  • If a save stops with a lost response or the record has changed, check the Event before running the program again.
  • If you still need a change after checking the old run, use EXHIBITDAY_JOB_MODE=new with a new job ID and journal path.
  • Run only one copy per journal.
  • If a crash leaves a .lock file, make sure no copy using that journal is running or can start. Then remove the lock file and keep the journal.