seatsio 65.3.0 → 66.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "seatsio",
-  "version": "65.3.0",
+  "version": "66.0.0",
   "main": "index.js",
   "description": "Official JavaScript and Node.JS client library for the Seats.io REST API",
   "license": "MIT",
@@ -14,13 +14,13 @@
     "url": "https://github.com/seatsio/seatsio-js"
   },
   "dependencies": {
-    "axios": "0.24.0"
+    "axios": "0.25.0"
   },
   "devDependencies": {
     "browserify": "latest",
     "eslint": "7.32.0",
     "eslint-config-standard": "16.0.3",
-    "eslint-plugin-import": "2.25.3",
+    "eslint-plugin-import": "2.25.4",
     "eslint-plugin-node": "11.1.0",
     "eslint-plugin-promise": "6.0.0",
     "eslint-plugin-standard": "5.0.0",
@@ -30,8 +30,8 @@
     "gulp-tap": "latest",
     "gulp-uglify": "latest",
     "gulp-uglify-es": "latest",
-    "jest": "27.4.5",
-    "jest-cli": "27.4.5",
+    "jest": "27.4.7",
+    "jest-cli": "27.4.7",
     "uuid": "8.3.2"
   }
 }

package/src/AsyncIterator.js

@@ -5,6 +5,7 @@ const Event = require('./Events/Event.js')
 const User = require('./Users/User.js')
 const Subaccount = require('./Subaccounts/Subaccount.js')
 const Workspace = require('./Workspaces/Workspace.js')
+const Season = require('./Seasons/Season')
 
 class AsyncIterator {
     /**
@@ -45,6 +46,16 @@ class AsyncIterator {
         this.pages.push(new Page(events, data.next_page_starts_after, data.previous_page_ends_before))
     }
 
+    seasons (data) {
+        const seasons = []
+        data.items.forEach(seasonData => {
+            const season = new Season(seasonData)
+            this.items.push(season)
+            seasons.push(season)
+        })
+        this.pages.push(new Page(seasons, data.next_page_starts_after, data.previous_page_ends_before))
+    }
+
     statusChanges (data) {
         const statusChanges = []
         data.items.forEach((statusData) => {
@@ -102,6 +113,9 @@ class AsyncIterator {
                 case 'events':
                     this.events(res.data)
                     break
+                case 'seasons':
+                    this.seasons(res.data)
+                    break
                 case 'statusChanges':
                     this.statusChanges(res.data)
                     break

package/src/Events/StatusChange.js

@@ -13,6 +13,8 @@ class StatusChange {
         this.extraData = statusChange.extraData ? statusChange.extraData : null
         this.holdToken = statusChange.holdToken ? statusChange.holdToken : null
         this.origin = statusChange.origin
+        this.isPresentOnChart = statusChange.isPresentOnChart
+        this.displayedLabel = statusChange.displayedLabel ? statusChange.displayedLabel : null
     }
 }
 

package/src/Seasons/Season.js

@@ -0,0 +1,16 @@
+const Event = require('../Events/Event.js')
+
+class Season {
+    /**
+     * @param {object} season
+     */
+    constructor (season) {
+        this.id = season.id
+        this.key = season.key
+        this.seasonEvent = new Event(season.seasonEvent)
+        this.partialSeasonKeys = season.partialSeasonKeys
+        this.events = season.events.map(e => new Event(e))
+    }
+}
+
+module.exports = Season

package/src/Seasons/SeasonParams.js

@@ -0,0 +1,28 @@
+class SeasonParams {
+    key (key) {
+        this._key = key
+        return this
+    }
+
+    numberOfEvents (numberOfEvents) {
+        this._numberOfEvents = numberOfEvents
+        return this
+    }
+
+    eventKeys (eventKeys) {
+        this._eventKeys = eventKeys
+        return this
+    }
+
+    tableBookingConfig (tableBookingConfig) {
+        this._tableBookingConfig = tableBookingConfig
+        return this
+    }
+
+    socialDistancingRulesetKey (socialDistancingRulesetKey) {
+        this._socialDistancingRulesetKey = socialDistancingRulesetKey
+        return this
+    }
+}
+
+module.exports = SeasonParams

package/src/Seasons/Seasons.js

