seatsio 26.1.0 → 28.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88ee98c7b310f64dc09c357d9f52d18d0438751b35db4c121228a76503b71c3e
-  data.tar.gz: 90211a4df7b4ee70999ef223d07179b5618c99704c94b299c64e174788371be0
+  metadata.gz: aa0f200b52412b29b9e10925637731f803d6dae6145699c5f569a14da079d644
+  data.tar.gz: ae6064a298eb37162405f0368e46182a1e5de890d2d7aef5ecb497ca497fd9da
 SHA512:
-  metadata.gz: 2365ccc24f348c702c3c6fd5605af42db1f22e7d9b4ffbbd179b83f2fe673998f1745cff5a7536f95f7d064150c2c00fbfab9e253b116230744c21f0a5dfa571
-  data.tar.gz: 7d9ae6eeae803f450055262b02cfaaa839d4048a793b0eb72c912558887b708f054b2a047ef10ebe3d9efa022126db464ef1c50227843fd66a26647f900eba9d
+  metadata.gz: 9ebc9a608826fb7d89f7c6c2dc1c98024ba3b20ca027f615d7381776bdc2f29579056ae895303763d6b8d4a48f613959267930a8844e7be037f6dc2f4ee34c95
+  data.tar.gz: ef11128346ddce38465a3e4147519c0c57c69dcba3b67d0acbc31d59329f3715b92f616299a64abb856ac4fc4ac389af52bada3a566ed541f8c9da3ece49aaa2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    seatsio (26.1.0)
+    seatsio (28.2.0)
 
 GEM
   remote: https://rubygems.org/

data/lib/seatsio/chart_reports.rb

@@ -10,24 +10,25 @@ module Seatsio
       @http_client = ::Seatsio::HttpClient.new(secret_key, workspace_key, base_url)
     end
 
-    def by_label(chart_key)
-      get_chart_report('byLabel', chart_key)
+    def by_label(chart_key, book_whole_tables = nil)
+      get_chart_report('byLabel', chart_key, book_whole_tables)
     end
 
-    def by_category_key(chart_key)
-      get_chart_report('byCategoryKey', chart_key)
+    def by_category_key(chart_key, book_whole_tables = nil)
+      get_chart_report('byCategoryKey', chart_key, book_whole_tables)
     end
 
-    def by_category_label(chart_key)
-      get_chart_report('byCategoryLabel', chart_key)
+    def by_category_label(chart_key, book_whole_tables = nil)
+      get_chart_report('byCategoryLabel', chart_key, book_whole_tables)
     end
 
     private
 
-    def get_chart_report(report_type, chart_key)
+    def get_chart_report(report_type, chart_key, book_whole_tables)
+      params = book_whole_tables.nil? ? {} : { bookWholeTables: book_whole_tables }
       url = "reports/charts/#{chart_key}/#{report_type}"
-      body = @http_client.get(url)
-      Domain::ChartReport.new(body)
+      body = @http_client.get(url, params)
+      ChartReport.new(body)
     end
   end
 end

data/lib/seatsio/charts.rb

@@ -13,24 +13,24 @@ module Seatsio
 
     def initialize(secret_key, workspace_key, base_url)
       @http_client = Seatsio::HttpClient.new(secret_key, workspace_key, base_url)
-      @archive = Pagination::Cursor.new(Domain::Chart, 'charts/archive', @http_client)
+      @archive = Pagination::Cursor.new(Chart, 'charts/archive', @http_client)
     end
 
-    # @return [Seatsio::Domain::Chart]
+    # @return [Seatsio::Chart]
     def retrieve(chart_key)
       response = @http_client.get("charts/#{chart_key}")
-      Domain::Chart.new(response)
+      Chart.new(response)
     end
 
     def retrieve_with_events(chart_key)
       response = @http_client.get("charts/#{chart_key}?expand=events")
-      Domain::Chart.new(response)
+      Chart.new(response)
     end
 
     def create(name: nil, venue_type: nil, categories: nil)
       payload = build_chart_request name: name, venue_type: venue_type, categories: categories
       response = @http_client.post('charts', payload)
-      Domain::Chart.new(response)
+      Chart.new(response)
     end
 
     def update(key:, new_name: nil, categories: nil)
@@ -48,24 +48,24 @@ module Seatsio
 
     def copy(key)
       response = @http_client.post("charts/#{key}/version/published/actions/copy")
-      Domain::Chart.new(response)
+      Chart.new(response)
     end
 
     def copy_to_subaccount(chart_key, subaccount_id)
       url = "charts/#{chart_key}/version/published/actions/copy-to/#{subaccount_id}"
       response = @http_client.post url
-      Domain::Chart.new(response)
+      Chart.new(response)
     end
 
     def copy_to_workspace(chart_key, to_workspace_key)
       url = "charts/#{chart_key}/version/published/actions/copy-to-workspace/#{to_workspace_key}"
       response = @http_client.post url
-      Domain::Chart.new(response)
+      Chart.new(response)
     end
 
     def copy_draft_version(key)
       response = @http_client.post("charts/#{key}/version/draft/actions/copy")
-      Domain::Chart.new(response)
+      Chart.new(response)
     end
 
     def retrieve_published_version(key)
@@ -98,7 +98,7 @@ module Seatsio
     end
 
     def list(chart_filter: nil, tag: nil, expand_events: nil, with_validation: false)
-      cursor = Pagination::Cursor.new(Domain::Chart, 'charts', @http_client)
+      cursor = Pagination::Cursor.new(Chart, 'charts', @http_client)
       cursor.set_query_param('filter', chart_filter)
       cursor.set_query_param('tag', tag)
 
@@ -123,12 +123,12 @@ module Seatsio
 
     def validate_published_version(chart_key)
       response = @http_client.post("charts/#{chart_key}/version/published/actions/validate")
-      Seatsio::Domain::ChartValidationResult.new(response)
+      Seatsio::ChartValidationResult.new(response)
     end
 
     def validate_draft_version(chart_key)
       response = @http_client.post("charts/#{chart_key}/version/draft/actions/validate")
-      Seatsio::Domain::ChartValidationResult.new(response)
+      Seatsio::ChartValidationResult.new(response)
     end
 
     private

data/lib/seatsio/domain.rb

@@ -1,6 +1,6 @@
 require 'seatsio/util'
 
-module Seatsio::Domain
+module Seatsio
 
   module_function
 
@@ -22,10 +22,19 @@ module Seatsio::Domain
       @archived = data['archived']
       @validation = data['validation']
       @social_distancing_rulesets = data['socialDistancingRulesets'].map {
-          |key, r| [key, SocialDistancingRuleset.new(r['name'], r['numberOfDisabledSeatsToTheSides'], r['disableSeatsInFrontAndBehind'],
-                                                     r['numberOfDisabledAisleSeats'], r['maxGroupSize'],
-                                                     r['maxOccupancyAbsolute'], r['maxOccupancyPercentage'], r['oneGroupPerTable'], r['fixedGroupLayout'],
-                                                     r['disabledSeats'], r['enabledSeats'], r['index'])]
+          |key, r| [key, SocialDistancingRuleset.new(r['name'],
+                                                     number_of_disabled_seats_to_the_sides: r['numberOfDisabledSeatsToTheSides'],
+                                                     disable_seats_in_front_and_behind: r['disableSeatsInFrontAndBehind'],
+                                                     disable_diagonal_seats_in_front_and_behind: r['disableDiagonalSeatsInFrontAndBehind'],
+                                                     number_of_disabled_aisle_seats: r['numberOfDisabledAisleSeats'],
+                                                     max_group_size: r['maxGroupSize'],
+                                                     max_occupancy_absolute: r['maxOccupancyAbsolute'],
+                                                     max_occupancy_percentage: r['maxOccupancyPercentage'],
+                                                     one_group_per_table: r['oneGroupPerTable'],
+                                                     fixed_group_layout: r['fixedGroupLayout'],
+                                                     disabled_seats: r['disabledSeats'],
+                                                     enabled_seats: r['enabledSeats'],
+                                                     index: r['index'])]
       }.to_h
     end
   end
@@ -61,6 +70,38 @@ module Seatsio::Domain
     end
   end
 
+  class TableBookingConfig
+
+    attr_reader :mode, :tables
+
+    def initialize(mode, tables = nil)
+      @mode = mode
+      @tables = tables
+    end
+
+    def self.inherit
+      TableBookingConfig.new('INHERIT')
+    end
+
+    def self.all_by_seat
+      TableBookingConfig.new('ALL_BY_SEAT')
+    end
+
+    def self.all_by_table
+      TableBookingConfig.new('ALL_BY_TABLE')
+    end
+
+    def self.custom(tables)
+      TableBookingConfig.new('CUSTOM', tables)
+    end
+
+    def self.from_json(data)
+      if data
+        TableBookingConfig.new(data['mode'], data['tables'])
+      end
+    end
+  end
+
   class Channel
     attr_reader :key, :name, :color, :index, :objects
 
