spree_cm_commissioner 2.13.2 → 2.13.3.pre.pre2

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

@@ -0,0 +1,83 @@
+module Spree::Api::SwitchCm
+  module Ota
+    # Booking.com's two OTA reservation streams share one shape; subclasses name the stream.
+    class ReservationStreamsController < BaseController
+      # GET /api/switch_cm/hotels/ota/OTA_HotelResNotif (ResNotifsController): new reservations
+      # GET /api/switch_cm/hotels/ota/OTA_HotelResModifyNotif (ResModifyNotifsController): cancellations
+      # ?hotel_ids=&id=&last_change=&limit= returns what hasn't been acknowledged; `id` or
+      # `last_change` re-reads regardless.
+      def index
+        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(
+          feed_method,
+          id: params[:id],
+          last_change: SpreeCmCommissioner::Integrations::SwitchCm::ReservationFeed.parse_last_change(params[:last_change]),
+          limit: params[:limit]
+        )
+
+        document = SpreeCmCommissioner::Integrations::SwitchCm::Ota::ResponseBuilder.notification(
+          notification_root, ruid: ruid, warnings: hotel_warnings(unknown_hotel_ids)
+        ) do |xml|
+          xml.send(container) do
+            reservations.each do |reservation|
+              present(SpreeCmCommissioner::Integrations::SwitchCm::Ota::ReservationPresenter.new(reservation), xml)
+            end
+          end
+        end
+        render xml: document
+      end
+
+      # POST /api/switch_cm/hotels/ota/OTA_HotelResNotif (ResNotifsController)
+      # POST /api/switch_cm/hotels/ota/OTA_HotelResModifyNotif (ResModifyNotifsController)
+      # Acknowledges by reservation id: <...RS><Success/><...><HotelReservationID ResID_Value="..."/></...></...RS>
+      def acknowledge
+        # Booking.com's contract: <Success/> takes the reservations off the queue, while <Errors>
+        # (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(
+          integrations: switch_cm_integrations.includes(:vendor).to_a,
+          reservation_ids: request_document.xpath('//HotelReservationID/@ResID_Value').map(&:value),
+          status: acknowledged_status
+        )
+
+        warnings = result.value[:unknown].map do |reservation_id|
+          { type: 3, text: "Reservation #{reservation_id} not found for acknowledgement", record_id: reservation_id }
+        end
+        render_success(warnings: warnings)
+      end
+
+      private
+
+      def feed_method
+        raise NotImplementedError, "#{self.class.name} must implement feed_method"
+      end
+
+      def acknowledged_status
+        raise NotImplementedError, "#{self.class.name} must implement acknowledged_status"
+      end
+
+      def notification_root
+        raise NotImplementedError, "#{self.class.name} must implement notification_root"
+      end
+
+      def container
+        raise NotImplementedError, "#{self.class.name} must implement container"
+      end
+
+      def present(_presenter, _xml)
+        raise NotImplementedError, "#{self.class.name} must implement present"
+      end
+
+      def processing_failed?
+        request_document.at_xpath('/*/Errors').present? && request_document.at_xpath('/*/Success').nil?
+      end
+
+      def hotel_warnings(unknown_hotel_ids)
+        unknown_hotel_ids.map { |hotel_id| { type: 6, text: "Not authorized for hotel #{hotel_id}", record_id: hotel_id } }
+      end
+    end
+  end
+end

data/app/controllers/spree/api/switch_cm/tokens_controller.rb