@@ -0,0 +1,194 @@
+const Page = require('../Page.js')
+const Lister = require('../Lister.js')
+const Season = require('./Season')
+
+class Seasons {
+    /**
+     * @param {SeatsioClient} client
+     */
+    constructor (client) {
+        this.client = client
+    }
+
+    /**
+     * @param {string} chartKey
+     * @param {?seasonParams} SeasonParams
+     * @returns {Promise<Season>}
+     */
+    create (chartKey, seasonParams = null) {
+        const requestParameters = {}
+
+        requestParameters.chartKey = chartKey
+
+        if (seasonParams !== null) {
+            if (seasonParams._key !== null) {
+                requestParameters.key = seasonParams._key
+            }
+
+            if (seasonParams._numberOfEvents !== null) {
+                requestParameters.numberOfEvents = seasonParams._numberOfEvents
+            }
+
+            if (seasonParams._eventKeys !== null) {
+                requestParameters.eventKeys = seasonParams._eventKeys
+            }
+
+            if (seasonParams._tableBookingConfig !== null) {
+                requestParameters.tableBookingConfig = seasonParams._tableBookingConfig
+            }
+
+            if (seasonParams._socialDistancingRulesetKey !== null) {
+                requestParameters.socialDistancingRulesetKey = seasonParams._socialDistancingRulesetKey
+            }
+        }
+
+        return this.client.post('/seasons', requestParameters)
+            .then((res) => new Season(res.data))
+    }
+
+    /**
+     * @param {string} topLevelSeasonKey
+     * @param {?string} partialSeasonKey
+     * @param {?string[]} eventKeys
+     * @returns {Promise<Season>}
+     */
+    createPartialSeason (topLevelSeasonKey, partialSeasonKey = null, eventKeys = null) {
+        const requestParameters = {}
+
+        if (partialSeasonKey !== null) {
+            requestParameters.key = partialSeasonKey
+        }
+
+        if (eventKeys !== null) {
+            requestParameters.eventKeys = eventKeys
+        }
+        return this.client.post(`/seasons/${encodeURIComponent(topLevelSeasonKey)}/partial-seasons`, requestParameters)
+            .then((res) => new Season(res.data))
+    }
+
+    /**
+     * @param {string} key
+     * @returns {Promise<Season>}
+     */
+    retrieve (key) {
+        return this.client.get(`/seasons/${encodeURIComponent(key)}`)
+            .then((res) => new Season(res.data))
+    }
+
+    /**
+     * @param {string} topLevelSeasonKey
+     * @param {?string} partialSeasonKey
+     * @returns {Promise<Season>}
+     */
+    retrievePartialSeason (topLevelSeasonKey, partialSeasonKey) {
+        return this.client.get(`/seasons/${encodeURIComponent(topLevelSeasonKey)}/partial-seasons/${encodeURIComponent(partialSeasonKey)}`)
+            .then((res) => new Season(res.data))
+    }
+
+    /**
+     * @param {string} key
+     * @param {?number} numberOfEvents
+     * @param {?string[]} eventKeys
+     * @returns {Promise<Season>}
+     */
+    createEvents (key, numberOfEvents = null, eventKeys = null) {
+        const requestParameters = { }
+
+        if (numberOfEvents !== null) {
+            requestParameters.numberOfEvents = numberOfEvents
+        }
+
+        if (eventKeys !== null) {
+            requestParameters.eventKeys = eventKeys
+        }
+
+        return this.client.post(`/seasons/${encodeURIComponent(key)}/actions/create-events`, requestParameters)
+            .then((res) => new Season(res.data))
+    }
+
+    /**
+     * @param {string} topLevelSeasonKey
+     * @param {string} partialSeasonKey
+     * @param {string[]} eventKeys
+     * @returns {Promise<Season>}
+     */
+    addEventsToPartialSeason (topLevelSeasonKey, partialSeasonKey, eventKeys) {
+        const requestParameters = { eventKeys }
+        return this.client.post(`/seasons/${encodeURIComponent(topLevelSeasonKey)}/partial-seasons/${encodeURIComponent(partialSeasonKey)}/actions/add-events`, requestParameters)
+            .then((res) => new Season(res.data))
+    }
+
+    /**
+     * @param {string} key
+     * @returns {Promise}
+     */
+    delete (key) {
+        return this.client.delete(`/seasons/${encodeURIComponent(key)}`)
+    }
+
+    /**
+     * @param {string} topLevelSeasonKey
+     * @param {string} partialSeasonKey
+     * @returns {Promise<void>}
+     */
+    deletePartialSeason (topLevelSeasonKey, partialSeasonKey) {
+        return this.client.delete(`/seasons/${encodeURIComponent(topLevelSeasonKey)}/partial-seasons/${encodeURIComponent(partialSeasonKey)}`)
+    }
+
+    /**
+     * @param {string} topLevelSeasonKey
+     * @param {string} partialSeasonKey
+     * @param {string} eventKey
+     * @returns {Promise<Season>}
+     */
+    async removeEventFromPartialSeason (topLevelSeasonKey, partialSeasonKey, eventKey) {
+        return this.client.delete(`/seasons/${encodeURIComponent(topLevelSeasonKey)}/partial-seasons/${encodeURIComponent(partialSeasonKey)}/events/${encodeURIComponent(eventKey)}`)
+            .then((res) => new Season(res.data))
+    }
+
+    /**
+     * @param {?object} requestParameters
+     * @returns {AsyncIterator<Season>}
+     */
+    listAll (requestParameters = {}) {
+        return this.iterator().all(requestParameters)
+    }
+
+    /**
+     * @param {?number} pageSize
+     * @returns {Page<Season>}
+     */
+    listFirstPage (pageSize = null) {
+        return this.iterator().firstPage(null, pageSize)
+    }
+
+    /**
+     * @param {?string} afterId
+     * @param {?number} pageSize
+     * @returns {Page<Season>}
+     */
+    listPageAfter (afterId, pageSize = null) {
+        return this.iterator().pageAfter(afterId, null, pageSize)
+    }
+
+    /**
+     * @param {?string} beforeId
+     * @param {?number} pageSize
+     * @returns {Page<Season>}
+     */
+    listPageBefore (beforeId, pageSize = null) {
+        return this.iterator().pageBefore(beforeId, null, pageSize)
+    }
+
+    /**
+     * @returns {Lister}
+     */
+    iterator () {
+        return new Lister('/seasons', this.client, 'seasons', (data) => {
+            const seasons = data.items.map(seasonData => new Season(seasonData))
+            return new Page(seasons, data.next_page_starts_after, data.previous_page_ends_before)
+        })
+    }
+}
+
+module.exports = Seasons

package/src/SeatsioClient.js

@@ -11,6 +11,7 @@ const EventReports = require('./Reports/EventReports.js')
 const UsageReports = require('./Reports/UsageReports.js')
 const errorResponseHandler = require('./errorInterceptor.js')
 const Axios = require('axios')
+const Seasons = require('./Seasons/Seasons')
 
 class SeatsioClient {
     constructor (region, secretKey, workspaceKey = null, extraHeaders = {}) {
@@ -32,6 +33,7 @@ class SeatsioClient {
         this.chartReports = new ChartReports(this.client)
         this.eventReports = new EventReports(this.client)
         this.usageReports = new UsageReports(this.client)
+        this.seasons = new Seasons(this.client)
     }
 
     _axiosConfig (baseUrl, secretKey, workspaceKey, extraHeaders) {

package/tests/events/listAllStatusChanges.test.js

@@ -174,6 +174,8 @@ test('properties of status changes', async () => {
     expect(statusChange.value.eventId).toBe(event.id)
     expect(statusChange.value.extraData).toEqual({ foo: 'bar' })
     expect(statusChange.value.origin.type).toBe('API_CALL')
+    expect(statusChange.value.displayedLabel).toBe('A-1')
+    expect(statusChange.value.isPresentOnChart).toBe(true)
 })
 
 test('should list status changes with hold token', async () => {

package/tests/seasons/addEventsToPartialSeason.test.js

@@ -0,0 +1,13 @@
+const testUtils = require('../testUtils.js')
+const SeasonParams = require('../../src/Seasons/SeasonParams')
+
+test('add events to partial season', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+    const season = await client.seasons.create(chart.key, new SeasonParams().eventKeys(['event1', 'event2']))
+    const partialSeason = await client.seasons.createPartialSeason(season.key)
+
+    const updatedPartialSeason = await client.seasons.addEventsToPartialSeason(season.key, partialSeason.key, ['event1', 'event2'])
+
+    expect(updatedPartialSeason.events.map(e => e.key)).toEqual(['event1', 'event2'])
+})

package/tests/seasons/createEventsInSeason.test.js

@@ -0,0 +1,21 @@
+const testUtils = require('../testUtils.js')
+
+test('create events in season by event keys', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+    const season = await client.seasons.create(chart.key)
+
+    const updatedSeason = await client.seasons.createEvents(season.key, null, ['event1', 'event2'])
+
+    expect(updatedSeason.events.map(e => e.key)).toEqual(['event1', 'event2'])
+})
+
+test('create events in season by number of events', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+    const season = await client.seasons.create(chart.key)
+
+    const updatedSeason = await client.seasons.createEvents(season.key, 2)
+
+    expect(updatedSeason.events.length).toBe(2)
+})

package/tests/seasons/createPartialSeason.test.js

@@ -0,0 +1,22 @@
+const testUtils = require('../testUtils.js')
+const SeasonParams = require('../../src/Seasons/SeasonParams')
+
+test('key can be passed in', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+    const season = await client.seasons.create(chart.key)
+
+    const partialSeason = await client.seasons.createPartialSeason(season.key, 'aPartialSeason')
+
+    expect(partialSeason.key).toBe('aPartialSeason')
+})
+
+test('event keys can be passed in', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+    const season = await client.seasons.create(chart.key, new SeasonParams().eventKeys(['event1', 'event2']))
+
+    const partialSeason = await client.seasons.createPartialSeason(season.key, null, ['event1', 'event2'])
+
+    expect(partialSeason.events.map(event => event.key)).toEqual(['event1', 'event2'])
+})

package/tests/seasons/createSeason.test.js

@@ -0,0 +1,76 @@
+const testUtils = require('../testUtils.js')
+const SocialDistancingRuleset = require('../../src/Charts/SocialDistancingRuleset.js')
+const TableBookingConfig = require('../../src/Events/TableBookingConfig')
+const SeasonParams = require('../../src/Seasons/SeasonParams')
+
+test('chart key is required', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+
+    const season = await client.seasons.create(chartKey)
+
+    expect(season.key).toBeTruthy()
+    expect(season.id).toBeTruthy()
+    expect(season.partialSeasonKeys.length).toBe(0)
+    expect(season.events.length).toBe(0)
+
+    const seasonEvent = season.seasonEvent
+    expect(seasonEvent.id).toBeTruthy()
+    expect(seasonEvent.key).toBe(season.key)
+    expect(seasonEvent.chartKey).toBe(chartKey)
+    expect(seasonEvent.tableBookingConfig).toEqual(TableBookingConfig.inherit())
+    expect(seasonEvent.supportsBestAvailable).toBe(true)
+    expect(seasonEvent.createdOn).toBeInstanceOf(Date)
+    expect(seasonEvent.forSaleConfig).toBeFalsy()
+    expect(seasonEvent.updatedOn).toBeFalsy()
+})
+
+test('key can be passed in', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+
+    const season = await client.seasons.create(chart.key, new SeasonParams().key('aSeason'))
+
+    expect(season.key).toBe('aSeason')
+})
+
+test('number of events can be passed in', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+
+    const season = await client.seasons.create(chart.key, new SeasonParams().numberOfEvents(2))
+
+    expect(season.events.length).toBe(2)
+})
+
+test('event keys can be passed in', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+
+    const season = await client.seasons.create(chart.key, new SeasonParams().eventKeys(['event1', 'event2']))
+
+    expect(season.events.map(event => event.key)).toEqual(['event1', 'event2'])
+})
+
+test('table booking config can be passed in', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChartWithTables(chartKey, user.secretKey)
+    const tableBookingConfig = TableBookingConfig.custom({ T1: 'BY_TABLE', T2: 'BY_SEAT' })
+
+    const season = await client.seasons.create(chartKey, new SeasonParams().tableBookingConfig(tableBookingConfig))
+
+    expect(season.seasonEvent.tableBookingConfig).toEqual(tableBookingConfig)
+})
+
+test('social distancing ruleset key can be passed in', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+    const rulesets = { ruleset1: SocialDistancingRuleset.ruleBased('My ruleset').build() }
+    await client.charts.saveSocialDistancingRulesets(chart.key, rulesets)
+
+    const season = await client.seasons.create(chart.key, new SeasonParams().socialDistancingRulesetKey('ruleset1'))
+
+    expect(season.seasonEvent.socialDistancingRulesetKey).toBe('ruleset1')
+})

package/tests/seasons/deletePartialSeason.test.js

@@ -0,0 +1,18 @@
+const testUtils = require('../testUtils.js')
+
+test('delete partial season', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+    const season = await client.seasons.create(chartKey)
+    const partialSeason = await client.seasons.createPartialSeason(season.key)
+
+    await client.seasons.deletePartialSeason(season.key, partialSeason.key)
+
+    try {
+        await client.seasons.retrievePartialSeason(season.key, partialSeason.key)
+        throw new Error('Should have failed')
+    } catch (e) {
+        expect(e.errors[0].code).toBe('SEASON_NOT_FOUND')
+    }
+})

package/tests/seasons/deleteSeason.test.js

@@ -0,0 +1,17 @@
+const testUtils = require('../testUtils.js')
+
+test('delete season', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+    const season = await client.seasons.create(chartKey)
+
+    await client.seasons.delete(season.key)
+
+    try {
+        await client.seasons.retrieve(season.key)
+        throw new Error('Should have failed')
+    } catch (e) {
+        expect(e.errors[0].code).toBe('SEASON_NOT_FOUND')
+    }
+})