@@ -84,17 +125,16 @@ module Seatsio::Domain
 
   class Event
 
-    attr_accessor :id, :key, :chart_key, :book_whole_tables, :supports_best_available,
-                  :table_booking_modes, :for_sale_config, :created_on, :updated_on, :channels,
+    attr_accessor :id, :key, :chart_key, :supports_best_available,
+                  :table_booking_config, :for_sale_config, :created_on, :updated_on, :channels,
                   :social_distancing_ruleset_key
 
     def initialize(data)
       @id = data['id']
       @key = data['key']
       @chart_key = data['chartKey']
-      @book_whole_tables = data['bookWholeTables']
       @supports_best_available = data['supportsBestAvailable']
-      @table_booking_modes = data['tableBookingModes']
+      @table_booking_config = TableBookingConfig::from_json(data['tableBookingConfig'])
       @for_sale_config = ForSaleConfig.new(data['forSaleConfig']) if data['forSaleConfig']
       @created_on = parse_date(data['createdOn'])
       @updated_on = parse_date(data['updatedOn'])
@@ -185,7 +225,7 @@ module Seatsio::Domain
     attr_reader :objects
 
     def initialize(data)
-      @objects = Seatsio::Domain.to_object_details(data['objects']);
+      @objects = Seatsio.to_object_details(data['objects']);
     end
   end
 
@@ -217,7 +257,7 @@ module Seatsio::Domain
     def initialize(data)
       @next_to_each_other = data['nextToEachOther']
       @objects = data['objects']
-      @object_details = Seatsio::Domain.to_object_details(data['objectDetails'])
+      @object_details = Seatsio.to_object_details(data['objectDetails'])
     end
   end
 
@@ -475,15 +515,16 @@ module Seatsio::Domain
 
   class SocialDistancingRuleset
     attr_reader :name, :number_of_disabled_seats_to_the_sides, :disable_seats_in_front_and_behind,
-                :number_of_disabled_aisle_seats, :max_group_size, :max_occupancy_absolute,
+                :disable_diagonal_seats_in_front_and_behind, :number_of_disabled_aisle_seats, :max_group_size, :max_occupancy_absolute,
                 :max_occupancy_percentage, :one_group_per_table, :fixed_group_layout, :disabled_seats, :enabled_seats, :index
 
-    def initialize(name, number_of_disabled_seats_to_the_sides = 0, disable_seats_in_front_and_behind = false, number_of_disabled_aisle_seats = 0,
-                   max_group_size = 0, max_occupancy_absolute = 0, max_occupancy_percentage = 0, one_group_per_table = false,
-                   fixed_group_layout = false, disabled_seats = [], enabled_seats = [], index = 0)
+    def initialize(name, number_of_disabled_seats_to_the_sides: 0, disable_seats_in_front_and_behind: false, disable_diagonal_seats_in_front_and_behind: false,
+                   number_of_disabled_aisle_seats: 0, max_group_size: 0, max_occupancy_absolute: 0, max_occupancy_percentage: 0, one_group_per_table: false,
+                   fixed_group_layout: false, disabled_seats: [], enabled_seats: [], index: 0)
       @name = name
       @number_of_disabled_seats_to_the_sides = number_of_disabled_seats_to_the_sides
       @disable_seats_in_front_and_behind = disable_seats_in_front_and_behind
+      @disable_diagonal_seats_in_front_and_behind = disable_diagonal_seats_in_front_and_behind
       @number_of_disabled_aisle_seats = number_of_disabled_aisle_seats
       @max_group_size = max_group_size
       @max_occupancy_absolute = max_occupancy_absolute
@@ -495,22 +536,33 @@ module Seatsio::Domain
       @index = index
     end
 
-    def self.fixed(name, disabled_seats = [], index = 0)
-      SocialDistancingRuleset.new(name, 0, false, 0, 0, 0, 0, false, true, disabled_seats, [], index)
+    def self.fixed(name, disabled_seats: [], index: 0)
+      return SocialDistancingRuleset.new(name, index: index, disabled_seats: disabled_seats, fixed_group_layout: true)
     end
 
-    def self.rule_based(name, number_of_disabled_seats_to_the_sides = 0, disable_seats_in_front_and_behind = false, number_of_disabled_aisle_seats = 0,
-                        max_group_size = 0, max_occupancy_absolute = 0, max_occupancy_percentage = 0, one_group_per_table = false,
-                        disabled_seats = [], enabled_seats = [], index = 0)
-      SocialDistancingRuleset.new(name, number_of_disabled_seats_to_the_sides, disable_seats_in_front_and_behind, number_of_disabled_aisle_seats,
-                                  max_group_size, max_occupancy_absolute, max_occupancy_percentage,
-                                  one_group_per_table, false, disabled_seats, enabled_seats, index)
+    def self.rule_based(name, number_of_disabled_seats_to_the_sides: 0, disable_seats_in_front_and_behind: false, disable_diagonal_seats_in_front_and_behind: false,
+                        number_of_disabled_aisle_seats: 0, max_group_size: 0, max_occupancy_absolute: 0, max_occupancy_percentage: 0, one_group_per_table: false,
+                        disabled_seats: [], enabled_seats: [], index: 0)
+      return SocialDistancingRuleset.new(name,
+                                         number_of_disabled_seats_to_the_sides: number_of_disabled_seats_to_the_sides,
+                                         disable_seats_in_front_and_behind: disable_seats_in_front_and_behind,
+                                         disable_diagonal_seats_in_front_and_behind: disable_diagonal_seats_in_front_and_behind,
+                                         number_of_disabled_aisle_seats: number_of_disabled_aisle_seats,
+                                         max_group_size: max_group_size,
+                                         max_occupancy_absolute: max_occupancy_absolute,
+                                         max_occupancy_percentage: max_occupancy_percentage,
+                                         one_group_per_table: one_group_per_table,
+                                         fixed_group_layout: false,
+                                         disabled_seats: disabled_seats,
+                                         enabled_seats: enabled_seats,
+                                         index: index)
     end
 
     def == (other)
       self.name == other.name &&
           self.number_of_disabled_seats_to_the_sides == other.number_of_disabled_seats_to_the_sides &&
           self.disable_seats_in_front_and_behind == other.disable_seats_in_front_and_behind &&
+          self.disable_diagonal_seats_in_front_and_behind == other.disable_diagonal_seats_in_front_and_behind &&
           self.number_of_disabled_aisle_seats == other.number_of_disabled_aisle_seats &&
           self.max_group_size == other.max_group_size &&
           self.max_occupancy_absolute == other.max_occupancy_absolute &&

data/lib/seatsio/event_reports.rb

@@ -15,26 +15,50 @@ module Seatsio
       fetch_summary_report('byStatus', event_key)
     end
 
+    def deep_summary_by_status(event_key)
+      fetch_deep_summary_report('byStatus', event_key)
+    end
+
     def summary_by_category_key(event_key)
       fetch_summary_report('byCategoryKey', event_key)
     end
 
+    def deep_summary_by_category_key(event_key)
+      fetch_deep_summary_report('byCategoryKey', event_key)
+    end
+
     def summary_by_category_label(event_key)
       fetch_summary_report('byCategoryLabel', event_key)
     end
 
+    def deep_summary_by_category_label(event_key)
+      fetch_deep_summary_report('byCategoryLabel', event_key)
+    end
+
     def summary_by_section(event_key)
       fetch_summary_report('bySection', event_key)
     end
 
+    def deep_summary_by_section(event_key)
+      fetch_deep_summary_report('bySection', event_key)
+    end
+
     def summary_by_selectability(event_key)
       fetch_summary_report('bySelectability', event_key)
     end
 
+    def deep_summary_by_selectability(event_key)
+      fetch_deep_summary_report('bySelectability', event_key)
+    end
+
     def summary_by_channel(event_key)
       fetch_summary_report('byChannel', event_key)
     end
 
+    def deep_summary_by_channel(event_key)
+      fetch_deep_summary_report('byChannel', event_key)
+    end
+
     def by_label(event_key, label = nil)
       fetch_report('byLabel', event_key, label)
     end
@@ -74,15 +98,20 @@ module Seatsio
       @http_client.get(url)
     end
 