@@ -0,0 +1,68 @@
+module Spree::Api::SwitchCm
+  class TokensController < BaseController
+    # Booking.com's tokens also last an hour; connectors refresh on that schedule.
+    TOKEN_LIFETIME = 1.hour
+
+    skip_before_action :authenticate_switch_cm!
+
+    # POST /api/switch_cm/token-based-authentication/exchange
+    # Client id and secret in (JSON or XML), { jwt, ruid } out, then `Authorization: Bearer` on every
+    # other call. The value is a Doorkeeper access token rather than a signed JWT, so a connector
+    # that only forwards it works but one that decodes it won't.
+    def create
+      client_id, client_secret = credentials
+      return render_fault(:bad_request, 'client_id and client_secret are required') if client_id.blank? || client_secret.blank?
+
+      @oauth_application = Spree::OauthApplication.find_by(uid: client_id)
+      unless @oauth_application&.secret_matches?(client_secret) && switch_cm_integrations.exists?
+        return render_fault(:unauthorized, 'Invalid client credentials')
+      end
+
+      render_token(issue_token.plaintext_token)
+    end
+
+    private
+
+    def issue_token
+      Spree::OauthAccessToken.create_for(
+        application: @oauth_application,
+        resource_owner: nil,
+        scopes: '',
+        expires_in: TOKEN_LIFETIME.to_i,
+        use_refresh_token: false
+      )
+    end
+
+    def credentials
+      return [params[:client_id], params[:client_secret]] unless xml_request?
+
+      %w[client_id client_secret].map { |name| request_document.at_xpath("/request/#{name}")&.text&.strip }
+    end
+
+    def xml_request?
+      request.content_mime_type&.symbol == :xml
+    end
+
+    def render_token(token)
+      return render json: { jwt: token, ruid: ruid } unless xml_request?
+
+      document = SpreeCmCommissioner::Integrations::SwitchCm::Xml::ResponseBuilder.build('response', ruid: ruid) do |xml|
+        xml.jwt token
+        xml.ruid ruid
+      end
+      render xml: document
+    end
+
+    # override
+    def render_fault(status, text, code: nil)
+      code ||= Rack::Utils.status_code(status)
+
+      if xml_request?
+        render xml: SpreeCmCommissioner::Integrations::SwitchCm::Xml::ResponseBuilder.fault('response', code: code, text: text, ruid: ruid),
+               status: status
+      else
+        render json: { errors: [{ code: code, message: text }], ruid: ruid }, status: status
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Spree::Api::SwitchCm
+  module Xml
+    class AvailabilitiesController < BaseController
+      before_action :require_active_integration!
+
+      # 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.
+      def create
+        result = SpreeCmCommissioner::Integrations::SwitchCm::AcceptPush.call(
+          integration: current_integration,
+          message: 'availability',
+          updates: parser.updates,
+          request_id: ruid
+        )
+
+        push_response = SpreeCmCommissioner::Integrations::SwitchCm::Xml::PushResponse.new(result: result.value, ruid: ruid)
+        render xml: push_response.to_xml, status: push_response.http_status
+      end
+
+      private
+
+      # override
+      def response_root
+        'availability'
+      end
+
+      def parser
+        @parser ||= SpreeCmCommissioner::Integrations::SwitchCm::Xml::AvailabilityParser.new(request_document)
+      end
+
+      # B.XML pushes carry no hotel id; the rooms name it.
+      # override
+      def accommodation_id_from_request
+        vendor_id_of_room(parser.first_room_id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Spree::Api::SwitchCm
+  module Xml
+    # Booking.com's B.XML family (/hotels/xml/...): a request that fails as a whole answers with
+    # a <fault code string/> under the call's root element. Requests carry their parameters
+    # in a <request> body.
+    class BaseController < Spree::Api::SwitchCm::BaseController
+      private
+
+      def response_root
+        raise NotImplementedError, "#{self.class.name} must implement response_root"
+      end
+
+      # override
+      def render_fault(status, text, code: nil)
+        code ||= Rack::Utils.status_code(status)
+        render xml: SpreeCmCommissioner::Integrations::SwitchCm::Xml::ResponseBuilder.fault(response_root, code: code, text: text, ruid: ruid),
+               status: status
+      end
+
+      def render_document(&block)
+        render xml: SpreeCmCommissioner::Integrations::SwitchCm::Xml::ResponseBuilder.build(response_root, ruid: ruid, &block)
+      end
+
+      # override
+      def accommodation_id_from_request
+        request_value('hotel_id')
+      end
+
+      # A parameter from the <request> body, falling back to the query string.
+      def request_value(name)
+        return params[name] if request.raw_post.blank?
+
+        request_document.at_xpath("/request/#{name}")&.text&.strip.presence || params[name]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+module Spree::Api::SwitchCm
+  module Xml
+    class ReservationSummariesController < BaseController
+      before_action :require_integration!
+
+      # POST /api/switch_cm/hotels/xml/reservationssummary with <request><hotel_id/></request>
+      # The hotel's confirmed stays checking out from tomorrow on, however long ago they were
+      # 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
+
+        render_document do |xml|
+          reservations.each do |reservation|
+            SpreeCmCommissioner::Integrations::SwitchCm::Xml::ReservationPresenter.new(reservation, summary: true).build(xml)
+          end
+        end
+      end
+
+      private
+
+      # override
+      def response_root
+        'reservations'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Spree::Api::SwitchCm
+  module Xml
+    class ReservationsController < BaseController
+      # POST /api/switch_cm/hotels/xml/reservations with <request><hotel_id/><last_change/><limit/><id/></request>
+      # New and cancelled reservations in one stream. B.XML has no acknowledgement, so returning a
+      # reservation is what marks it seen; `last_change` re-reads recent ones regardless.
+      def create
+        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(
+          id: request_value('id'),
+          last_change: SpreeCmCommissioner::Integrations::SwitchCm::ReservationFeed.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) }
+        end
+
+        # Marked only once the document is built. One that fails to mark is simply returned
+        # again next time, which is harmless: its status is the same.
+        failed = mark_seen(reservations)
+        log_mark_seen_failures(failed) if failed.any?
+
+        render xml: document
+      end
+
+      private
+
+      # override
+      def response_root
+        'reservations'
+      end
+
+      def mark_seen(reservations)
+        reservations.each_with_object([]) do |reservation, failed|
+          SpreeCmCommissioner::Integrations::SwitchCm::MarkSeen.call(
+            integration: reservation.integration, order: reservation.order, status: reservation.status
+          )
+        rescue StandardError => e
+          failed << {
+            order_id: reservation.id,
+            integration_id: reservation.integration.id,
+            error_class: e.class.name,
+            error_message: e.message
+          }
+        end
+      end
+
+      def log_mark_seen_failures(failed)
+        CmAppLogger.error(label: "#{self.class.name}#mark_seen failed", data: { ruid: ruid, failed: failed })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+module Spree::Api::SwitchCm
+  module Xml
+    class RoomRateAvailabilitiesController < BaseController
+      DAYS_RANGE = (1..31)
+
+      before_action :require_integration!
+
+      # POST /api/switch_cm/hotels/xml/roomrateavailability with <request><hotel_id/><start_date/><number_of_days/><room_id/></request>
+      # What we hold per room and night, so the channel manager can check its pushes landed.
+      # number_of_days is 1-31, 31 by default, as at Booking.com.
+      def create
+        start_date = parse_date(request_value('start_date')) || Time.zone.today
+        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(
+          integration: current_integration,
+          dates: (start_date...(start_date + days)).to_a,
+          room_id: request_value('room_id')
+        ).rows
+
+        render_document { |xml| rows.each { |row| build_row(xml, row) } }
+      end
+
+      private
+
+      # override
+      def response_root
+        'result'
+      end
+
+      def build_row(xml, row)
+        xml.roomrate(
+          {
+            date: row.date.iso8601,
+            room_id: row.room_id,
+            rate_id: row.rate_id,
+            rooms_to_sell: row.rooms_to_sell,
+            booked: row.booked,
+            cancelled: row.cancelled,
+            closed: row.closed ? 1 : 0,
+            price: row.price && format('%.2f', row.price),
+            currency: row.currency,
+            pushed_at: row.pushed_at&.utc&.iso8601
+          }.compact
+        )
+      end
+
+      def parse_date(value)
+        Date.iso8601(value) if value.present?
+      rescue Date::Error
+        nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+module Spree::Api::SwitchCm
+  module Xml
+    class RoomRatesController < BaseController
+      before_action :require_integration!
+
+      # POST /api/switch_cm/hotels/xml/roomrates with <request><hotel_id/></request>
+      # The hotel's rooms, each with its rates, which the channel manager maps to its own
+      # ("Refresh Room" in switch.cm).
+      def create
+        vendor = current_integration.vendor
+        rooms = SpreeCmCommissioner::Integrations::SwitchCm::RoomCatalog.new(vendor).rooms
+
+        render_document do |xml|
+          rooms.each do |room|
+            xml.room(id: room.id, hotel_id: vendor.id, hotel_name: vendor.name, room_name: room.name, max_children: room.max_children) do
+              xml.rates do
+                xml.rate(id: room.rate_id, rate_name: room.rate_name, max_persons: room.max_persons, is_child_rate: 0, readonly: 0)
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      # override
+      def response_root
+        'rooms'
+      end
+    end
+  end
+end

