spree_cm_commissioner 2.13.2 → 2.13.3.pre.pre2

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/external_client/client.rb

@@ -0,0 +1,230 @@
+module SpreeCmCommissioner::Integrations::BookMeBusV1::ExternalClient
+  class Client
+    include Connection
+    include SpreeCmCommissioner::AuditWrapper
+
+    BASE_PATH = '/api/v2'.freeze
+    RATE_LIMIT = 100
+
+    attr_reader :integration
+
+    def initialize(integration:)
+      @integration = integration
+    end
+
+    # Location Operations
+
+    # Get all available locations
+    # @return [Array<SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::Location>] Array of location objects
+    def get_locations! # rubocop:disable Naming/AccessorMethodName
+      endpoint = "#{BASE_PATH}/locations"
+
+      response = get(endpoint)
+      handle_response(response, SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::Location, collection: true)
+    end
+
+    # Trip Operations
+
+    # Search available trips for a given route and date
+    # @param origin_id [String] The origin location ID
+    # @param destination_id [String] The destination location ID
+    # @param on_date [String] The travel date (YYYY-MM-DD format)
+    # @return [Array<SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::Trip>] Array of available trip objects
+    def search_trips!(origin_id:, destination_id:, on_date:)
+      params = {
+        origin_id: origin_id,
+        destination_id: destination_id,
+        on_date: on_date,
+        # Scopes results to this integration's operator when multiple Integrations share one
+        # BookMeBus application (Application#use_multiple_operators?). Compacted out (rather than
+        # sent as an empty value) when unset, so a single-operator setup behaves exactly as before.
+        operator_id: integration.operator_id
+      }.compact
+      endpoint = "#{BASE_PATH}/trip_availabilities"
+
+      response = get(endpoint, params)
+      handle_response(response, SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::Trip, collection: true)
+    end
+
+    # Seat Layout Operations
+
+    # Get seat layout for a specific trip segment
+    # @param trip_id [String] The trip ID
+    # @param from_stop_id [String] The departure stop ID
+    # @param to_stop_id [String] The arrival stop ID
+    # @param on_date [String] The travel date (YYYY-MM-DD format)
+    # @param show_all_stops [Boolean] Whether to show all stops (default: false)
+    # @return [SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::SeatLayout] Seat layout object
+    def get_seat_layout!(trip_id:, from_stop_id:, to_stop_id:, on_date:, show_all_stops: false)
+      params = {
+        trip_id: trip_id,
+        from_stop_id: from_stop_id,
+        to_stop_id: to_stop_id,
+        on_date: on_date,
+        show_all_stops: show_all_stops
+      }
+      endpoint = "#{BASE_PATH}/seat_layouts"
+
+      response = get(endpoint, params)
+      handle_response(response, SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::SeatLayout)
+    end
+
+    # Reservation Operations
+
+    # Create a reservation cart in BookMeBus
+    # @param params [Hash] Reservation parameters
+    # @option params [Integer] :trip_id The BookMeBus trip ID
+    # @option params [Integer] :from_stop_id The boarding stop ID
+    # @option params [Integer] :to_stop_id The drop-off stop ID
+    # @option params [Integer] :from_stop_time_id The boarding stop time ID
+    # @option params [Integer] :to_stop_time_id The drop-off stop time ID
+    # @option params [String] :departure_date The travel date (YYYY-MM-DD format)
+    # @option params [Hash] :reserved_seats Reserved seats hash keyed by stop_id with seat detail objects
+    # @option params [String] :contact_name Passenger contact name
+    # @option params [String] :contact_email Passenger contact email
+    # @option params [String] :contact_phone Passenger contact phone
+    # @option params [Object] :internal_order Internal order for audit
+    # @return [SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::ReservationCart] The created reservation cart
+    def create_reservation!(params)
+      number_of_seats = params[:reserved_seats].values.flatten.count
+
+      body = {
+        reservations: [
+          {
+            trip_id: params[:trip_id],
+            from_stop_id: params[:from_stop_id],
+            to_stop_id: params[:to_stop_id],
+            from_stop_time_id: params[:from_stop_time_id],
+            to_stop_time_id: params[:to_stop_time_id],
+            departure_date: params[:departure_date],
+            number_of_seats: number_of_seats,
+            reserved_seats: params[:reserved_seats],
+            contact_name: params[:contact_name],
+            contact_email: params[:contact_email],
+            contact_phone: params[:contact_phone],
+            is_request_pickup: false
+          }.compact
+        ]
+      }
+
+      endpoint = "#{BASE_PATH}/trip_reservations"
+
+      with_audit(
+        event_base: 'bookmebus.reservations.post',
+        request: { method: 'POST', endpoint: endpoint, body: body },
+        auditable: params[:internal_order]
+      ) do
+        response = post(endpoint, body)
+        handle_response(response, SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::ReservationCart)
+      end
+    end
+
+    # Wallet Payment Operations
+    # Create a wallet payment for a reservation cart
+    # @param cart_id [String] The reservation cart ID
+    # @return [SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::WalletPayment] The created wallet payment
+    def create_wallet_payment!(cart_id:, internal_order:)
+      endpoint = "#{BASE_PATH}/wallet_payments?reservation_cart_id=#{cart_id}"
+
+      with_audit(
+        event_base: 'bookmebus.wallet_payments.post',
+        request: { method: 'POST', endpoint: endpoint, body: {} },
+        auditable: internal_order
+      ) do
+        response = post(endpoint, {})
+        handle_response(response, SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::WalletPayment)
+      end
+    end
+
+    # Confirm a wallet payment (deduct from user's BookMeBus wallet)
+    # @param payment_id [String] The wallet payment ID
+    # @return [SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::WalletPayment] The confirmed wallet payment
+    def confirm_wallet_payment!(payment_id:, internal_order:)
+      endpoint = "#{BASE_PATH}/bmb_wallets?payment_id=#{payment_id}"
+
+      with_audit(
+        event_base: 'bookmebus.wallet_payments.post',
+        request: { method: 'POST', endpoint: endpoint, body: {} },
+        auditable: internal_order
+      ) do
+        response = post(endpoint, {})
+        handle_response(response, SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::WalletPayment)
+      end
+    end
+
+    # Get passenger seat info for a specific seat
+    # @param stop_id [String] The stop ID
+    # @param trip_id [String] The trip ID
+    # @param seat [String] The seat number/label
+    # @param departure_date [String] The departure date (YYYY-MM-DD format)
+    # @return [SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::InventoryItemStatus] Seat/passenger info
+    def inventory_item_status!(stop_id:, trip_id:, label:, layer:, departure_date:)
+      params = {
+        stop_id: stop_id,
+        trip_id: trip_id,
+        seat: {
+          label: label,
+          layer: layer
+        },
+        departure_date: departure_date
+      }
+      endpoint = "#{BASE_PATH}/passenger_seat_infos"
+
+      with_audit(
+        event_base: 'bookmebus.passenger_seat_infos.get',
+        request: { method: 'GET', endpoint: endpoint, params: params },
+        auditable: integration
+      ) do
+        response = get(endpoint, params)
+        handle_response(response, SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::InventoryItemStatus)
+      end
+    end
+
+    private
+
+    def handle_response(response, model_class, collection: false) # rubocop:disable Metrics/PerceivedComplexity
+      raise_api_error(response) unless response.success?
+
+      data = response.body
+
+      # Handle both JSON:API format and direct object format
+      if data.is_a?(Hash) && data['data'].present?
+        # JSON:API format
+        collection ? model_class.from_json_api(data) : model_class.from_json_api_single(data)
+
+      elsif collection && data.is_a?(Array)
+        # Direct array format
+        data.map { |item| model_class.new(item) }
+      elsif !collection && data.is_a?(Hash)
+        # Direct object format
+        model_class.new(data)
+      else
+        Rails.logger.warn "handle_response - returning nil, data: #{data.inspect}"
+        nil
+      end
+    end
+
+    def raise_api_error(response)
+      status = response.status
+      body = response.body
+
+      message = if body.is_a?(Hash)
+                  error = body['errors']&.first || body['error'] || body['message']
+                  case error
+                  when Hash
+                    error['detail'] || error['title'] || error.to_json
+                  when String
+                    error
+                  else
+                    "API request failed with status #{status}"
+                  end
+                else
+                  "API request failed with status #{status}"
+                end
+
+      message = "#{message} (body: #{body.to_json})" if status >= 500
+
+      raise SpreeCmCommissioner::Integrations::ExternalClientError.new(message, status)
+    end
+  end
+end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/external_client/connection.rb