+    def fetch_deep_summary_report(report_type, event_key)
+      url = "reports/events/#{event_key}/#{report_type}/summary/deep"
+      @http_client.get(url)
+    end
+
     def fetch_report(report_type, event_key, report_filter = nil)
       if report_filter
         url = "reports/events/#{event_key}/#{report_type}/#{report_filter}"
         body = @http_client.get(url)
-        Domain::EventReport.new(body[report_filter])
+        EventReport.new(body[report_filter])
       else
         url = "reports/events/#{event_key}/#{report_type}"
         body = @http_client.get(url)
-        Domain::EventReport.new(body)
+        EventReport.new(body)
       end
     end
   end

data/lib/seatsio/events.rb

@@ -15,22 +15,21 @@ module Seatsio
       @http_client = ::Seatsio::HttpClient.new(secret_key, workspace_key, base_url)
     end
 
-    def create(chart_key: nil, event_key: nil, book_whole_tables: nil, table_booking_modes: nil, social_distancing_ruleset_key: nil)
-      payload = build_event_request(chart_key: chart_key, event_key: event_key, book_whole_tables: book_whole_tables,
-                                    table_booking_modes: table_booking_modes, social_distancing_ruleset_key: social_distancing_ruleset_key)
+    def create(chart_key: nil, event_key: nil, table_booking_config: nil, social_distancing_ruleset_key: nil)
+      payload = build_event_request(chart_key: chart_key, event_key: event_key,
+                                    table_booking_config: table_booking_config, social_distancing_ruleset_key: social_distancing_ruleset_key)
       response = @http_client.post("events", payload)
-      Domain::Event.new(response)
+      Event.new(response)
     end
 
     def create_multiple(key: nil, event_creation_params: nil)
       payload = build_events_request(chart_key: key, event_creation_params: event_creation_params)
       response = @http_client.post("events/actions/create-multiple", payload)
-      Domain::Events.new(response).events
+      Events.new(response).events
     end
 
-    def update(key:, chart_key: nil, event_key: nil, book_whole_tables: nil, table_booking_modes: nil, social_distancing_ruleset_key: nil)
-      payload = build_event_request(chart_key: chart_key, event_key: event_key, book_whole_tables: book_whole_tables,
-                                    table_booking_modes: table_booking_modes, social_distancing_ruleset_key: social_distancing_ruleset_key)
+    def update(key:, chart_key: nil, event_key: nil, table_booking_config: nil, social_distancing_ruleset_key: nil)
+      payload = build_event_request(chart_key: chart_key, event_key: event_key, table_booking_config: table_booking_config, social_distancing_ruleset_key: social_distancing_ruleset_key)
       @http_client.post("/events/#{key}", payload)
     end
 
@@ -47,77 +46,76 @@ module Seatsio
     def retrieve_object_status(key:, object_key:)
       url = "events/#{key}/objects/#{CGI::escape(object_key).gsub('+', '%20')}"
       response = @http_client.get(url)
-      Domain::ObjectStatus.new(response)
+      ObjectStatus.new(response)
     end
 
-    def book(event_key_or_keys, object_or_objects, hold_token: nil, order_id: nil, keep_extra_data: nil, ignore_channels: nil, channel_keys: nil)
-      self.change_object_status(event_key_or_keys, object_or_objects, Domain::ObjectStatus::BOOKED, hold_token: hold_token, order_id: order_id, keep_extra_data: keep_extra_data, ignore_channels: ignore_channels, channel_keys: channel_keys)
+    def book(event_key_or_keys, object_or_objects, hold_token: nil, order_id: nil, keep_extra_data: nil, ignore_channels: nil, channel_keys: nil, ignore_social_distancing: nil)
+      self.change_object_status(event_key_or_keys, object_or_objects, ObjectStatus::BOOKED, hold_token: hold_token, order_id: order_id, keep_extra_data: keep_extra_data, ignore_channels: ignore_channels, channel_keys: channel_keys, ignore_social_distancing: ignore_social_distancing)
     end
 
-    def change_object_status(event_key_or_keys, object_or_objects, status, hold_token: nil, order_id: nil, keep_extra_data: nil, ignore_channels: nil, channel_keys: nil)
-      request = create_change_object_status_request(object_or_objects, status, hold_token, order_id, event_key_or_keys, keep_extra_data, ignore_channels, channel_keys)
+    def change_object_status(event_key_or_keys, object_or_objects, status, hold_token: nil, order_id: nil, keep_extra_data: nil, ignore_channels: nil, channel_keys: nil, ignore_social_distancing: nil)
+      request = create_change_object_status_request(object_or_objects, status, hold_token, order_id, event_key_or_keys, keep_extra_data, ignore_channels, channel_keys, ignore_social_distancing)
       request[:params] = {
           :expand => 'objects'
       }
       response = @http_client.post("seasons/actions/change-object-status", request)
-      Domain::ChangeObjectStatusResult.new(response)
+      ChangeObjectStatusResult.new(response)
     end
 
     def change_object_status_in_batch(status_change_requests)
       request = {
           :statusChanges => status_change_requests,
-          :params => { :expand => 'objects' }
+          :params => {:expand => 'objects'}
       }
       response = @http_client.post("events/actions/change-object-status", request)
-      Domain::ChangeObjectStatusInBatchResult.new(response).results
+      ChangeObjectStatusInBatchResult.new(response).results
     end
 
-    def hold(event_key_or_keys, object_or_objects, hold_token, order_id: nil, keep_extra_data: nil, ignore_channels: nil, channel_keys: nil)
-      change_object_status(event_key_or_keys, object_or_objects, Domain::ObjectStatus::HELD, hold_token: hold_token, order_id: order_id, keep_extra_data: keep_extra_data, ignore_channels: ignore_channels, channel_keys: channel_keys)
+    def hold(event_key_or_keys, object_or_objects, hold_token, order_id: nil, keep_extra_data: nil, ignore_channels: nil, channel_keys: nil, ignore_social_distancing: nil)
+      change_object_status(event_key_or_keys, object_or_objects, ObjectStatus::HELD, hold_token: hold_token, order_id: order_id, keep_extra_data: keep_extra_data, ignore_channels: ignore_channels, channel_keys: channel_keys, ignore_social_distancing: ignore_social_distancing)
     end
 
     def change_best_available_object_status(key, number, status, categories: nil, hold_token: nil, extra_data: nil, ticket_types: nil, order_id: nil, keep_extra_data: nil, ignore_channels: nil, channel_keys: nil)
       request = create_change_best_available_object_status_request(number, status, categories, extra_data, ticket_types, hold_token, order_id, keep_extra_data, ignore_channels, channel_keys)
       response = @http_client.post("events/#{key}/actions/change-object-status", request)
-      Domain::BestAvailableObjects.new(response)
+      BestAvailableObjects.new(response)
     end
 
     def book_best_available(key, number, categories: nil, hold_token: nil, order_id: nil, keep_extra_data: nil, extra_data: nil, ticket_types: nil, ignore_channels: nil, channel_keys: nil)
-      change_best_available_object_status(key, number, Domain::ObjectStatus::BOOKED, categories: categories, hold_token: hold_token, order_id: order_id, keep_extra_data: keep_extra_data, extra_data: extra_data, ticket_types: ticket_types, ignore_channels: ignore_channels, channel_keys: channel_keys)
+      change_best_available_object_status(key, number, ObjectStatus::BOOKED, categories: categories, hold_token: hold_token, order_id: order_id, keep_extra_data: keep_extra_data, extra_data: extra_data, ticket_types: ticket_types, ignore_channels: ignore_channels, channel_keys: channel_keys)
     end
 
     def hold_best_available(key, number, hold_token, categories: nil, order_id: nil, keep_extra_data: nil, extra_data: nil, ticket_types: nil, ignore_channels: nil, channel_keys: nil)
-      change_best_available_object_status(key, number, Domain::ObjectStatus::HELD, categories: categories, hold_token: hold_token, order_id: order_id, keep_extra_data: keep_extra_data, extra_data: extra_data, ticket_types: ticket_types, ignore_channels: ignore_channels, channel_keys: channel_keys)
+      change_best_available_object_status(key, number, ObjectStatus::HELD, categories: categories, hold_token: hold_token, order_id: order_id, keep_extra_data: keep_extra_data, extra_data: extra_data, ticket_types: ticket_types, ignore_channels: ignore_channels, channel_keys: channel_keys)
     end
 
     def release(event_key_or_keys, object_or_objects, hold_token: nil, order_id: nil, keep_extra_data: nil, ignore_channels: nil, channel_keys: nil)
