spree_cm_commissioner 2.13.2 → 2.13.3.pre.pre2

data/app/models/concerns/spree_cm_commissioner/user_notification.rb

@@ -8,8 +8,10 @@ module SpreeCmCommissioner
 
       scope :push_notificable, -> { where('device_tokens_count > 0') }
 
+      # Previously chained with `end_users`, which excludes users who are assigned to a vendor (organizers),
+      # so organizers couldn't test notifications on their own account. Dropped that scope here.
       def self.end_users_push_notificable
-        end_users.push_notificable
+        push_notificable
       end
     end
   end

data/app/models/concerns/spree_cm_commissioner/variant_metadata.rb

@@ -0,0 +1,24 @@
+module SpreeCmCommissioner
+  module VariantMetadata
+    extend ActiveSupport::Concern
+
+    def manual_generate_inventory_items?
+      ActiveModel::Type::Boolean.new.cast(private_metadata['manual_generate_inventory_items'])
+    end
+
+    def manual_generate_inventory_items=(value)
+      boolean_value = ActiveModel::Type::Boolean.new.cast(value)
+      set_private_metadata_value('manual_generate_inventory_items', boolean_value)
+    end
+
+    private
+
+    def set_private_metadata_value(key, value)
+      if value.nil? || value == false
+        private_metadata.delete(key)
+      else
+        private_metadata[key] = value.to_s
+      end
+    end
+  end
+end

data/app/models/concerns/spree_cm_commissioner/vehicle_kind.rb

@@ -2,7 +2,7 @@ module SpreeCmCommissioner
   module VehicleKind
     extend ActiveSupport::Concern
 
-    VEHICLE_KINDS = %i[suv sedan minivan van sleeping_bus luxury_van air_bus bus ferry].freeze
+    VEHICLE_KINDS = %i[suv sedan minivan van sleeping_bus luxury_van air_bus bus ferry boat train].freeze
 
     included do
       enum kind: VEHICLE_KINDS if table_exists? && column_names.include?('kind')

data/app/models/spree_cm_commissioner/adjustable/adjuster/service_fee.rb

@@ -0,0 +1,31 @@
+module SpreeCmCommissioner
+  module Adjustable
+    module Adjuster
+      class ServiceFee < Spree::Adjustable::Adjuster::Base
+        def update
+          service_fee_total = adjustments.service_fee.eligible.reload.sum(&:amount)
+
+          update_totals(service_fee_total)
+        end
+
+        private
+
+        def adjustments
+          adjustable.try(:all_adjustments) || adjustable.adjustments
+        end
+
+        # Folds into the existing non_taxable_adjustment_total bucket (same as the
+        # PricingAction adjuster) so order.total/adjustment_total are correct with no core
+        # decoration needed. `service_fee_total` is set as its own key only for line items —
+        # it becomes its own DB column there (for a clean "Service Fee: $X" display total),
+        # but Spree::Shipment has no such column, and this same adjuster instance also runs
+        # for shipments (adjusters are global, not adjustable-type-specific).
+        def update_totals(service_fee_total)
+          service_fee_total ||= 0.0
+          @totals[:non_taxable_adjustment_total] += service_fee_total
+          @totals[:service_fee_total] = service_fee_total if adjustable.is_a?(Spree::LineItem)
+        end
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/adjustment_decorator.rb

@@ -3,6 +3,7 @@ module SpreeCmCommissioner
     def self.prepended(base)
       base.belongs_to :payable, polymorphic: true, optional: true
       base.scope :pricing_action, -> { where(source_type: 'SpreeCmCommissioner::PricingAction') }
+      base.scope :service_fee, -> { where(source_type: 'SpreeCmCommissioner::ServiceFeeRule') }
       base.whitelisted_ransackable_attributes |= %w[payable_id]
     end
 

data/app/models/spree_cm_commissioner/audit_event.rb

@@ -0,0 +1,11 @@
+module SpreeCmCommissioner
+  class AuditEvent < Base
+    belongs_to :auditable, polymorphic: true, optional: true
+    belongs_to :user, class_name: 'Spree::User', optional: true
+
+    validates :event_type, presence: true
+
+    scope :success, -> { where(success: true) }
+    scope :failed,  -> { where(success: false) }
+  end
+end