data/app/controllers/spree/api/v2/operator/check_ins_controller.rb

@@ -3,6 +3,8 @@ module Spree
     module V2
       module Operator
         class CheckInsController < ::Spree::Api::V2::ResourceController
+          include SpreeCmCommissioner::Operator::EventAuthorization
+
           before_action :require_spree_current_user, only: %i[index create]
 
           # Check-in history data requires fresh/recent data for operator dashboards
@@ -45,15 +47,14 @@ module Spree
 
           private
 
-          # Non-organizers may only see check-in history for an event they're assigned
-          # to, and only while it's ongoing — once it ends, it becomes organizer-owned
-          # history (admins assign themselves the organizer role explicitly if they
-          # need access). A missing/nonexistent taxon_id is restricted the same way.
+          # The organizer who owns the event's vendor always sees check-in history.
+          # Crew/operators assigned via user.events only see it while the event is
+          # ongoing — once it ends, it becomes organizer-owned history. A missing/
+          # nonexistent taxon_id is restricted the same way.
           def restricted?
-            return false if spree_current_user.organizer?
-
             taxon = Spree::Taxon.find_by(id: params[:taxon_id])
             return true if taxon.nil?
+            return false if organizer_for_event?(taxon)
             return true unless spree_current_user.events.exists?(id: taxon.id)
 
             taxon.ended?

data/app/controllers/spree/api/v2/operator/event_charts_controller.rb

@@ -3,6 +3,10 @@ module Spree
     module V2
       module Operator
         class EventChartsController < ::Spree::Api::V2::ResourceController
+          include SpreeCmCommissioner::Operator::EventAuthorization
+
+          before_action :require_spree_current_user
+
           ACCEPTED_KYC_FIELDS = %i[guest_gender guest_occupation guest_nationality].freeze
           ADDITIONAL_FIELDS = %i[participation entry_type].freeze
 
@@ -40,18 +44,12 @@ module Spree
 
           private
 
-          # Non-organizers may only see chart data for an event they're assigned to,
-          # and only while it's ongoing — once it ends, it becomes organizer-owned
-          # history (admins assign themselves the organizer role explicitly if they
-          # need access). A missing/nonexistent taxon_id is restricted the same way.
+          # Only the organizer who owns the event's vendor may see chart data —
+          # crew/operators assigned via user.events never see it, regardless of
+          # whether the event is ongoing or ended. See organizer_for_event? (EventAuthorization).
           def restricted?
-            return false if spree_current_user&.organizer?
-
             taxon = Spree::Taxon.find_by(id: params[:taxon_id])
-            return true if taxon.nil?
-            return true unless spree_current_user&.events&.exists?(id: taxon.id)
-
-            taxon.ended?
+            !organizer_for_event?(taxon)
           end
 
           def event_chart_aggregator_queries

data/app/controllers/spree/api/v2/operator/event_ticket_aggregators_controller.rb

@@ -3,11 +3,21 @@ module Spree
     module V2
       module Operator
         class EventTicketAggregatorsController < ::Spree::Api::V2::ResourceController
+          include SpreeCmCommissioner::Operator::EventAuthorization
+
+          before_action :require_spree_current_user
+
           def resource
-            @resource = SpreeCmCommissioner::EventTicketAggregatorQuery.new(
-              taxon_id: params[:taxon_id],
-              refreshed: params[:refreshed] || false
-            ).call
+            taxon = Spree::Taxon.find_by(id: params[:taxon_id])
+
+            @resource = if organizer_for_event?(taxon)
+                          SpreeCmCommissioner::EventTicketAggregatorQuery.new(
+                            taxon_id: params[:taxon_id],
+                            refreshed: params[:refreshed] || false
+                          ).call
+                        else
+                          SpreeCmCommissioner::EventTicketAggregator.new(id: params[:taxon_id], value: [])
+                        end
           end
 
           def resource_serializer

data/app/controllers/spree/api/v2/operator/pie_chart_event_aggregators_controller.rb

@@ -3,8 +3,22 @@ module Spree
     module V2
       module Operator
         class PieChartEventAggregatorsController < ::Spree::Api::V2::ResourceController
+          include SpreeCmCommissioner::Operator::EventAuthorization
+
+          before_action :require_spree_current_user
+
           def resource
-            @resource = pie_chart_event_aggregator_queries.call
+            taxon = Spree::Taxon.find_by(id: params[:taxon_id])
+
+            @resource = if organizer_for_event?(taxon)
+                          pie_chart_event_aggregator_queries.call
+                        else
+                          SpreeCmCommissioner::EventChart.new(
+                            id: params[:chart_type] || 'participation',
+                            chart_type: params[:chart_type] || 'participation',
+                            product_charts: []
+                          )
+                        end
           end
 
           def resource_serializer

data/app/controllers/spree/api/v2/platform/homepage_section_relatable_options_controller.rb

@@ -14,6 +14,34 @@ module Spree
           def resource_serializer
             ::SpreeCmCommissioner::Api::V2::Platform::HomepageSectionRelatableOptionsSerializer
           end
+
+          # Opt-in only (params[:taxon_scope] == 'events'/params[:tenant_id]), so existing callers
+          # that search across all taxons/vendors (e.g. ticket transfer rules, homepage sections)
+          # are unaffected.
+          def scope
+            result = super
+            result = result.merge(Spree::Taxon.events) if model_class == Spree::Taxon && params[:taxon_scope] == 'events'
+            result = scoped_to_tenant(result) if params[:tenant_id].present?
+
+            result
+          end
+
+          private
+
+          # Product has its own tenant_id (set from its vendor — see
+          # SpreeCmCommissioner::ProductDecorator#set_tenant). Taxon (Event) has no tenant_id
+          # column of its own, so it's derived through the products that reference it as their
+          # event.
+          def scoped_to_tenant(result)
+            case model_class.name
+            when 'Spree::Vendor', 'Spree::Product'
+              result.where(tenant_id: params[:tenant_id])
+            when 'Spree::Taxon'
+              result.where(id: Spree::Product.where(tenant_id: params[:tenant_id]).select(:event_id))
+            else
+              result
+            end
+          end
         end
       end
     end

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

@@ -0,0 +1,41 @@
+module Spree
+  module Api
+    module V2
+      module Storefront
+        class CrossAppHandoffTokensController < ::Spree::Api::V2::ResourceController
+          # No AR model backs a handoff token (see CrossAppHandoffTokens::Encode) — this just gives
+          # the generated {token:, expires_at:} pair an #id so it can go through the same
+          # serializer/JSON:API pipeline as every other storefront resource.
+          Resource = Struct.new(:token, :expires_at) do
+            def id
+              token
+            end
+          end
+
+          def create
+            return render_error_payload(I18n.t('authenticator.incorrect_login'), 401) if spree_current_user.blank?
+
+            result = SpreeCmCommissioner::CrossAppHandoffTokens::Encode.call(user: spree_current_user, purpose: purpose)
+            return render_error_payload(result.error, 422) unless result.success?
+
+            render_serialized_payload(201) { serialize_resource(Resource.new(result.value[:token], result.value[:expires_at])) }
+          end
+
+          def serialize_resource(resource)
+            resource_serializer.new(resource).serializable_hash
+          end
+
+          def resource_serializer
+            SpreeCmCommissioner::V2::Storefront::CrossAppHandoffTokenSerializer
+          end
+
+          private
+
+          def purpose
+            params[:purpose].to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -16,10 +16,12 @@ module Spree
           end
 
           def collection
-            @collection ||= model_class.filter_by_segment(params[:homepage_id] || :general)
-                                       .active
+            # for_feed applies the segment itself, and its fallback only counts rows that survive
+            # the filters above, so it goes last.
+            @collection ||= model_class.active
                                        .where(tenant_id: nil)
                                        .where(preview: false)
+                                       .for_feed(params[:homepage_id] || :general, params[:mini_app])
                                        .order(position: :asc)
           end
         end