@@ -0,0 +1,147 @@
+module SpreeCmCommissioner::Integrations::BookMeBusV1::ExternalClient
+  module Connection
+    OAUTH_TOKEN_PATH = '/oauth/token'.freeze
+    REQUEST_TIMEOUT = 30
+    OPEN_TIMEOUT = 10
+
+    def get(url, params = nil, headers = nil)
+      execute_request { connection.get(url, params, build_headers(headers)) }
+    end
+
+    def post(url, body = nil, headers = nil)
+      execute_request { connection.post(url, body, build_headers(headers)) }
+    end
+
+    def put(url, body = nil, headers = nil)
+      execute_request { connection.put(url, body, build_headers(headers)) }
+    end
+
+    def patch(url, body = nil, headers = nil)
+      execute_request { connection.patch(url, body, build_headers(headers)) }
+    end
+
+    def delete(url, params = nil, headers = nil)
+      execute_request { connection.delete(url, params, build_headers(headers)) }
+    end
+
+    def connection
+      @connection ||= Faraday.new(url: @integration.base_url) do |faraday|
+        faraday.request :json
+        faraday.response :json, content_type: /\bjson$/
+        faraday.options.timeout = REQUEST_TIMEOUT
+        faraday.options.open_timeout = OPEN_TIMEOUT
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    # Thread-safe token access with automatic refresh on expiration
+    def access_token
+      token_mutex.synchronize do
+        @access_token ||= @integration.access_token
+        @token_expires_at ||= @integration.token_expires_at
+
+        fetch_and_persist_access_token! if token_expired?
+
+        @access_token
+      end
+    end
+
+    private
+
+    def token_mutex
+      @token_mutex ||= Mutex.new
+    end
+
+    def token_expired?
+      @access_token.blank? || @token_expires_at.blank? || Time.current >= @token_expires_at
+    end
+
+    def fetch_and_persist_access_token!
+      response = oauth_connection.post(OAUTH_TOKEN_PATH) do |req|
+        req.body = {
+          grant_type: 'client_credentials',
+          client_id: @integration.client_id,
+          client_secret: @integration.client_secret
+        }
+      end
+
+      unless response.success?
+        raise SpreeCmCommissioner::Integrations::ExternalClientError.new(
+          'Failed to fetch access token',
+          response.status
+        )
+      end
+
+      token_data = response.body
+      @access_token = token_data['access_token']
+      expires_in = token_data['expires_in'] || 3600
+      @token_expires_at = Time.current + expires_in.seconds - 60.seconds
+
+      update_integration_token!
+      reset_connection
+    end
+
+    # Execute HTTP request with automatic token refresh on 401
+    def execute_request(retry_count: 0, &block)
+      response = block.call
+
+      if response.status == 401 && retry_count.zero?
+        invalidate_token
+        access_token
+        reset_connection
+        return execute_request(retry_count: 1, &block)
+      end
+
+      response
+    rescue Faraday::TimeoutError => e
+      raise SpreeCmCommissioner::Integrations::ExternalClientError.new(
+        "Request timeout: #{e.message}",
+        408
+      )
+    rescue Faraday::Error => e
+      raise SpreeCmCommissioner::Integrations::ExternalClientError.new(
+        "Request failed: #{e.message}",
+        nil
+      )
+    end
+
+    def build_headers(extra_headers)
+      default_headers = {
+        'Content-Type' => 'application/json',
+        'Accept' => 'application/json',
+        'Authorization' => "Bearer #{access_token}"
+      }
+      return default_headers if extra_headers.blank?
+
+      default_headers.merge(extra_headers)
+    end
+
+    def invalidate_token
+      token_mutex.synchronize do
+        @access_token = nil
+        @token_expires_at = nil
+      end
+    end
+
+    def oauth_connection
+      @oauth_connection ||= Faraday.new(url: @integration.base_url) do |faraday|
+        faraday.request :url_encoded
+        faraday.response :json, content_type: /\bjson$/
+        faraday.options.timeout = REQUEST_TIMEOUT
+        faraday.options.open_timeout = OPEN_TIMEOUT
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    def reset_connection
+      @connection = nil
+      connection
+    end
+
+    def update_integration_token!
+      @integration.access_token = @access_token
+      @integration.token_expires_at = @token_expires_at
+      @integration.save! if @integration.changed?
+    end
+  end
+end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/inventory/external_inventory_item_status.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SpreeCmCommissioner
+  module Integrations
+    class BookMeBusV1
+      module Inventory
+        # Fetches detailed status for a specific inventory item (seat) from BookMeBus
+        # Uses the inventory_item_status! API (passenger_seat_infos endpoint)
+        class ExternalInventoryItemStatus
+          prepend ::Spree::ServiceModule::Base
+
+          def call(integration:, order:, options:)
+            @integration = integration
+            @order = order
+            @options = options
+
+            validate_params!
+            item_status = fetch_item_status
+
+            success(item_status: item_status)
+          rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
+            failure(nil, e.message)
+          end
+
+          private
+
+          attr_reader :integration, :order, :options
+
+          def validate_params!
+            raise_error('stop_id is required') if options[:stop_id].blank?
+            raise_error('seat is required') if options[:label].blank?
+            raise_error('departure_date is required') if options[:departure_date].blank?
+          end
+
+          def fetch_item_status
+            integration.client.inventory_item_status!(
+              stop_id: options[:stop_id],
+              trip_id: options[:trip_id],
+              label: options[:label],
+              layer: options[:layer],
+              departure_date: options[:departure_date]
+            )
+          end
+
+          def raise_error(msg)
+            raise SpreeCmCommissioner::Integrations::SyncError, msg
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/inventory/external_inventory_items.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module SpreeCmCommissioner
+  module Integrations
+    class BookMeBusV1
+      module Inventory
+        # Fetches all inventory items (seats) for an order from BookMeBus
+        # Uses the get_seat_layout! API to retrieve seat availability
+        class ExternalInventoryItems
+          prepend ::Spree::ServiceModule::Base
+
+          def call(integration:, order:)
+            @integration = integration
+            @order = order
+
+            items = []
+            order.line_items.each do |line_item|
+              items.concat(fetch_items_for_line_item(line_item))
+            end
+
+            success(items: items)
+          rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
+            failure(nil, e.message)
+          end
+
+          private
+
+          attr_reader :integration, :order
+
+          def fetch_items_for_line_item(line_item)
+            trip_mapping = find_trip_mapping(line_item)
+            return [] if trip_mapping.nil?
+
+            seat_layout = fetch_seat_layout(line_item, trip_mapping)
+            build_inventory_items(seat_layout, line_item, trip_mapping)
+          end
+
+          def find_trip_mapping(line_item)
+            return nil if line_item.trip_id.blank?
+
+            SpreeCmCommissioner::IntegrationMapping.find_by(
+              integration_id: integration.id,
+              internal_type: 'SpreeCmCommissioner::Trip',
+              internal_id: line_item.trip_id,
+              status: :active
+            )
+          end
+
+          def fetch_seat_layout(line_item, trip_mapping)
+            integration.client.get_seat_layout!(
+              trip_id: trip_mapping.external_id.to_i,
+              from_stop_id: fetch_stop_id(trip_mapping, line_item.boarding_trip_stop_id, 'from_stop_id'),
+              to_stop_id: fetch_stop_id(trip_mapping, line_item.drop_off_trip_stop_id, 'to_stop_id'),
+              on_date: line_item.from_date.to_date.strftime('%Y-%m-%d')
+            )
+          end
+
+          def fetch_stop_id(trip_mapping, trip_stop_id, fallback_key)
+            return trip_mapping.external_payload[fallback_key] if trip_stop_id.blank?
+
+            stop_mapping = SpreeCmCommissioner::IntegrationMapping.find_by(
+              internal_type: 'SpreeCmCommissioner::TripStop',
+              internal_id: trip_stop_id,
+              status: :active
+            )
+            stop_mapping&.external_payload&.dig('stop', 'id') || trip_mapping.external_payload[fallback_key]
+          end
+
+          def build_inventory_items(seat_layout, line_item, trip_mapping)
+            items = []
+            items += seat_layout.seats.map do |seat|
+              {
+                id: "#{trip_mapping.external_id}-#{seat.label}",
+                seat_label: seat.label,
+                seat_type: seat.seat_type_name,
+                layer: seat.layer,
+                status: seat.available? ? 'available' : 'booked',
+                gender: seat.gender,
+                position: seat.position,
+                from_stop_id: seat_layout.from_stop_id,
+                departure_date: line_item.from_date.to_date.strftime('%Y-%m-%d'),
+                trip_id: trip_mapping.external_id.to_i
+              }
+            end
+            items
+          end
+        end
+      end
+    end
+  end
+end