data/app/models/spree_cm_commissioner/calculators/service_fee_flat_amount.rb

@@ -0,0 +1,17 @@
+module SpreeCmCommissioner
+  module Calculators
+    class ServiceFeeFlatAmount < Spree::Calculator
+      preference :flat_amount, :decimal, default: 0
+
+      def self.description
+        Spree.t(:service_fee_flat_amount)
+      end
+
+      # Per unit, not per line item — a $0.25 fee on a 2-ticket line item charges $0.50, matching
+      # how a booking fee is normally priced (confirmed decision, see plan.md).
+      def compute(line_item)
+        preferred_flat_amount * line_item.quantity
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/calculators/service_fee_percent.rb

@@ -0,0 +1,20 @@
+module SpreeCmCommissioner
+  module Calculators
+    class ServiceFeePercent < Spree::Calculator
+      preference :percent, :decimal, default: 0
+
+      def self.description
+        Spree.t(:service_fee_percent)
+      end
+
+      # `discounted_amount` (price net of taxable promotions, before tax) rather than
+      # `pre_tax_amount`: the latter is only ever populated as a side effect of
+      # Spree::TaxRate.store_pre_tax_amount running for this line item, so it would make
+      # service-fee computation order-dependent on tax having already run. discounted_amount
+      # is a live computed value (amount + taxable_adjustment_total) with no such dependency.
+      def compute(line_item)
+        line_item.discounted_amount * preferred_percent / 100
+      end
+    end
+  end
+end

data/app/models/spree_cm_commissioner/currency_rate.rb

@@ -0,0 +1,15 @@
+module SpreeCmCommissioner
+  class CurrencyRate < SpreeCmCommissioner::Base
+    belongs_to :vendor, class_name: 'Spree::Vendor', optional: false
+
+    validates :from_currency, :to_currency, :rate, presence: true
+    validates :rate, numericality: { greater_than: 0 }
+    validates :from_currency, :to_currency, inclusion: { in: %w[USD KHR] }
+
+    self.whitelisted_ransackable_attributes = %w[from_currency to_currency status]
+
+    def self.by_pair(from, to)
+      where(from_currency: from.upcase, to_currency: to.upcase, status: 'active')
+    end
+  end
+end

data/app/models/spree_cm_commissioner/customer_notification.rb

@@ -9,12 +9,14 @@ module SpreeCmCommissioner
     has_many :notification_taxons, dependent: :destroy, class_name: 'SpreeCmCommissioner::NotificationTaxon'
     has_many :taxons, through: :notification_taxons, class_name: 'Spree::Taxon'
 
-    belongs_to :vendor, class_name: 'Spree::Vendor'
+    belongs_to :vendor, class_name: 'Spree::Vendor', optional: true
 
     validates :title, presence: true
 
     validates :notification_type, presence: true
 
+    validate :taxons_must_belong_to_vendor
+
     self.whitelisted_ransackable_attributes = %w[title excerpt notification_type]
     self.whitelisted_ransackable_associations = %w[notification_taxons taxons]
 
@@ -33,5 +35,17 @@ module SpreeCmCommissioner
     def self.scheduled_items
       where(['sent_at IS NULL AND started_at <= ? AND active', Time.current])
     end
+
+    private
+
+    # Prevents picking a taxon that isn't one of the selected vendor's own taxons
+    def taxons_must_belong_to_vendor
+      return if vendor_id.blank? || taxon_ids.blank?
+
+      invalid_taxon_ids = taxon_ids - vendor.taxon_ids
+      return if invalid_taxon_ids.empty?
+
+      errors.add(:taxon_ids, :must_belong_to_vendor, vendor_name: vendor.name)
+    end
   end
 end

data/app/models/spree_cm_commissioner/homepage_section.rb

@@ -8,6 +8,9 @@ module SpreeCmCommissioner
     multi_tenant :tenant, class_name: 'SpreeCmCommissioner::Tenant'
 
     attribute :segment, :integer, default: 0
+    attribute :mini_app, :integer, default: 0
+
+    self.whitelisted_ransackable_attributes = %w[title active]
 
     has_many :homepage_section_relatables, -> { active }, inverse_of: :homepage_section, dependent: :destroy
 
@@ -20,6 +23,28 @@ module SpreeCmCommissioner
 
     scope :filter_by_segment, -> (segment) { where('segment & ? > 0', BIT_SEGMENT[segment.to_sym]) }
 
+    # Sections tagged for `mini_app`; an unknown value means the untagged ones.
+    scope :filter_by_mini_app, lambda { |mini_app|
+      bit = BIT_MINI_APP[mini_app.to_s.to_sym]
+
+      bit ? where('cm_homepage_sections.mini_app & ? > 0', bit) : where(mini_app: 0)
+    }
+
+    # Which sections a homepage feed shows. Using Wing as the example:
+    #
+    #   BookMe+     -> every section of this segment; ticking a Mini App never hides one here
+    #   Wing        -> sections of this segment with Wing ticked; if none, the BookMe+ ones
+    scope :for_feed, lambda { |segment, mini_app = nil|
+      name = mini_app.to_s.to_sym
+      everything = filter_by_segment(segment)
+      next everything unless BIT_MINI_APP.key?(name)
+
+      curated = filter_by_mini_app(name)
+      curated = curated.filter_by_segment(segment) unless MINI_APP_HOME_SEGMENT[name] == segment.to_sym
+
+      curated.exists? ? curated : everything
+    }
+
     # Create maintaining task to purge homepage section related caches
     after_save { SpreeCmCommissioner::MaintenanceTasks::CacheInvalidation.pending.create_or_find_by(maintainable: self) }
   end

data/app/models/spree_cm_commissioner/integration.rb

@@ -14,10 +14,25 @@ module SpreeCmCommissioner
     validates :incremental_sync_interval_seconds, presence: true, numericality: { only_integer: true, greater_than: 0, less_than_or_equal_to: 3600 }
     validates :full_sync_interval_hours, presence: true, numericality: { only_integer: true, greater_than: 0, less_than_or_equal_to: 168 }
 
+    # Listed from the folder rather than `descendants`, which misses subclasses Zeitwerk hasn't
+    # loaded yet in dev and test.
+    def self.types
+      Dir[SpreeCmCommissioner::Engine.root.join('app/models/spree_cm_commissioner/integrations/*.rb')]
+        .map { |path| "SpreeCmCommissioner::Integrations::#{File.basename(path, '.rb').camelize}" }
+        .sort
+    end
+
     def sync_manager
       raise NotImplementedError, 'Subclasses must implement the sync_manager method'
     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.
+    def inventory_external_wins?(_variant)
+      false
+    end
+
     def restock_external_inventory!(_order, _line_items)
       raise NotImplementedError, 'Subclasses must implement the restock_external_inventory! method'
     end
@@ -25,5 +40,36 @@ module SpreeCmCommissioner
     def unstock_external_inventory!(_order, _line_items)
       raise NotImplementedError, 'Subclasses must implement the unstock_external_inventory! method'
     end
+
+    def sync_item_availability!(_options = {})
+      raise NotImplementedError, 'Subclasses must implement the sync_item_availability! method'
+    end
+
+    def hold_inventory!(_order, _line_items)
+      raise NotImplementedError, 'Subclasses must implement the hold_inventory! method'
+    end
+
+    # Integrations that manage external inventory reservations should override this to return true
+    def supports_external_inventory_holding?
+      false
+    end
+
+    # Integrations that support automatically releasing external inventory
+    # after reservation expiration or order cancellation should override this to return true
+    def supports_auto_release_inventory?
+      false
+    end
+
+    def release_inventory!(_order, _line_items)
+      raise NotImplementedError, 'Subclasses must implement the release_inventory! method'
+    end
+
+    def external_inventory_items(_order)
+      raise NotImplementedError, 'Subclasses must implement the external_inventory_items method'
+    end
+
+    def external_inventory_item_status(_order, _options)
+      raise NotImplementedError, 'Subclasses must implement the external_inventory_item_status method'
+    end
   end
 end

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

@@ -0,0 +1,64 @@
+class SpreeCmCommissioner::Integrations::BookMeBusV1 < SpreeCmCommissioner::Integration
+  store_private_metadata :client_id, :string
+  store_private_metadata :client_secret, :string
+  store_private_metadata :base_url, :string # e.g. 'https://bookmebus.com'
+  store_private_metadata :username, :string # Contact email (optional)
+  store_private_metadata :access_token, :string
+  store_private_metadata :token_expires_at, :datetime
+  store_private_metadata :operator_id, :string
+  # override
+  def sync_manager
+    SpreeCmCommissioner::Integrations::BookMeBusV1::SyncManager.new(integration: self)
+  end
+
+  # override
+  def unstock_external_inventory!(order, line_items)
+    result = SpreeCmCommissioner::Integrations::BookMeBusV1::Inventory::UnstockInventory.new.call(
+      integration: self,
+      order: order,
+      line_items: line_items
+    )
+
+    raise SpreeCmCommissioner::Integrations::SyncError, result.error unless result.success?
+  end
+
+  # override
+  # BookMeBus has no working cancellation API (its public reservation-cancellation endpoint is
+  # disabled in production), so there is nothing to actually restock on their side. Raise instead
+  # of silently succeeding - matching VireakBuntham/Larryta - so order cancellation surfaces this
+  # loudly rather than letting local inventory quietly diverge from what BookMeBus still shows as
+  # booked (a silent no-op here would let BookMe+ resell a seat BookMeBus still considers taken).
+  def restock_external_inventory!(_order, _line_items)
+    raise SpreeCmCommissioner::Integrations::SyncError, 'Booking cannot be cancelled once confirmed'
+  end
+
+  # override - Fetch all external inventory items
+  def external_inventory_items(order)
+    SpreeCmCommissioner::Integrations::BookMeBusV1::Inventory::ExternalInventoryItems.new.call(
+      integration: self,
+      order: order
+    )
+  end
+
+  # override - Fetch detailed status for a specific external inventory item
+  def external_inventory_item_status(order, options)
+    SpreeCmCommissioner::Integrations::BookMeBusV1::Inventory::ExternalInventoryItemStatus.new.call(
+      integration: self,
+      order: order,
+      options: options
+    )
+  end
+
+  def sync_item_availability!(options = {})
+    SpreeCmCommissioner::Integrations::BookMeBusV1::Polling::SyncItemAvailability.new(
+      integration: self
+    ).call(
+      trip_id: options[:trip_id],
+      on_date: options[:on_date]
+    )
+  end
+
+  def client
+    @client ||= SpreeCmCommissioner::Integrations::BookMeBusV1::ExternalClient::Client.new(integration: self)
+  end
+end

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

@@ -0,0 +1,81 @@
+class SpreeCmCommissioner::Integrations::Larryta < SpreeCmCommissioner::Integration
+  store_private_metadata :base_url, :string
+  store_private_metadata :username, :string
+  store_private_metadata :api_token, :string
+  store_private_metadata :api_uid, :string
+  store_private_metadata :sync_days, :integer, default: 7
+
+  def sync_manager
+    SpreeCmCommissioner::Integrations::Larryta::SyncManager.new(integration: self)
+  end
+
+  def hold_inventory!(order, line_items)
+    result = SpreeCmCommissioner::Integrations::Larryta::Inventory::HoldSeats.new.call(
+      integration: self,
+      order: order,
+      line_items: line_items
+    )
+
+    raise SpreeCmCommissioner::Integrations::SyncError, result.error unless result.success?
+  end
+
+  def unstock_external_inventory!(order, line_items)
+    result = SpreeCmCommissioner::Integrations::Larryta::Inventory::UnstockInventory.new.call(
+      integration: self,
+      order: order,
+      line_items: line_items
+    )
+
+    raise SpreeCmCommissioner::Integrations::SyncError, result.error unless result.success?
+  end
+
+  def supports_external_inventory_holding?
+    true
+  end
+
+  def restock_external_inventory!(_order, _line_items)
+    raise SpreeCmCommissioner::Integrations::SyncError, 'Booking cannot be cancelled once confirmed'
+  end
+
+  def supports_auto_release_inventory?
+    true
+  end
+
+  def release_inventory!(order, line_items)
+    SpreeCmCommissioner::Integrations::Larryta::Inventory::ReleaseSeats.new.call(
+      integration: self,
+      order: order,
+      line_items: line_items
+    )
+  end
+
+  def sync_item_availability!(options = {})
+    SpreeCmCommissioner::Integrations::Larryta::Polling::SyncItemAvailability.new(
+      integration: self
+    ).call(
+      trip_id: options[:trip_id],
+      on_date: options[:on_date]
+    )
+  end
+
+  # override - Fetch all external inventory items for an order
+  def external_inventory_items(order)
+    SpreeCmCommissioner::Integrations::Larryta::Inventory::ExternalInventoryItems.new.call(
+      integration: self,
+      order: order
+    )
+  end
+
+  # override - Fetch detailed status for a specific external inventory item
+  def external_inventory_item_status(order, options)
+    SpreeCmCommissioner::Integrations::Larryta::Inventory::ExternalInventoryItemStatus.new.call(
+      integration: self,
+      order: order,
+      options: options
+    )
+  end
+
+  def client
+    @client ||= SpreeCmCommissioner::Integrations::Larryta::ExternalClient::Client.new(integration: self)
+  end
+end

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

@@ -5,10 +5,7 @@ class SpreeCmCommissioner::Integrations::StadiumXV1 < SpreeCmCommissioner::Integ
 
   # override
   def sync_manager
-    SpreeCmCommissioner::Integrations::StadiumXV1::SyncManager.new(
-      integration: self,
-      client: client
-    )
+    SpreeCmCommissioner::Integrations::StadiumXV1::SyncManager.new(integration: self)
   end
 
   # override
@@ -18,7 +15,6 @@ class SpreeCmCommissioner::Integrations::StadiumXV1 < SpreeCmCommissioner::Integ
       order: order,
       line_items: line_items
     )
-
     raise SpreeCmCommissioner::Integrations::SyncError, result.error unless result.success?
   end
 
@@ -27,11 +23,9 @@ class SpreeCmCommissioner::Integrations::StadiumXV1 < SpreeCmCommissioner::Integ
     raise SpreeCmCommissioner::Integrations::SyncError, 'Ticket cannot be cancelled'
   end
 
+  def sync_item_availability!(_options = {}); end
+
   def client
-    SpreeCmCommissioner::Integrations::StadiumXV1::ExternalClient::Client.new(
-      public_key: public_key,
-      private_key: private_key,
-      base_url: base_url
-    )
+    @client ||= SpreeCmCommissioner::Integrations::StadiumXV1::ExternalClient::Client.new(integration: self)
   end
 end

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

@@ -0,0 +1,86 @@
+# 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 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,
+# reservation summary) while it keeps selling on its own counts. `active` with conflict strategy
+# `external_wins` hands the rooms' availability, prices and restrictions over to switch.cm.
+class SpreeCmCommissioner::Integrations::SwitchCm < SpreeCmCommissioner::Integration
+  READABLE_STATUSES = %i[active paused].freeze
+
+  belongs_to :oauth_application, class_name: 'Spree::OauthApplication', optional: false
+
+  # Reservations completed before this aren't in the reservation feeds: switch.cm imports them
+  # through the reservation summary while setting the hotel up.
+  store_public_metadata :connected_at, :datetime
+
+  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 sync_manager
+    SyncManager.new(integration: self)
+  end
+
+  # Only for rooms switch.cm can see (RoomCatalog): a hotel's other products, and rooms that need
+  # confirmation, keep BookMe+ counts since switch.cm never pushes them.
+  # override
+  def inventory_external_wins?(variant)
+    owns_inventory? && variant.accommodation? && !variant.need_confirmation?
+  end
+
+  def owns_inventory?
+    active? && external_wins?
+  end
+
+  # switch.cm pulls reservations, so a BookMe+ sale needs nothing from it at checkout, and the
+  # hotel's own cancellation rules decide whether a booking can be cancelled.
+  # override
+  def unstock_external_inventory!(_order, _line_items); end
+
+  # override
+  def restock_external_inventory!(_order, _line_items); end
+
+  # override
+  def sync_item_availability!(_options = {}); end
+
+  # override
+  def external_inventory_items(_order)
+    []
+  end
+
+  # override
+  def external_inventory_item_status(_order, _options)
+    {}
+  end
+
+  # 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
+  end
+
+  private
+
+  def set_connected_at
+    self.connected_at ||= Time.current.iso8601
+  end
+
+  # Taking over closes the rooms' unpushed nights; letting go (paused, disconnected, or another
+  # conflict strategy) reopens them, while pushed nights keep switch.cm's last numbers.
+  def sync_unpushed_nights
+    owned_before = status_before_last_save.to_s == 'active' && conflict_strategy_before_last_save.to_s == 'external_wins'
+    return if owned_before == owns_inventory?
+
+    PushedNights.new(self).reconcile_unpushed!
+  end
+end

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

@@ -0,0 +1,82 @@
+class SpreeCmCommissioner::Integrations::VireakBuntham < SpreeCmCommissioner::Integration
+  # VET API requires a `type` parameter to scope responses to a vehicle category.
+  # Each VireakBuntham integration instance represents one category.
+  ROUTE_TYPES = { bus: 1, ferry: 2, air_bus: 3 }.freeze
+
+  store_private_metadata :api_url, :string
+  store_private_metadata :api_token, :string
+  store_private_metadata :callback_username, :string
+  store_private_metadata :callback_pwd, :string
+  store_private_metadata :sync_days, :integer, default: 7
+  store_private_metadata :route_type, :integer, default: 1
+
+  validate :route_type_must_be_valid
+
+  def route_type_name
+    ROUTE_TYPES.key(route_type.to_i)
+  end
+
+  # VET `type` query param used by /destination/from, /schedule/list, /schedule/listByDate
+  def vet_type_param
+    route_type.to_i
+  end
+
+  def sync_manager
+    SpreeCmCommissioner::Integrations::VireakBuntham::SyncManager.new(integration: self)
+  end
+
+  # Confirm and finalize booking on VET: POST /booking/confirm + /booking/complete in atomic transaction.
+  def unstock_external_inventory!(order, line_items)
+    result = SpreeCmCommissioner::Integrations::VireakBuntham::Inventory::UnstockInventory.new.call(
+      integration: self,
+      order: order,
+      line_items: line_items
+    )
+
+    raise SpreeCmCommissioner::Integrations::SyncError, result.error unless result.success?
+  end
+
+  def restock_external_inventory!(_order, _line_items)
+    raise SpreeCmCommissioner::Integrations::SyncError, 'Booking cannot be cancelled once confirmed'
+  end
+
+  # Sync trip prices and reserved seats from VET via GET /schedule/list + /seat/unavailable APIs.
+  def sync_item_availability!(options = {})
+    SpreeCmCommissioner::Integrations::VireakBuntham::Polling::SyncItemAvailability.new(
+      integration: self
+    ).call(
+      trip_id: options[:trip_id],
+      on_date: options[:on_date]
+    )
+  end
+
+  # Fetch available seats and prices from VET for order's trips.
+  def external_inventory_items(order)
+    SpreeCmCommissioner::Integrations::VireakBuntham::Inventory::ExternalInventoryItems.new.call(
+      integration: self,
+      order: order
+    )
+  end
+
+  # Check seat availability and pricing for specific trip/date/nationality from VET.
+  def external_inventory_item_status(order, options)
+    SpreeCmCommissioner::Integrations::VireakBuntham::Inventory::ExternalInventoryItemStatus.new.call(
+      integration: self,
+      order: order,
+      options: options
+    )
+  end
+
+  # Lazy-loaded HTTP client instance for all VET API calls.
+  def client
+    @client ||= SpreeCmCommissioner::Integrations::VireakBuntham::ExternalClient::Client.new(integration: self)
+  end
+
+  private
+
+  def route_type_must_be_valid
+    return if ROUTE_TYPES.values.include?(route_type.to_i)
+
+    errors.add(:route_type, "must be one of: #{ROUTE_TYPES.values.join(', ')}")
+  end
+end