seatsio 26.0.0 → 28.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 56dacdba1281d3633ebd9eec2ef5ce9b3b35b1f6c5bd823be2e5f02bd8157962
-  data.tar.gz: b54123ab3b42336f2b490dbc669996be69e6cd3438c3591ed4722993cbd22c44
+  metadata.gz: f16665209691ecc5c5be881c2c37580dc4525c3d1e2c067780830241aae5c77b
+  data.tar.gz: 84ecfa02bb8129ee5bc78f71319201c9ca1650b74cb570666628aa2a57dd9287
 SHA512:
-  metadata.gz: 58833779b5be413655325bc3dce81ac8bd78382887d7c13caba7097e3a52f33dd6009e91abdce0bcbc7961b09a7518046b809c8348940d1dee1ab1ff0615b87a
-  data.tar.gz: 71ac86858ccb803b5eb5002ce59552c261daebae7ef509334b2bf38ac828f66bd10d77b95274f8a059bdf64c1c13d389c13bfc8407404cf607c3ecb7434b74d0
+  metadata.gz: 8882b8209078d93b30db4f410c27f063a79eea273840e02a060b36b01c28eb6953007e46244abfc3f0f863e3ede87de1d15bd804bdbf121024bdad618b9ec341
+  data.tar.gz: 13663be3aaf3e6189037d5678c86dc6575785dcb3150a09d197f4a6ab16bd82d20c4edf3822f4d3bcfb7d9cbe414b49a749eae08315b609abe022521d4a442b0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    seatsio (26.0.0)
+    seatsio (28.1.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['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,45 +515,59 @@ 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,
-                :max_occupancy_percentage, :fixed_group_layout, :disabled_seats, :enabled_seats, :index
+                :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, 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
       @max_occupancy_percentage = max_occupancy_percentage
+      @one_group_per_table = one_group_per_table
       @fixed_group_layout = fixed_group_layout
       @disabled_seats = disabled_seats
       @enabled_seats = enabled_seats
       @index = index
     end
 
-    def self.fixed(name, disabled_seats = [], index = 0)
-      SocialDistancingRuleset.new(name, 0, false, 0, 0, 0, 0, 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,
-                        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,
-                                  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 &&
           self.max_occupancy_percentage == other.max_occupancy_percentage &&
+          self.one_group_per_table == other.one_group_per_table &&
           self.fixed_group_layout == other.fixed_group_layout &&
           self.disabled_seats == other.disabled_seats &&
           self.enabled_seats == other.enabled_seats &&

data/lib/seatsio/event_reports.rb

@@ -78,11 +78,11 @@ module Seatsio
       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.0.0"
+  VERSION = "28.1.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.0.0
+  version: 28.1.0
 platform: ruby
 authors:
 - Seats.io
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-10-08 00:00:00.000000000 Z
+date: 2020-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler