spree_cm_commissioner 2.13.3.pre.pre1 → 2.13.3.pre.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6debbf57a54a0a2fcbc3ba4ee4c3e07045c520377afbd0ad13d6f6fde2120654
-  data.tar.gz: 3c66791879a8187925ac7ecba67437a4e049bce327f7d19ff9f435d0acddd54e
+  metadata.gz: c2ffd7af989f00931883cac1fc7aa3ff4173458f57a42abd9294ecba2687c2bb
+  data.tar.gz: d2ee7a2a5d558f018075eded5ef178d294a61afc6e53b5d77018c3ef3a239c04
 SHA512:
-  metadata.gz: f5a7c7f1e396e46ae559484c92900a1180ede361e562b192a0b13abc922779f521fbc093a86d695b760abcc8609e0563785e5fadd285fb919670c0c8816bf5d9
-  data.tar.gz: 124912777c8bacddd0a1f067ab1e6faaa245af600da5343150f4862fd5c9cabdea60e54efddf64e636903a99cb2e0a7143c91647ff34e05a5c0d9d705ff8a5da
+  metadata.gz: db45749501e065ded53bef1baa37ebbbca96badd6384ac47505f72ed08dd45c0040e6ea22f50dfa4454ea32a3059d63aa7f9ce3e80fe4b97f99d3dca06e1f1ea
+  data.tar.gz: fc0b52d82222015696750733ecc702ef57e425256ca4e460644f21fe48369251e01e41adee33848e9d78be225e3342d845db8c4df93e973c70a9a360c21e72cb

data/Gemfile.lock

@@ -34,7 +34,7 @@ GIT
 PATH
   remote: .
   specs:
-    spree_cm_commissioner (2.13.3.pre.pre1)
+    spree_cm_commissioner (2.13.3.pre.pre3)
       activerecord-multi-tenant
       activerecord_json_validator (~> 2.1, >= 2.1.3)
       aws-sdk-cloudfront

data/app/controllers/spree/admin/integrations_controller.rb

@@ -12,9 +12,7 @@ module Spree
       def enqueue_polling
         sync_type = params[:sync_type].presence || :full
 
-        if !@integration.supports_polling?
-          flash[:error] = Spree.t('admin.integration_polling_not_supported')
-        elsif @integration.active?
+        if @integration.active?
           SpreeCmCommissioner::Integrations::PollingJob.perform_later(
             integration_id: @integration.id,
             sync_type: sync_type

data/app/controllers/spree/api/switch_cm/ota/avail_notifs_controller.rb

@@ -5,7 +5,7 @@ module Spree::Api::SwitchCm
       private
 
       # override
-      def parser_class = SpreeCmCommissioner::Integrations::SwitchCm::Ota::AvailNotifParser
+      def parser_class = SpreeCmCommissioner::Integrations::SwitchCm::Ota::AvailabilityParser
 
       # override
       def message_name = 'OTA_HotelAvailNotif'

data/app/controllers/spree/api/switch_cm/ota/pushes_controller.rb

@@ -6,9 +6,9 @@ module Spree::Api::SwitchCm
 
       # POST /api/switch_cm/hotels/ota/OTA_HotelAvailNotif (AvailNotifsController): rooms to sell and open/close
       # POST /api/switch_cm/hotels/ota/OTA_HotelRateAmountNotif (RateAmountNotifsController): per-night prices
-      # Validated and applied in the request (AcceptPush); the answer is the real outcome.
+      # Validated and applied in the request (Inventory::AcceptPush); the answer is the real outcome.
       def create
-        result = SpreeCmCommissioner::Integrations::SwitchCm::AcceptPush.call(
+        result = SpreeCmCommissioner::Integrations::SwitchCm::Inventory::AcceptPush.call(
           integration: current_integration,
           message: message_name,
           updates: updates,

data/app/controllers/spree/api/switch_cm/ota/rate_amount_notifs_controller.rb

@@ -5,7 +5,7 @@ module Spree::Api::SwitchCm
       private
 
       # override
-      def parser_class = SpreeCmCommissioner::Integrations::SwitchCm::Ota::RateAmountNotifParser
+      def parser_class = SpreeCmCommissioner::Integrations::SwitchCm::Ota::PriceParser
 
       # override
       def message_name = 'OTA_HotelRateAmountNotif'

data/app/controllers/spree/api/switch_cm/ota/res_modify_notifs_controller.rb

@@ -23,8 +23,8 @@ module Spree::Api::SwitchCm
       def container = :HotelResModifies
 
       # override
-      def present(presenter, xml)
-        presenter.build_modification(xml)
+      def serialize(serializer, xml)
+        serializer.build_modification(xml)
       end
     end
   end

data/app/controllers/spree/api/switch_cm/ota/res_notifs_controller.rb

@@ -21,8 +21,8 @@ module Spree::Api::SwitchCm
       def container = :HotelReservations
 
       # override
-      def present(presenter, xml)
-        presenter.build_reservation(xml)
+      def serialize(serializer, xml)
+        serializer.build_reservation(xml)
       end
     end
   end

data/app/controllers/spree/api/switch_cm/ota/reservation_streams_controller.rb

@@ -10,10 +10,10 @@ module Spree::Api::SwitchCm
         integrations, unknown_hotel_ids = requested_integrations(params[:hotel_ids])
         return render_fault(:forbidden, 'Not authorized for these hotels') if integrations.empty?
 
-        reservations = SpreeCmCommissioner::Integrations::SwitchCm::ReservationFeed.new(integrations).public_send(
+        reservations = SpreeCmCommissioner::Integrations::SwitchCm::Reservations::Feed.new(integrations).public_send(
           feed_method,
           id: params[:id],
-          last_change: SpreeCmCommissioner::Integrations::SwitchCm::ReservationFeed.parse_last_change(params[:last_change]),
+          last_change: SpreeCmCommissioner::Integrations::SwitchCm::Reservations::Feed.parse_last_change(params[:last_change]),
           limit: params[:limit]
         )
 
@@ -22,7 +22,7 @@ module Spree::Api::SwitchCm
         ) do |xml|
           xml.send(container) do
             reservations.each do |reservation|
-              present(SpreeCmCommissioner::Integrations::SwitchCm::Ota::ReservationPresenter.new(reservation), xml)
+              serialize(SpreeCmCommissioner::Integrations::SwitchCm::Ota::ReservationSerializer.new(reservation), xml)
             end
           end
         end
@@ -37,7 +37,7 @@ module Spree::Api::SwitchCm
         # (code 193) means the channel manager couldn't process them and they stay queued.
         return render_success if processing_failed?
 
-        result = SpreeCmCommissioner::Integrations::SwitchCm::AcknowledgeReservations.call(
+        result = SpreeCmCommissioner::Integrations::SwitchCm::Reservations::Acknowledge.call(
           integrations: switch_cm_integrations.includes(:vendor).to_a,
           reservation_ids: request_document.xpath('//HotelReservationID/@ResID_Value').map(&:value),
           status: acknowledged_status
@@ -67,8 +67,8 @@ module Spree::Api::SwitchCm
         raise NotImplementedError, "#{self.class.name} must implement container"
       end
 
-      def present(_presenter, _xml)
-        raise NotImplementedError, "#{self.class.name} must implement present"
+      def serialize(_serializer, _xml)
+        raise NotImplementedError, "#{self.class.name} must implement serialize"
       end
 
       def processing_failed?

data/app/controllers/spree/api/switch_cm/xml/availabilities_controller.rb

@@ -5,9 +5,9 @@ module Spree::Api::SwitchCm
 
       # POST /api/switch_cm/hotels/xml/availability
       # Rooms to sell, prices and closed in one message, validated and applied in the request
-      # (AcceptPush); the answer is the real outcome.
+      # (Inventory::AcceptPush); the answer is the real outcome.
       def create
-        result = SpreeCmCommissioner::Integrations::SwitchCm::AcceptPush.call(
+        result = SpreeCmCommissioner::Integrations::SwitchCm::Inventory::AcceptPush.call(
           integration: current_integration,
           message: 'availability',
           updates: parser.updates,

data/app/controllers/spree/api/switch_cm/xml/reservation_summaries_controller.rb

@@ -8,11 +8,11 @@ module Spree::Api::SwitchCm
       # booked. The channel manager imports these while setting the hotel up, so they count against
       # its availability before its first push. Read-only: nothing is marked seen.
       def create
-        reservations = SpreeCmCommissioner::Integrations::SwitchCm::ReservationFeed.new([current_integration]).summary
+        reservations = SpreeCmCommissioner::Integrations::SwitchCm::Reservations::Feed.new([current_integration]).summary
 
         render_document do |xml|
           reservations.each do |reservation|
-            SpreeCmCommissioner::Integrations::SwitchCm::Xml::ReservationPresenter.new(reservation, summary: true).build(xml)
+            SpreeCmCommissioner::Integrations::SwitchCm::Xml::ReservationSerializer.new(reservation, summary: true).build(xml)
           end
         end
       end

data/app/controllers/spree/api/switch_cm/xml/reservations_controller.rb

@@ -8,14 +8,14 @@ module Spree::Api::SwitchCm
         integrations, = requested_integrations(request_value('hotel_id') || request_value('hotel_ids'))
         return render_fault(:forbidden, 'Not authorized for these hotels') if integrations.empty?
 
-        reservations = SpreeCmCommissioner::Integrations::SwitchCm::ReservationFeed.new(integrations).changed_reservations(
+        reservations = SpreeCmCommissioner::Integrations::SwitchCm::Reservations::Feed.new(integrations).changed_reservations(
           id: request_value('id'),
-          last_change: SpreeCmCommissioner::Integrations::SwitchCm::ReservationFeed.parse_last_change(request_value('last_change')),
+          last_change: SpreeCmCommissioner::Integrations::SwitchCm::Reservations::Feed.parse_last_change(request_value('last_change')),
           limit: request_value('limit')
         )
 
         document = SpreeCmCommissioner::Integrations::SwitchCm::Xml::ResponseBuilder.build(response_root, ruid: ruid) do |xml|
-          reservations.each { |reservation| SpreeCmCommissioner::Integrations::SwitchCm::Xml::ReservationPresenter.new(reservation).build(xml) }
+          reservations.each { |reservation| SpreeCmCommissioner::Integrations::SwitchCm::Xml::ReservationSerializer.new(reservation).build(xml) }
         end
 
         # Marked only once the document is built. One that fails to mark is simply returned
@@ -35,7 +35,7 @@ module Spree::Api::SwitchCm
 
       def mark_seen(reservations)
         reservations.each_with_object([]) do |reservation, failed|
-          SpreeCmCommissioner::Integrations::SwitchCm::MarkSeen.call(
+          SpreeCmCommissioner::Integrations::SwitchCm::Reservations::MarkSeen.call(
             integration: reservation.integration, order: reservation.order, status: reservation.status
           )
         rescue StandardError => e

data/app/controllers/spree/api/switch_cm/xml/room_rate_availabilities_controller.rb

@@ -13,7 +13,7 @@ module Spree::Api::SwitchCm
         days = (request_value('number_of_days').presence || DAYS_RANGE.max).to_i
         return render_fault(:bad_request, "number_of_days must be between #{DAYS_RANGE.min} and #{DAYS_RANGE.max}") unless DAYS_RANGE.cover?(days)
 
-        rows = SpreeCmCommissioner::Integrations::SwitchCm::AvailabilityReadback.new(
+        rows = SpreeCmCommissioner::Integrations::SwitchCm::Inventory::AvailabilitySnapshot.new(
           integration: current_integration,
           dates: (start_date...(start_date + days)).to_a,
           room_id: request_value('room_id')

data/app/controllers/spree/api/v2/storefront/draft_orders_controller.rb

@@ -12,7 +12,9 @@ module Spree
           # Creates a generic draft order from a locally-assembled cart in a single request.
           # Endpoint: POST /api/v2/storefront/draft_orders
           # Params:
-          # - line_items: Array of { variant_id:, quantity:, options: {}, public_metadata: {}, private_metadata: {} } (required)
+          # - line_items: Array of { variant_id:, quantity:, options: { from_date:, to_date:, guests_attributes: [] },
+          #   public_metadata: {}, private_metadata: {} } (required) — guests_attributes fields mirror the checkout
+          #   API's line_items_attributes.guests_attributes (see Spree::PermittedAttributes checkout_attributes).
           # - st: private sale token granting this order the product's locked stock (optional).
           def create
             result = SpreeCmCommissioner::DraftOrders::Create.call(
@@ -45,8 +47,44 @@ module Spree
           end
 
           def draft_order_line_items
-            params.permit(line_items: [:variant_id, :quantity, { options: {}, public_metadata: {}, private_metadata: {} }])
-                  .fetch(:line_items, [])
+            params.permit(
+              line_items: [
+                :variant_id,
+                :quantity,
+                {
+                  options: [
+                    :from_date,
+                    :to_date,
+                    {
+                      guests_attributes: [
+                        :block_id,
+                        :first_name,
+                        :last_name,
+                        :address,
+                        :dob,
+                        :gender,
+                        :occupation_id,
+                        :other_occupation,
+                        :nationality_id,
+                        :age,
+                        :emergency_contact,
+                        :phone_number,
+                        :other_organization,
+                        :social_contact,
+                        :social_contact_platform,
+                        :expectation,
+                        :country_code,
+                        :upload_later,
+                        :contact,
+                        { guest_dynamic_fields_attributes: %i[dynamic_field_id dynamic_field_option_id value] }
+                      ]
+                    }
+                  ],
+                  public_metadata: {},
+                  private_metadata: {}
+                }
+              ]
+            ).fetch(:line_items, [])
           end
 
           def draft_order_products

data/app/controllers/spree/api/v2/storefront/guest_qrs_controller.rb

@@ -9,6 +9,8 @@ module Spree
           before_action :load_guest, only: [:show]
 
           def show
+            return head :not_found if @guest.qr_data.blank?
+
             respond_to do |format|
               format.png { send_data @guest.generate_png_qr, type: 'image/png', disposition: 'inline' }
               format.svg { send_data @guest.generate_svg_qr, type: 'image/svg+xml', disposition: 'inline' }

data/app/models/spree_cm_commissioner/guest.rb

@@ -201,6 +201,8 @@ module SpreeCmCommissioner
     end
 
     def generate_svg_qr
+      return nil if qr_data.blank?
+
       qrcode = RQRCode::QRCode.new(qr_data)
       qrcode.as_svg(
         color: '000',
@@ -213,6 +215,8 @@ module SpreeCmCommissioner
     end
 
     def generate_png_qr(size = 120)
+      return nil if qr_data.blank?
+
       qrcode = RQRCode::QRCode.new(qr_data)
       qrcode.as_png(
         bit_depth: 1,
@@ -228,7 +232,11 @@ module SpreeCmCommissioner
       )
     end
 
+    # Transferred guests no longer own the ticket, so they must not receive any
+    # scannable QR data. The ownership moved to the guest created by
+    # SpreeCmCommissioner::TicketTransfers::TransferGuest.
     def qr_data
+      return nil if transferred?
       return external_qr_data if external_qr_data.present?
 
       token

data/app/models/spree_cm_commissioner/integration.rb

@@ -22,22 +22,10 @@ module SpreeCmCommissioner
         .sort
     end
 
-    # Integrations the partner calls into (rather than us pulling from them) have no sync_manager
-    # and override this to false. Class-level so the pollable scope can filter on `type`.
-    def self.supports_polling?
-      true
-    end
-
-    scope :pollable, -> { where(type: types.select { |type| type.constantize.supports_polling? }) }
-
     def sync_manager
       raise NotImplementedError, 'Subclasses must implement the sync_manager method'
     end
 
-    def supports_polling?
-      self.class.supports_polling?
-    end
-
     # Whether the partner, not BookMe+, sets this variant's per-night stock, prices and closings.
     # When true, stock resets and dashboard edits leave its inventory items alone, and new nights
     # start closed until the partner opens them (InventoryItem). Off by default.

data/app/models/spree_cm_commissioner/integrations/switch_cm.rb

@@ -1,6 +1,7 @@
 # A hotel connected to switch.cm, which calls our Booking.com-compatible channel-manager API
 # (Spree::Api::SwitchCm) instead of us calling it: it pushes availability, prices and
-# restrictions, and pulls reservations. So there's nothing to poll, hold or unstock externally.
+# restrictions, and pulls reservations. So there's nothing to pull, hold or unstock externally;
+# polling only runs our own checks (SyncManager).
 #
 # Every switch.cm row shares one Doorkeeper app; the hotels switch.cm may manage are the rows
 # pointing at it. `paused` is the setup state: switch.cm can read the hotel (room list,
@@ -18,11 +19,16 @@ class SpreeCmCommissioner::Integrations::SwitchCm < SpreeCmCommissioner::Integra
   before_create :set_connected_at
   after_commit :sync_unpushed_nights, on: %i[create update]
 
+  # Polling runs the hotel's periodic checks (SyncManager), and the incremental one alerts on
+  # every run while reservations sit unpulled, so the column's 10-second default would flood
+  # Telegram. Full runs daily upkeep.
+  attribute :incremental_sync_interval_seconds, :integer, default: -> { SyncStrategies::IncrementalSyncStrategy::UNSEEN_AFTER.to_i }
+
   scope :readable, -> { where(status: READABLE_STATUSES) }
 
   # override
-  def self.supports_polling?
-    false
+  def sync_manager
+    SyncManager.new(integration: self)
   end
 
   # Only for rooms switch.cm can see (RoomCatalog): a hotel's other products, and rooms that need
@@ -60,7 +66,7 @@ class SpreeCmCommissioner::Integrations::SwitchCm < SpreeCmCommissioner::Integra
   # While switch.cm owns the rooms, nights it hasn't pushed stay closed, so the admin page shows
   # this until the first full push lands.
   def push_progress
-    PushedNights.new(self).progress
+    Inventory::PushedNights.new(self).progress
   end
 
   private
@@ -75,6 +81,6 @@ class SpreeCmCommissioner::Integrations::SwitchCm < SpreeCmCommissioner::Integra
     owned_before = status_before_last_save.to_s == 'active' && conflict_strategy_before_last_save.to_s == 'external_wins'
     return if owned_before == owns_inventory?
 
-    owns_inventory? ? PushedNights.new(self).close_unpushed! : PushedNights.new(self).reopen_unpushed!
+    Inventory::PushedNights.new(self).reconcile_unpushed!
   end
 end

data/app/serializers/spree_cm_commissioner/v2/storefront/cart_serializer_decorator.rb

@@ -10,7 +10,8 @@ module SpreeCmCommissioner
           base.attributes :phone_number, :intel_phone_number, :country_code, :request_state,
                           :term_accepted_at,
                           :channel, :hold_expires_at,
-                          :service_fee_total, :display_service_fee_total
+                          :service_fee_total, :display_service_fee_total,
+                          :order_total_after_store_credit, :display_order_total_after_store_credit
 
           base.attribute :has_incomplete_guest_info, &:has_incomplete_guest_info?
           base.attribute :required_payway_payout, &:required_payway_payout?

data/app/services/spree_cm_commissioner/integrations/polling_scheduler.rb

@@ -4,7 +4,7 @@ module SpreeCmCommissioner
       BATCH_SIZE = 10 # Process integrations in batches to avoid overwhelming the server
 
       def call
-        SpreeCmCommissioner::Integration.active.pollable.find_each(batch_size: BATCH_SIZE) do |integration|
+        SpreeCmCommissioner::Integration.active.find_each(batch_size: BATCH_SIZE) do |integration|
           if should_run_full_sync?(integration)
             schedule_full_sync(integration)
           elsif should_run_incremental_sync?(integration)

data/app/services/spree_cm_commissioner/integrations/switch_cm/inventory/accept_push.rb

@@ -0,0 +1,103 @@
+class SpreeCmCommissioner::Integrations::SwitchCm
+  module Inventory
+    # Booking.com's push contract: validated and applied before we answer, and the answer is the real
+    # outcome. It stays affordable because Booking.com asks for one hotel and one month per request,
+    # so a connector built for it already sends month-sized pushes; a larger one is rejected so it
+    # knows to split, rather than queued.
+    #
+    # outcome: :applied (200), :rejected (400, nothing valid or over a month), :busy (503, another
+    # push for this hotel held the lock too long), :failed (500, the apply raised). The channel
+    # manager resends :busy and :failed, which is safe because every write is absolute.
+    #
+    # Every push is logged as an IntegrationSyncSession, written after the lock is released.
+    class AcceptPush
+      prepend ::Spree::ServiceModule::Base
+
+      MAX_SPAN_DAYS = 31
+      LOCK_WAIT = 5.seconds
+      HTTP_STATUS = { applied: :ok, rejected: :bad_request, busy: :service_unavailable, failed: :internal_server_error }.freeze
+
+      def call(integration:, message:, updates:, request_id:)
+        started_at = Time.current
+        validation = ValidateUpdates.call(integration: integration, updates: updates).value
+        outcome, applied = apply(integration, validation)
+        add_missing_nights_warning(validation, applied) if outcome == :applied
+
+        request = { message: message, request_id: request_id, started_at: started_at }
+        session = log_session!(integration, request, validation, outcome, applied)
+        log_attention(session, outcome, applied)
+
+        success(validation.merge(outcome: outcome, session: session))
+      end
+
+      private
+
+      def apply(integration, validation)
+        accepted = validation[:accepted]
+        return [:rejected, nil] if accepted.empty?
+
+        unless within_one_month?(accepted)
+          validation[:errors] << { code: 'REQUEST_SPANS_MORE_THAN_ONE_MONTH', message: 'Send at most one month per request', index: nil }
+          return [:rejected, nil]
+        end
+
+        result = AccommodationLock.with_lock(integration, wait: LOCK_WAIT) { ApplyUpdates.new(integration: integration).call(accepted) }
+        result == AccommodationLock::BUSY ? [:busy, nil] : [:applied, result]
+      rescue StandardError => e
+        [:failed, { error_class: e.class.name, error_message: e.message, backtrace: e.backtrace&.first(5) }]
+      end
+
+      def within_one_month?(accepted)
+        (accepted.map(&:date_to).max - accepted.map(&:date_from).min).to_i < MAX_SPAN_DAYS
+      end
+
+      def add_missing_nights_warning(validation, applied)
+        return unless applied[:missing_nights].positive?
+
+        validation[:warnings] << {
+          code: 'NIGHTS_NOT_OPEN_FOR_SALE',
+          message: "#{applied[:missing_nights]} night(s) have no inventory on BookMe+ yet and were skipped",
+          index: nil
+        }
+      end
+
+      def log_session!(integration, request, validation, outcome, applied)
+        SpreeCmCommissioner::IntegrationSyncSession.create!(
+          integration: integration,
+          tenant: integration.tenant,
+          sync_type: :webhook_triggered,
+          status: outcome == :applied ? :completed : :failed,
+          started_at: request[:started_at],
+          ended_at: Time.current,
+          sync_result: {
+            message: request[:message],
+            request_id: request[:request_id],
+            outcome: outcome,
+            accepted: validation[:accepted].size,
+            room_nights: validation[:accepted].sum(&:nights),
+            errors: validation[:errors],
+            warnings: validation[:warnings],
+            applied: applied
+          }
+        )
+      end
+
+      # Worth a look: pushes we didn't apply, and nights where holds kept stock above the pushed count.
+      def log_attention(session, outcome, applied)
+        clamped = outcome == :applied ? applied[:clamped_nights] : []
+        return if outcome == :applied && clamped.empty?
+
+        CmAppLogger.log(
+          label: "#{self.class.name}#call",
+          data: {
+            session_id: session.id,
+            integration_id: session.integration_id,
+            outcome: outcome,
+            clamped_nights: clamped,
+            failure: (applied if outcome == :failed)
+          }
+        )
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/integrations/switch_cm/inventory/accommodation_lock.rb

@@ -0,0 +1,43 @@
+class SpreeCmCommissioner::Integrations::SwitchCm
+  module Inventory
+    # One push per hotel at a time, so pushes land in arrival order and two pushes never interleave
+    # their per-night deltas. A session-level Postgres advisory lock, like
+    # InventoryHolds::Acquire#with_advisory_lock!, but waiting briefly instead of failing at once:
+    # a connector resends on 503, and a short wait usually saves it the round trip.
+    module AccommodationLock
+      BUSY = Object.new.freeze
+      POLL_INTERVAL = 0.1
+
+      # Yields and returns the block's value, or BUSY if another push for this hotel still holds the
+      # lock after `wait`.
+      def self.with_lock(integration, wait:)
+        lock_id = lock_id(integration)
+        deadline = Time.current + wait
+
+        acquired = try_lock(lock_id)
+        until acquired || Time.current >= deadline
+          sleep POLL_INTERVAL
+          acquired = try_lock(lock_id)
+        end
+        return BUSY unless acquired
+
+        begin
+          yield
+        ensure
+          ActiveRecord::Base.connection.execute("SELECT pg_advisory_unlock(#{lock_id})")
+        end
+      end
+
+      # select_value returns true (pg adapter >= 1.0) or "t" (older adapters).
+      def self.try_lock(lock_id)
+        [true, 't'].include?(ActiveRecord::Base.connection.select_value("SELECT pg_try_advisory_lock(#{lock_id})"))
+      end
+
+      def self.lock_id(integration)
+        Zlib.crc32("spree_cm_commissioner:switch_cm_push:#{integration.id}")
+      end
+
+      private_class_method :try_lock, :lock_id
+    end
+  end
+end

data/app/services/spree_cm_commissioner/integrations/switch_cm/inventory/apply_updates.rb

@@ -0,0 +1,121 @@
+class SpreeCmCommissioner::Integrations::SwitchCm
+  module Inventory
+    # Writes validated updates to the hotel's inventory rows. Callers hold the hotel's
+    # AccommodationLock, so this never logs; it returns what happened for the caller to log.
+    #
+    # Pushed rooms to sell is an absolute "rooms BookMe+ may still sell", applied as a delta:
+    #
+    # 1. Subtract rooms on BookMe+ reservations the channel manager hasn't seen (UnseenRoomNights),
+    #    and the night's withheld (locked) pool, which is sold on top of public stock.
+    # 2. Never go below rooms held by guests already paying, so their holds can still convert;
+    #    otherwise conversion would take Redis negative and its async DB sync would fail validation.
+    #    When this clamps, we've sold more than the channel manager allowed: returned for an alert.
+    # 3. Set Redis stock in one Lua script that returns the delta, then add that delta to the row's
+    #    quantity_available and max_capacity. Relative, so it commutes with BulkAdjustQuantities jobs
+    #    still in flight for the row; an absolute write would be undone by them.
+    #
+    # Closing and prices are plain writes: the row's `closed`, and the per-night Spree::Price row
+    # Variant#price_for_date reads. A night's first availability push also opens it (PushedNights),
+    # unless the same update closes it.
+    class ApplyUpdates
+      # KEYS: stock, hold. ARGV: target, ttl. Returns [final - stock, final].
+      SET_STOCK_SCRIPT = <<~LUA.freeze
+        local stock = tonumber(redis.call('GET', KEYS[1]) or 0)
+        local held = tonumber(redis.call('GET', KEYS[2]) or 0)
+        local target = tonumber(ARGV[1])
+        local final = math.max(target, held)
+        redis.call('SET', KEYS[1], final, 'EX', tonumber(ARGV[2]))
+        return { final - stock, final }
+      LUA
+
+      def initialize(integration:)
+        @integration = integration
+        @unseen = UnseenRoomNights.new(integration)
+        @pushed_nights = PushedNights.new(integration)
+      end
+
+      def call(updates)
+        outcome = { room_nights: 0, missing_nights: 0, clamped_nights: [] }
+
+        updates.each do |update|
+          dates = update.dates
+          items = SpreeCmCommissioner::InventoryItem.where(variant_id: update.room_id, inventory_date: dates).order(:inventory_date).to_a
+          outcome[:missing_nights] += dates.size - items.size
+          next if items.empty?
+
+          write_closed(items.map(&:id), update.closed) unless update.closed.nil?
+          write_prices(items, update) if update.price
+          if update.rooms_to_sell
+            outcome[:clamped_nights].concat(write_availability(items, update, dates))
+            mark_pushed(items, update)
+          end
+          outcome[:room_nights] += items.size
+        end
+
+        outcome
+      end
+
+      private
+
+      def write_closed(item_ids, closed)
+        SpreeCmCommissioner::InventoryItem.where(id: item_ids).update_all( # rubocop:disable Rails/SkipsModelValidations
+          ['closed = :closed, lock_version = lock_version + 1, updated_at = :now', { closed: closed, now: Time.current }]
+        )
+      end
+
+      def mark_pushed(items, update)
+        first_pushed = items.map(&:id) - @pushed_nights.pushed_at_by_item_id(items).keys
+
+        SpreeCmCommissioner::InventoryItem.transaction do
+          write_closed(first_pushed, false) if update.closed.nil? && first_pushed.any?
+          @pushed_nights.record!(items, at: Time.current)
+        end
+      end
+
+      def write_prices(items, update)
+        items.each do |item|
+          price = Spree::Price.find_or_initialize_by(variant_id: item.variant_id, inventory_item_id: item.id, currency: update.currency)
+          price.update!(amount: update.price) if price.new_record? || price.amount != update.price
+        end
+      end
+
+      # Returns the nights where in-flight holds kept stock above the target.
+      def write_availability(items, update, dates)
+        # A cold key reads as 0 in the script; seed every pool from the row first (SET NX).
+        cached = SpreeCmCommissioner::RedisStock::CachedInventoryItemsBuilder.new(items).call.index_by(&:inventory_item_id)
+        unseen = @unseen.by_date(update.room_id, dates)
+
+        items.filter_map do |item|
+          target = [update.rooms_to_sell - unseen[item.inventory_date] - cached[item.id].quantity_locked, 0].max
+          delta, final = set_stock(item, target)
+          add_delta!(item, delta)
+
+          { room_id: item.variant_id, date: item.inventory_date, target: target, held: final } if final > target
+        end
+      end
+
+      def set_stock(item, target)
+        SpreeCmCommissioner.inventory_redis_pool.with do |redis|
+          redis.eval(SET_STOCK_SCRIPT, keys: [item.redis_key, item.redis_hold_key], argv: [target, item.redis_expired_in])
+        end
+      end
+
+      # Bumps lock_version so a writer holding a stale copy of the row fails instead of overwriting.
+      # If the row can't take the delta, Redis is put back by the same delta, which commutes with any
+      # sale that landed in between; the push then fails and the channel manager resends it.
+      def add_delta!(item, delta)
+        # A relative SQL update is the point here (see the class comment), so no model save.
+        SpreeCmCommissioner::InventoryItem.where(id: item.id).update_all( # rubocop:disable Rails/SkipsModelValidations
+          [
+            'quantity_available = quantity_available + :delta, max_capacity = max_capacity + :delta, ' \
+            'lock_version = lock_version + 1, updated_at = :now',
+            { delta: delta, now: Time.current }
+          ]
+        )
+      rescue StandardError
+        SpreeCmCommissioner.inventory_redis_pool.with { |redis| redis.incrby(item.redis_key, -delta) } unless delta.zero?
+        raise
+      end
+    end
+  end
+end