Skip to main content

Node.js Library

Welcome to the Gumband Node.js SDK. This library is broken up into different modules for different feature areas.

Configuration Options​

SDK Configuration Options

Here is a list of the configuration options that the SDK constructor takes as parameters:

Node Application
constructor (token: string, exhibitId: number, manifest: string | Object, options? = {
    endpoint: string,
    customServerIP: string,
    contentLocation: string,
    version: string,
    noInternetConnection: boolean,
    allowOnlyCloudHardwareIds: boolean,
    allowedHardwareIds: number[],
    useLocalMQTTBroker: boolean,
    MQTTBrokerIP: string,
    MQTTBrokerPort: number,
    skipOrganizationFileSync: boolean
})
argtypedescription
exhibit_idnumberThe ID of the exhibit in Gumband. This can be found under the Exhibit/Auth tab in the Gumband UI. This is required to authenticate the SDK with Gumband.
tokenstringThe exhibit token generated through the Exhibit/Auth tab in the Gumband UI. This is required to authenticate the SDK with Gumband.
manifeststring | objectA path to a json file of the manifest, or a dictionary of the manifest object. See the Exhibit Manifest Configuration docs for how to structure the manifest object. (default: {})
[options]GumbandOptionsConfiguration options (default: {})

Optional parameters provided through GumbandOptions:

argtypedescription
endpointstringThe environment your exhibit is connected to, such as 'app' or 'custom' (default: 'app'). This should almost always be "app"
customServerIPstringCustom server IP to connect to if you are not connecting to app.gumband.com.
contentLocationstringThe path to local content storage directory to where files uploaded to the Gumband UI will sync. Without this configuration option, the SDK will not sync down files (default: null).
versionstringThe version of the Gumband Cloud to which the exhibit should connect. Set to “v1” by default.
noInternetConnectionbooleanTells the SDK that the exhibit is expected to be disconnected from the internet, and should not attempt to authenticate with Gumband.
allowOnlyCloudHardwareIdsbooleanTells the SDK only to accept messages from hardware associated with the same exhibit as the SDK in the Gumband UI.
allowedHardwareIdsnumber[]A whitelist of hardware IDs. The SDK is only permitted to process messages from hardware IDs on this whitelist. By default, messages from all hardware IDs are permitted.
useLocalMQTTBrokerbooleanWhether a local MQTT broker should be started when the SDK is initialized. This MQTT broker is used to communicate with the Gumband HDK.
MQTTBrokerIPstringAn alternative to the useLocalMQTTBroker option where instead of having the Gumband SDK manage an MQTT broker, you define an IP for a provided MQTT broker. The SDK will attempt to open an MQTT client connection to this IP and the port from the MQTTBrokerPort option.
MQTTBrokerPortnumberThis option is the port that the local MQTT broker is exposed on, or the port that the SDK should attempt to connect to if running a third part MQTT broker.
skipOrganizationFileSyncbooleanSet to true by default. Tells the SDK not to download all organization files along with the exhibit files when the “contentLocation” option is provided. Exhibit files are only accessible by the exhibit under the Exhibit/Files tab in the Gumband UI, but organization files are available to all exhibits under the organization and can be seen under each exhibits' Files tab. Organization/Workspace files are prefixed by “[ORG]” and are managed by the Strapi CMS.

SDK Base Function Library​

isReady​

isReady(): boolean

Returns true if Gumband is connected to the Gumband Cloud and is ready to process requests.

setManifest​

setManifest(manifestLocation: string): Promise<void>

Use a local manifest submit the defined status, controls, and settings to the gumband cloud. This will configure the status, controls, and settings in the Gumband UI.

Node Application
await gumbandSDK.setManifest('./path/to/manifest.json');

getOperatingMode​

note

Deprecated

getOperatingMode(): Promise<boolean>

Get the current operating mode for the exhibit from Gumband.

Node Application
let operatingMode = await gumbandSDK.getOperatingMode();

console.log(`Operating Mode: ${operatingMode}`);
// Operating Mode: true

setOperatingMode​

note

Deprecated

setOperatingMode(opMode: boolean): Promise<void>

Set the operating mode for the exhibit in Gumband.

opMode: The target operating mode.

Node Application
await gumbandSDK.setOperatingMode(true);

getStatus​

getStatus(statusName: string): Promise<string>

Get the value of a status from Gumband.

statusName: The “id” field of the status in the manifest.

Node Application
let statusValue = await gumbandSDK.getStatus('cpu-usage');

console.log(`CPU Usage: ${statusValue}`);
// CPU Usage: 50%

setStatus​

setStatus(statusName: string, value: string): Promise<void>

Set the value of a status in Gumband.

statusName: The “id” field of the status in the manifest.

value: The target value to which the status should be set.

Node Application
await gumbandSDK.setStatus('cpu-usage', "50%");

getSetting​

getSetting(manifestId: string): Promise<string>

Get the value of a setting from Gumband.

manifestId: The “id” field of the setting in the manifest.

Node Application
let motorRPM = await gumbandSDK.getSetting('motor-rpm');

console.log(`Motor RPM: ${motorRPM}`);
// Motor RPM: 30

setSetting​

setSetting(settingName: string, value: string): Promise<void>

Set the value of a setting in Gumband.

settingName: The “id” field of the setting in the manifest.

value: The target value to which the setting should be set.

Node Application
await gumbandSDK.setSetting('motor-rpm', '30');

getAllSettings​

getAllSettings(): Promise<Map<Setting>>

Get all settings as a map, where the key is the “id” field of each setting in the manifest.

Node Application
console.log(await gumbandSDK.getAllSettings());
//{
//  'motor-rpm': {
//    id: 14,
//    manifestId: 'motor-rpm',
//    exhibitId: 1,
//    type: 'IntegerInput',
//    display: 'Motor RPM',
//    enabledOpMode: null,
//    value: 30,
//    default: 0,
//    order: 0,
//    touchless: null,
//    listId: null,
//    groupId: null,
//    read: true,
//    write: true
//  }
//}

getAllSettingLists​

getAllSettingLists(): Promise<SettingList[]>

Get all setting lists in the manifest as an array.

Node Application
console.log(await gumbandSDK.getAllSettingLists());
//[
//  {
//    id: 1,
//    exhibitId: 1,
//    manifestId: 'my-list',
//    listDisplay: 'List Label',
//    listParent: null,
//    schema: [ [Object], [Object] ],
//    listItemCount: 1,
//    order: [ 'item 1' ],
//    orderSelf: null,
//    groupId: null,
//    settinglistitems: [ [Object] ],
//    type: 'SettingsList'
//  }
//]

getOnlineHardware​

getOnlineHardware(): Hardware[]

Get the list of Gumband Hardware that are currently connected to the SDK.

Node Application
console.log(gumbandSDK.getOnlineHardware());
//[
//  {
//    hardwareId: 83,
//    name: 'Gumband SDK Tutorial',
//    peripherals: { Button: [Object], LED: [Object] }
//  }
//]

Exhibit Module​

exhibit.getManifest​

exhibit.getManifest(): Promise<Manifest>

Get the full manifest of this exhibit from Gumband. This will include all current values of the statuses and settings.

Node Application
console.log(await gumbandSDK.exhibit.getManifest());
//{
//  manifest: {
//    id: 249,
//    siteId: 34,
//    name: 'Gumband SDK Tutorial',
//    mqttPath: '',
//    online: true,
//    manifestLocked: false,
//    opMode: 'On',
//    settingLists: [],
//    settingGroups: [ [Object], [Object] ],
//    settings: [ [Object] ],
//    statuses: [ [Object], [Object], [Object] ],
//    controls: [ [Object], [Object] ],
//    strapiContent: []
//  }
//}

exhibit.getStrapiContentSetting​

exhibit.getStrapiContentSetting(id: number): Promise<StrapiContent>

Get an exhibit setting with type StrapiContent.

id: The database ID of the StrapiContent.

Hardware Module​

hardware.setProperty​

hardware.setProperty(id: string, topic: string, value: any, options: any): Promise<void>

Set a hardware property to a value.

id: A string of the form ed028e04-41d9-4e77-a5d2-ab4e7346e3a7. This is the hardware ID.

topic: A string of the form ${property}/${path}, which is the name and path to the property that is having its value set.

value: The new value to which the property will be set.

[options.source]: The source of the property. The property source can be either system or app. system properties come on the Gumband Hardware by default, while app properties are created in the user firmware. This value will be set to app by default.

Node Application
//gmbnd_bool property type
await gumbandSDK.hardware.setProperty("ed028e04-41d9-4e77-a5d2-ab4e7346e3a7", "My Property", 1);

hardware.getProperty​

hardware.getProperty(id: string, topic: string): Promise<any>

Get the value of the given property.

id: A string of the form ed028e04-41d9-4e77-a5d2-ab4e7346e3a7. This is the hardware ID.

topic: A string of the form property/path, which is the name and path to the property that is having its value set.

[options.source]: The source of the property. The property source can be either system or app. system properties come on the Gumband Hardware by default, while app properties are created in the user firmware. This value will be set to app by default.

Node Application
//gmbnd_bool property type
console.log(await gumbandSDK.hardware.getProperty("ed028e04-41d9-4e77-a5d2-ab4e7346e3a7", "My Property"));
// 1

hardware.getRegisteredProperties​

hardware.getRegisteredProperties(id: string): Promise<Property[]>

Get all registered properties for a hardware. Will not include values for those properties

id: A string of the form ed028e04-41d9-4e77-a5d2-ab4e7346e3a7. This is the hardware ID.

[options.source]: The source of the property. The property source can be either system or app. system properties come on the Gumband Hardware by default, while app properties are created in the user firmware. This value will be set to app by default.

Node Application
//gmbnd_bool property type
console.log(await gumbandSDK.hardware.getRegisteredProperties("ed028e04-41d9-4e77-a5d2-ab4e7346e3a7"));
// [{
//    path: 'Types/My Bool',
//    desc: '',
//    index: 1,
//    type: 'gmbnd_primitive',
//    format: '!?',
//    length: 1,
//    settable: true,
//    gettable: true,
//    ui_hidden: false
//  }]

hardware.reboot​

hardware.reboot(id: string): Promise<void>

Triggers a reboot of the hardware matching the given ID.

id: A string of the form ed028e04-41d9-4e77-a5d2-ab4e7346e3a7. This is the hardware ID.

Node Application
await gumbandSDK.hardware.reboot("ed028e04-41d9-4e77-a5d2-ab4e7346e3a7");

hardware.identify​

hardware.identify(id: string): Promise<void>

Triggers the hardware matching the given ID to identify itself by flashing its LED.

id: A string of the form ed028e04-41d9-4e77-a5d2-ab4e7346e3a7. This is the hardware ID.

Node Application
await gumbandSDK.hardware.identify("ed028e04-41d9-4e77-a5d2-ab4e7346e3a7");

hardware.getExhibitHardware​

hardware.getExhibitHardware(): Promise<Response<Hardware[]>>

Get all hardware associated with this exhibit in the Gumband UI.

Node Application
console.log(await gumbandSDK.hardware.getExhibitHardware());
//[
//    {
//      id: '782ff2c2-11ef-489f-aa79-d0c229cd4799',
//      exhibitApi: 'v1',
//      exhibitId: 407,
//      name: 'My Hardware',
//      type: 'custom-hardware',
//      connected: false,
//      connectedChangedAt: null,
//      category: 'hardware'
//    }
//]

hardware.sendMqttMessage​

hardware.sendMqttMessage(topic: string, rawPayload): Promise<void>

Sends an MQTT message directly to the hardware with the given topic and rawPayload.

topic: A string of the form ${hardwareId}/${prop}, where hardwareId is the ID of the hardware found under the Hardware/Auth tab in the Gumband UI, and prop is the name of the property that is having its value set.

rawPayload: The raw value to be sent directly by the hardware.

hardware.getAllRegisteredHardware​

hardware.getAllRegisteredHardware(): Promise<Map<Hardware>>

Gets a map of all registered hardware keyed by the hardware id.

Node Application
console.log(await gumbandSDK.hardware.getAllRegisteredHardware());
//[
//  {
//    id: "ed028e04-41d9-4e77-a5d2-ab4e7346e3a7",
//    system: {
//      info: {
//        ...systemInfo
//      },
//      properties: {
//        ...systemProperties
//      }
//    },
//    app: {
//      info: {
//        ...appInfo
//      },
//      properties: {
//        ...appProperties
//      }
//    }
//  }
//]

hardware.getRegisteredHardware​

hardware.getRegisteredHardware(id: string): Promise<Hardware>

Gets a hardware that is registered.

id: A string of the form ed028e04-41d9-4e77-a5d2-ab4e7346e3a7. This is the hardware ID.

Node Application
console.log(await gumbandSDK.hardware.getRegisteredHardware("ed028e04-41d9-4e77-a5d2-ab4e7346e3a7"));
//  {
//    id: "ed028e04-41d9-4e77-a5d2-ab4e7346e3a7",
//    system: {
//      info: {
//        ...systemInfo
//      },
//      properties: {
//        ...systemProperties
//      }
//    },
//    app: {
//      info: {
//        ...appInfo
//      },
//      properties: {
//        ...appProperties
//      }
//    }
//  }

hardware.getIdFromName​

hardware.getIdFromName(name: string): Promise<string>

Gets a hardware ID from the given name.

name: The name of the hardware that the user gave it in the Gumband UI.

Node Application
console.log(await gumbandSDK.hardware.getRegisteredHardware("My Hardware"));
// "ed028e04-41d9-4e77-a5d2-ab4e7346e3a7"

Content Module​

content.getRemoteFileList​

content.getRemoteFileList(): Promise<Response<File[]>

Get a list of all remote file names. These file names will match the files list under the Exhibit/Files tab in the Gumband UI.

Node Application
let remoteFiles = await gumbandSDK.content.getRemoteFileList();

console.log(remoteFiles);
//{
//  response: 'OK',
//  files: [
//    {
//      file: 'gumband-cassette.png',
//      name: 'gumband-cassette.png',
//      hash: 'SlTZJxaq+s5YH4R1KX6wHA==',
//      lastUpdated: '2023-08-14T19:22:08.547Z',
//      size: '81204'
//    }
//  ],
//  errors: []
//}

content.getLocalFileList​

content.getLocalFileList(): File[]

Get a list of all locally saved file names for the exhibit.

Node Application
let localFiles = gumbandSDK.content.getLocalFileList();

console.log(localFiles);
//{
//  files: [
//    {
//      file: 'gumband-cassette.png',
//      name: 'gumband-cassette.png',
//      hash: 'SlTZJxaq+s5YH4R1KX6wHA==',
//      lastUpdated: '2023-08-14T19:22:08.547Z',
//      size: '81204'
//    }
//  ]
//}

content.sync​

content.sync(): Promise<void>

Sync locally saved files with the list of remote files. This is called whenever the SDK makes a connection to Gumband if local files is enabled with the contentLocation configuration option.

Node Application
await gumbandSDK.content.sync();

content.uploadFile​

content.uploadFile(fileStream: ReadStream): Promise<void>

Uploads a file to the list of remote files for the exhibit.

fileStream: A stream of data from a function such as fs.createReadStream("path/to/file").

Node Application
const fileStream = fs.createReadStream("path/to/file");
await gumbandSDK.content.uploadFile(fileStream);

content.downloadFile​

content.downloadFile(file: string): Promise<void>

Downloads the given file name from the remote list of files for the exhibit in Gumband, and saves it in the contentLocation directory (see configuration options) for the locally saved exhibit files. Existing files with the same name will be overwritten.

file: The name of the file.

Node Application
await gumbandSDK.content.downloadFile("gumband-cassette.png");

Log Module​

logger.info​

logger.info(message: string): Promise<void>

The message for the log.

message: Logs a message to Gumband as an "info" level log. Logs can be viewed under the Exhibit/Logs tab in the Gumband UI.

Node Application
await gumbandSDK.logger.info("This is an info log message");

logger.debug​

logger.debug(message: string): Promise<void>

Logs a message to Gumband as an “debug” level log. Logs can be viewed under the Exhibit/Logs tab in the Gumband UI.

message: The message for the log.

Node Application
await gumbandSDK.logger.debug("This is a debug log message");

logger.warn​

logger.warn(message: string): Promise<void>

Logs a message to Gumband as an “warn” level log. Logs can be viewed under the Exhibit/Logs tab in the Gumband UI.

message: The message for the log.

Node Application
await gumbandSDK.logger.warn("This is a warning log message");

logger.error​

logger.error(message: string): Promise<void>

Logs a message to Gumband as an “error” level log. Logs can be viewed under the Exhibit/Logs tab in the Gumband UI.

message: The message for the log.

Node Application
await gumbandSDK.logger.error("This is an error log message");

Metrics Module​

metrics.create​

metrics.create(eventName: string, data: object): void

Creates an analytics event for a given exhibit

eventName: Defines the type of interaction event.

[data]: Optional parameter that defines metadata for the interaction event.

Node Application
gumbandSDK.metrics.create('ButtonPress', { buttonType: 'accept', score: 72, isGameOver: false});

metrics.endInteraction​

metrics.endInteraction(data?: object)

Ends an active interaction for a given exhibit.

gumbandSDK.metrics.endInteraction()

[data]: Optional parameter that defines metadata for the interaction event.

Node Application
gumbandSDK.metrics.endInteraction()

metrics.createConcurrent​

metrics.createConcurrent(eventName: string, data: object, interactionId?: string): string

This method is identical to the create method except that it attaches an interactionId to each event, so Gumband can tell the difference between events for different, concurrent interactions. It will return the generated interactionId so it can be attached to future events for this interaction.

eventName: Defines the type of interaction event.

data: Defines metadata for the interaction event.

[interactionId]: The Id of the user interaction.

Node Application
gumbandSDK.metrics.createConcurrent('ButtonPress', { buttonType: 'accept', score: 72, isGameOver: false}, interactionId);

metrics.endConcurrentInteraction​

metrics.endConcurrentInteraction(data: object, interactionId: string): string

This method is identical to the endInteraction method except that it attaches an interactionId to each event, so Gumband can distinguish between events for distinct, concurrent interactions.

data: Defines metadata for the interaction event.

[interactionId]: The Id of the user interaction.

Node Application
gumbandSDK.metrics.endConcurrentInteraction({}, interactionId);

Notification Module​

notifications.email​

notifications.email(message: string): Promise<void>

Sends a custom email notification through Gumband. Custom email notifications can be subscribed to on an individual user basis under the Exhibit/Notifications tab of the Gumband UI.

message: The message for the custom email notification.

Node Application
await gumbandSDK.notification.email("Your exhibit requires maintenance");

Notification Events​

Whenever an event occurs that your exhibit ought to know about, an event will be emitted from the Gumband class. These events can be a result of configuration changes made through the Gumband UI, a change in the exhibit's websocket connection to Gumband, or any errors that occur within the SDK.

READY​

Emitted after the SDK successfully authenticates with Gumband, comes online, and is ready to make requests to Gumband.

Node Application
gumbandSDK.on(Sockets.READY, (manifest) => {
    console.log(manifest);
    // {
    //     id: 1,
    //     siteId: 1,
    //     name: 'E',
    //     mqttPath: null,
    //     online: true,
    //     manifestLocked: false,
    //     opMode: 'Off',
    //     settingLists: [...],
    //     settingGroups: [...],
    //     settings: [...],
    //     statuses: [...],
    //     controls: [...],
    //     strapiContent: [...]
    // }
});

EXHIBIT_ONLINE​

Emitted when the SDK successfully authenticates with Gumband and comes online.

Node Application
gumbandSDK.on(Sockets.EXHIBIT_ONLINE, () => {
    //no payload for the the Sockets.EXHIBIT_ONLINE event.
});

EXHIBIT_OFFLINE​

Emitted when the SDK losses its websocket connection with Gumband.

Node Application
gumbandSDK.on(Sockets.EXHIBIT_OFFLINE, () => {
    //no payload for the the Sockets.EXHIBIT_OFFLINE event.
});

CONTROL_RECEIVED​

Emitted when a control is triggered, usually through the Exhibit/Controls tab in the Gumband UI.

Node Application
gumbandSDK.on(Sockets.CONTROL_RECEIVED, async (payload) => {
    console.log(payload);
    // {
    //   id: 'control_manifest_id',
    //   touchless: undefined,
    //   sessionId: undefined,
    //   sessionUser: undefined
    // }
});

SETTING_RECEIVED​

Emitted when a setting is changed, usually through the Exhibit/Settings tab in the Gumband UI.

Node Application
gumbandSDK.on(Sockets.SETTING_RECEIVED, (payload) => {
    console.log(payload);
    // {
    //     id: 'setting_manifest_id',
    //     value: 'new value',
    //     touchless: undefined,
    //     sessionId: undefined,
    //     sessionUser: undefined
    // }
});

SETTING_LIST_RECEIVED​

Emitted when a new setting list item is added or deleted, when the setting list items have their order changed, or when a setting within a setting list item is changed. The payload is the new setting list with all of its items.

Node Application
gumbandSDK.on(Sockets.SETTING_LIST_RECEIVED, (payload) => {
    console.log(payload);
    // { 
    //     id: 'setting_list_manifest_id', 
    //     value: [
    //         ...settingListItems
    //     ]
    // }
});

SETTING_LIST_ITEM_DELETED​

Emitted when a setting list item is deleted. The payload is the setting list item that was deleted.

Node Application
gumbandSDK.on(Sockets.SETTING_LIST_ITEM_DELETED, (payload) => {
    console.log(payload);
    // {
    //   "id": "list_manifest_id",
    //   "value": [
    //     {
    //       "id": "deleted_list_item_name",
    //       "value": [ ...listItemValues ]
    //     }
    //   ]
    // }
});

OP_MODE_RECEIVED​

note

Deprecated

Emitted when the Operation Mode is changed, usually through the Exhibit dashboard in the Gumband UI.

Node Application
gumbandSDK.on(Sockets.OP_MODE_RECEIVED, (payload) => {
    console.log(payload);
    // {
    //   value: true
    // }
});

HARDWARE_CONNECTED​

Emitted when a Gumband Hardware connects to the exhibit SDK.

Node Application
gumbandSDK.on(Sockets.HARDWARE_CONNECTED, (payload) => {
    console.log(payload);
    // {
    //   id: "hardware-id"
    // }
});

HARDWARE_DISCONNECTED​

Emitted when a Gumband Hardware disconnects from the exhibit SDK.

Node Application
gumbandSDK.on(Sockets.HARDWARE_DISCONNECTED, (payload) => {
    console.log(payload);
    // {
    //   id: "hardware-id,
    // }
});

HARDWARE_SYSTEM_REGISTERED​

Emitted after a Gumband Hardware connects to and registers its system info/properties with the exhibit SDK.

Node Application
gumbandSDK.on(Sockets.HARDWARE_SYSTEM_REGISTERED, (payload) => {
    console.log(payload);
    //  {
    //    id: "hardware-id",
    //    system: {
    //      info: {
    //        ...systemInfo
    //      },
    //      properties: {
    //        ...systemProperties
    //      }
    //    },
    //    app: {
    //      info: {
    //        ...appInfo
    //      },
    //      properties: {
    //        ...appProperties
    //      }
    //    }
    //  }
});

HARDWARE_APP_REGISTERED​

Emitted when a Gumband Hardware connects to and registers its app info/properties with the exhibit SDK.

Node Application
gumbandSDK.on(Sockets.HARDWARE_APP_REGISTERED, (payload) => {
    console.log(payload);
    //  {
    //    id: "hardware-id",
    //    system: {
    //      info: {
    //        ...systemInfo
    //      },
    //      properties: {
    //        ...systemProperties
    //      }
    //    },
    //    app: {
    //      info: {
    //        ...appInfo
    //      },
    //      properties: {
    //        ...appProperties
    //      }
    //    }
    //  }
});

HARDWARE_FULLY_REGISTERED​

Emitted when a Gumband Hardware connects to and registers its app and system info/properties with the exhibit SDK.

Node Application
gumbandSDK.on(Sockets.HARDWARE_FULLY_REGISTERED, (payload) => {
    console.log(payload);
    //  {
    //    id: "hardware-id",
    //    system: {
    //      info: {
    //        ...systemInfo
    //      },
    //      properties: {
    //        ...systemProperties
    //      }
    //    },
    //    app: {
    //      info: {
    //        ...appInfo
    //      },
    //      properties: {
    //        ...appProperties
    //      }
    //    }
    //  }
});

HARDWARE_SYSTEM_PROPERTY_RECEIVED​

Emitted when a system property is changed in a Gumband Hardware that is connected to the exhibit.

Node Application
gumbandSDK.on(Sockets.HARDWARE_SYSTEM_PROPERTY_RECEIVED, async (payload) => {
    console.log(payload);
    //  {
    //      id: 'hardware-id',
    //      info: {
    //        system: { info: [Object], properties: [Array] },
    //        app: { info: [Object], properties: [Array] }
    //      },
    //      value: [ "myValue" ],
    //      property: 'My Property',
    //      source: 'app'
    //  }
});

HARDWARE_APP_PROPERTY_RECEIVED​

Emitted when an app property is changed in a Gumband Hardware that is connected to the exhibit.

Node Application
gumbandSDK.on(Sockets.HARDWARE_APP_PROPERTY_RECEIVED, async (payload) => {
    console.log(payload);
    //  {
    //      id: 'hardware-id',
    //      info: {
    //        system: { info: [Object], properties: [Array] },
    //        app: { info: [Object], properties: [Array] }
    //      },
    //      value: [ "myValue" ],
    //      property: 'My Property',
    //      source: 'app'
    //  }
});

HARDWARE_PROPERTY_RECEIVED​

Emitted when either a system or app property is changed in a Gumband Hardware that is connected to the exhibit.

Node Application
gumbandSDK.on(Sockets.HARDWARE_PROPERTY_RECEIVED, async (payload) => {
    console.log(payload);
    //  {
    //      id: 'hardware-id',
    //      info: {
    //        system: { info: [Object], properties: [Array] },
    //        app: { info: [Object], properties: [Array] }
    //      },
    //      value: [ "myValue" ],
    //      property: 'My Property',
    //      source: 'app'
    //  }
});

FILE_UPLOADED​

Emitted when a new file has been uploaded to Gumband, usually through the Exhibit/Files tab of the Gumband UI.

Node Application
gumbandSDK.on(Sockets.FILE_UPLOADED, (payload) => {
    console.log(payload);
    // {
    //   file: 'uploadedFileName.png',
    //   size: 7891,
    //   exhibitId: '1',
    //   lastUpdated: '2023-08-28T16:14:54.418Z'
    // }
});

FILE_DELETED​

Emitted when a file is deleted from Gumband, usually through the Exhibit/Files tab of the Gumband UI.

Node Application
gumbandSDK.on(Sockets.FILE_DELETED, (payload) => {
    console.log(payload);
    // { 
    //   file: 'deletedFileName.png'
    // }
});

ERROR​

Emitted when the SDK logs any error is logged to the local logger.

Node Application
gumbandSDK.on(Sockets.ERROR, (payload) => {
    console.log(payload);
    // This is an error message
    // Note: you can forward these errors to the Gumband UI by calling:
    // gumbandSDK.logger.error(payload);
});