package/tests/seasons/listAllSeasons.test.js

@@ -0,0 +1,16 @@
+const testUtils = require('../testUtils.js')
+
+test('list all seasons', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+    const season1 = await client.seasons.create(chart.key)
+    const season2 = await client.seasons.create(chart.key)
+    const season3 = await client.seasons.create(chart.key)
+
+    const retrievedSeasonKeys = []
+    for await (const season of client.seasons.listAll()) {
+        retrievedSeasonKeys.push(season.key)
+    }
+
+    expect(retrievedSeasonKeys).toEqual([season3.key, season2.key, season1.key])
+})

package/tests/seasons/removeEventsFromPartialSeason.test.js

@@ -0,0 +1,13 @@
+const testUtils = require('../testUtils.js')
+const SeasonParams = require('../../src/Seasons/SeasonParams')
+
+test('add events to partial season', async () => {
+    const { client } = await testUtils.createTestUserAndClient()
+    const chart = await client.charts.create()
+    const season = await client.seasons.create(chart.key, new SeasonParams().eventKeys(['event1', 'event2']))
+    const partialSeason = await client.seasons.createPartialSeason(season.key, null, ['event1', 'event2'])
+
+    const updatedPartialSeason = await client.seasons.removeEventFromPartialSeason(season.key, partialSeason.key, 'event2')
+
+    expect(updatedPartialSeason.events.map(e => e.key)).toEqual(['event1'])
+})

package/tests/seasons/retrievePartialSeason.test.js

@@ -0,0 +1,25 @@
+const testUtils = require('../testUtils.js')
+const TableBookingConfig = require('../../src/Events/TableBookingConfig')
+
+test('retrieve partial season', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+    const season = await client.seasons.create(chartKey)
+    const partialSeason = await client.seasons.createPartialSeason(season.key)
+
+    const retrievedPartialSeason = await client.seasons.retrievePartialSeason(season.key, partialSeason.key)
+
+    expect(retrievedPartialSeason.key).toBe(partialSeason.key)
+    expect(retrievedPartialSeason.id).toBeTruthy()
+
+    const seasonEvent = retrievedPartialSeason.seasonEvent
+    expect(seasonEvent.id).toBeTruthy()
+    expect(seasonEvent.key).toBe(retrievedPartialSeason.key)
+    expect(seasonEvent.chartKey).toBe(chartKey)
+    expect(seasonEvent.tableBookingConfig).toEqual(TableBookingConfig.inherit())
+    expect(seasonEvent.supportsBestAvailable).toBe(true)
+    expect(seasonEvent.createdOn).toBeInstanceOf(Date)
+    expect(seasonEvent.forSaleConfig).toBeFalsy()
+    expect(seasonEvent.updatedOn).toBeFalsy()
+})

package/tests/seasons/retrieveSeason.test.js

@@ -0,0 +1,29 @@
+const testUtils = require('../testUtils.js')
+const TableBookingConfig = require('../../src/Events/TableBookingConfig')
+const SeasonParams = require('../../src/Seasons/SeasonParams')
+
+test('retrieve season', async () => {
+    const { client, user } = await testUtils.createTestUserAndClient()
+    const chartKey = testUtils.getChartKey()
+    await testUtils.createTestChart(chartKey, user.secretKey)
+    const season = await client.seasons.create(chartKey, new SeasonParams().eventKeys(['event1', 'event2']))
+    const partialSeason1 = await client.seasons.createPartialSeason(season.key)
+    const partialSeason2 = await client.seasons.createPartialSeason(season.key)
+
+    const retrievedSeason = await client.seasons.retrieve(season.key)
+
+    expect(retrievedSeason.key).toBeTruthy()
+    expect(retrievedSeason.id).toBeTruthy()
+    expect(retrievedSeason.partialSeasonKeys).toEqual([partialSeason1.key, partialSeason2.key])
+    expect(retrievedSeason.events.map(e => e.key)).toEqual(['event1', 'event2'])
+
+    const seasonEvent = retrievedSeason.seasonEvent
+    expect(seasonEvent.id).toBeTruthy()
+    expect(seasonEvent.key).toBe(retrievedSeason.key)
+    expect(seasonEvent.chartKey).toBe(chartKey)
+    expect(seasonEvent.tableBookingConfig).toEqual(TableBookingConfig.inherit())
+    expect(seasonEvent.supportsBestAvailable).toBe(true)
+    expect(seasonEvent.createdOn).toBeInstanceOf(Date)
+    expect(seasonEvent.forSaleConfig).toBeFalsy()
+    expect(seasonEvent.updatedOn).toBeFalsy()
+})