-      change_object_status(event_key_or_keys, object_or_objects, Domain::ObjectStatus::FREE, hold_token: hold_token, order_id: order_id, keep_extra_data: keep_extra_data, ignore_channels: ignore_channels, channel_keys: channel_keys)
+      change_object_status(event_key_or_keys, object_or_objects, ObjectStatus::FREE, hold_token: hold_token, order_id: order_id, keep_extra_data: keep_extra_data, ignore_channels: ignore_channels, channel_keys: channel_keys)
     end
 
     def delete(key:)
       @http_client.delete("/events/#{key}")
     end
 
-
     def retrieve(key:)
       response = @http_client.get("events/#{key}")
-      Domain::Event.new(response)
+      Event.new(response)
     end
 
     def list
-      Pagination::Cursor.new(Domain::Event, 'events', @http_client)
+      Pagination::Cursor.new(Event, 'events', @http_client)
     end
 
     def list_status_changes(key, object_id = nil)
       if object_id != nil
         status_changes_for_object key: key, object_id: object_id
       else
-        Pagination::Cursor.new(Domain::StatusChange, "/events/#{key}/status-changes", @http_client)
+        Pagination::Cursor.new(StatusChange, "/events/#{key}/status-changes", @http_client)
       end
     end
 
     def status_changes_for_object(key:, object_id:)
-      Pagination::Cursor.new(Domain::StatusChange, "/events/#{key}/objects/#{object_id}/status-changes", @http_client)
+      Pagination::Cursor.new(StatusChange, "/events/#{key}/objects/#{object_id}/status-changes", @http_client)
     end
 
     def mark_as_not_for_sale(key:, objects: nil, categories: nil)
@@ -157,12 +155,11 @@ module Seatsio
       payload
     end
 
-    def build_event_request(chart_key: nil, event_key: nil, book_whole_tables: nil, table_booking_modes: nil, social_distancing_ruleset_key: nil)
+    def build_event_request(chart_key: nil, event_key: nil, table_booking_config: nil, social_distancing_ruleset_key: nil)
       result = {}
       result["chartKey"] = chart_key if chart_key
       result["eventKey"] = event_key if event_key
-      result["bookWholeTables"] = book_whole_tables if book_whole_tables != nil
-      result["tableBookingModes"] = table_booking_modes if table_booking_modes != nil
+      result["tableBookingConfig"] = table_booking_config_to_request(table_booking_config) if table_booking_config != nil
       result["socialDistancingRulesetKey"] = social_distancing_ruleset_key if social_distancing_ruleset_key != nil
       result
     end
@@ -179,12 +176,18 @@ module Seatsio
       params.each do |param|
         r = {}
         r["eventKey"] = param[:event_key] if param[:event_key] != nil
-        r["bookWholeTables"] = param[:book_whole_tables] if param[:book_whole_tables] != nil
-        r["tableBookingModes"] = param[:table_booking_modes] if param[:table_booking_modes] != nil
+        r["tableBookingConfig"] = table_booking_config_to_request(param[:table_booking_config]) if param[:table_booking_config] != nil
         result.push(r)
       end
       result
     end
 
+    def table_booking_config_to_request(table_booking_config)
+      result = {}
+      result["mode"] = table_booking_config.mode
+      result["tables"] = table_booking_config.tables if table_booking_config.tables != nil
+      result
+    end
+
   end
 end

data/lib/seatsio/events/change_object_status_request.rb

@@ -1,4 +1,4 @@
-def create_change_object_status_request(object_or_objects, status, hold_token, order_id, event_key_or_keys, keep_extra_data, ignore_channels, channel_keys)
+def create_change_object_status_request(object_or_objects, status, hold_token, order_id, event_key_or_keys, keep_extra_data, ignore_channels, channel_keys, ignore_social_distancing)
   result = {}
   result[:objects] = normalize(object_or_objects)
   result[:status] = status
@@ -12,6 +12,7 @@ def create_change_object_status_request(object_or_objects, status, hold_token, o
   result[:keepExtraData] = keep_extra_data if keep_extra_data != nil
   result[:ignoreChannels] = ignore_channels if ignore_channels != nil
   result[:channelKeys] = channel_keys if channel_keys != nil
+  result[:ignoreSocialDistancing] = ignore_social_distancing if ignore_social_distancing != nil
   result
 end
 

data/lib/seatsio/hold_tokens.rb

@@ -21,18 +21,18 @@ module Seatsio
         body[:expiresInMinutes] = expires_in_minutes
       end
       response = @http_client.post('hold-tokens', body)
-      Domain::HoldToken.new(response)
+      HoldToken.new(response)
     end
 
     def retrieve(hold_token)
       response = @http_client.get("/hold-tokens/#{hold_token}")
-      Domain::HoldToken.new(response)
+      HoldToken.new(response)
     end
 
     def expire_in_minutes(hold_token, expires_in_minutes = nil)
       body = {"expiresInMinutes": expires_in_minutes}
       response = @http_client.post("/hold-tokens/#{hold_token}", body)
-      Domain::HoldToken.new(response)
+      HoldToken.new(response)
     end
   end
 end

data/lib/seatsio/subaccounts.rb

@@ -17,7 +17,7 @@ module Seatsio
       body['name'] = name if name
 
       response = @http_client.post("subaccounts", body)
-      Domain::Subaccount.new(response)
+      Subaccount.new(response)
     end
 
     def update(id:, name: nil)
@@ -50,17 +50,17 @@ module Seatsio
 
     def retrieve(id:)
       response = @http_client.get("/subaccounts/#{id}")
-      Domain::Subaccount.new(response)
+      Subaccount.new(response)
     end
 
     def copy_chart_to_parent(id: nil, chart_key: nil)
       response = @http_client.post("/subaccounts/#{id}/charts/#{chart_key}/actions/copy-to/parent")
-      Domain::Chart.new(response)
+      Chart.new(response)
     end
 
     def copy_chart_to_subaccount(from_id: nil, to_id: nil, chart_key: nil)
       response = @http_client.post("/subaccounts/#{from_id}/charts/#{chart_key}/actions/copy-to/#{to_id}")
-      Domain::Chart.new(response)
+      Chart.new(response)
     end
 
     def regenerate_secret_key(id:)
@@ -75,7 +75,7 @@ module Seatsio
 
     def cursor(status: nil)
       endpoint = status ? "subaccounts/#{status}" : 'subaccounts'
-      Pagination::Cursor.new(Domain::Subaccount, endpoint, @http_client)
+      Pagination::Cursor.new(Subaccount, endpoint, @http_client)
     end
   end
 end

data/lib/seatsio/usage_reports.rb

@@ -13,19 +13,19 @@ module Seatsio
     def summary_for_all_months
       url = "reports/usage"
       body = @http_client.get(url)
-      Domain::UsageSummaryForAllMoths.new(body)
+      UsageSummaryForAllMoths.new(body)
     end
 
     def details_for_month(month)
       url = "reports/usage/month/" + month.serialize
       body = @http_client.get(url)
-      body.map { |item| Domain::UsageDetails.new(item) }
+      body.map { |item| UsageDetails.new(item) }
     end
 
     def details_for_event_in_month(eventId, month)
       url = "reports/usage/month/" + month.serialize + "/event/" + eventId.to_s
       body = @http_client.get(url)
-      body.map { |item| Domain::UsageForObject.new(item) }
+      body.map { |item| UsageForObject.new(item) }
     end
   end
 end

data/lib/seatsio/version.rb

@@ -1,3 +1,3 @@
 module Seatsio
-  VERSION = "26.1.0"
+  VERSION = "28.2.0"
 end

data/lib/seatsio/workspaces.rb

@@ -18,7 +18,7 @@ module Seatsio
       body['isTest'] = is_test if is_test
 
       response = @http_client.post("workspaces", body)
-      Domain::Workspace.new(response)
+      Workspace.new(response)
     end
 
     def update(key:, name:)
@@ -52,13 +52,13 @@ module Seatsio
 
     def retrieve(key:)
       response = @http_client.get("/workspaces/#{key}")
-      Domain::Workspace.new(response)
+      Workspace.new(response)
     end
 
     private
 
     def cursor()
-      Pagination::Cursor.new(Domain::Workspace, 'workspaces', @http_client)
+      Pagination::Cursor.new(Workspace, 'workspaces', @http_client)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: seatsio
 version: !ruby/object:Gem::Version
-  version: 26.1.0
+  version: 28.2.0
 platform: ruby
 authors:
 - Seats.io
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-19 00:00:00.000000000 Z
+date: 2020-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler