spree_cm_commissioner 2.13.2 → 2.13.3.pre.pre2

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_locations.rb

@@ -0,0 +1,103 @@
+module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
+  class SyncLocations
+    # Initialize SyncLocations service
+    # @param integration [SpreeCmCommissioner::Integrations::BookMeBusV1] The integration instance
+    # @param sync_result [SpreeCmCommissioner::Integrations::Base::SyncResult] Optional sync result tracker
+    def initialize(integration:, sync_result: nil)
+      @integration = integration
+      @sync_result = sync_result || SpreeCmCommissioner::Integrations::Base::SyncResult.new
+    end
+
+    def call
+      raise SpreeCmCommissioner::Integrations::SyncError, 'Integration must have a vendor to sync locations' if @integration.vendor.blank?
+
+      synced_location_mappings = sync_items!
+
+      cleanup_stale_mappings!(synced_location_mappings)
+    end
+
+    private
+
+    def client
+      @client ||= @integration.client
+    end
+
+    def geocoder
+      @geocoder ||= SpreeCmCommissioner::GoogleMapsGeocoder.new
+    end
+
+    # Sync all available locations from the API and create them as places
+    def sync_items!
+      external_locations = begin
+        @sync_result.track_api_call('get_locations') { client.get_locations! }
+      rescue SpreeCmCommissioner::Integrations::ExternalClientError => e
+        raise SpreeCmCommissioner::Integrations::SyncError, "Failed to sync locations: #{e.message}"
+      end
+
+      external_locations.map do |external_location|
+        sync_item!(external_location)
+      end
+    end
+
+    # Sync a single location and create it as a place with vendor place mapping
+    def sync_item!(external_location)
+      mapping = SpreeCmCommissioner::VendorPlace.find_or_initialize_integration_mapping(
+        integration_id: @integration.id,
+        external_id: external_location.id
+      )
+
+      vendor_place = mapping.internal
+
+      place = vendor_place.place ||
+        SpreeCmCommissioner::Place.find_by(name: external_location.name) ||
+        SpreeCmCommissioner::Place.new
+
+      @sync_result.track(:location, place) do |tracker|
+        if place.new_record? || place.lat.nil? || place.lon.nil?
+          location_data = geocoder.fetch_location_data(external_location.name, external_location.country_name)
+          place.assign_attributes(
+            lat: location_data[:lat],
+            lon: location_data[:lon],
+            reference: location_data[:reference]
+          )
+        end
+
+        place.assign_attributes(
+          name: external_location.name,
+          code: external_location.abbreviation.presence || external_location.slug.presence
+        )
+
+        tracker.save_if_changed!(place)
+      end
+
+      @sync_result.track(:vendor_place, vendor_place) do |tracker|
+        vendor_place.assign_attributes(
+          vendor_id: @integration.vendor.id,
+          place_type: :location,
+          place: place
+        )
+        tracker.save_if_changed!(vendor_place)
+      end
+
+      mapping.mark_as_active!(external_payload: external_location.to_h)
+      mapping
+    end
+
+    # Archive stale location mappings that are no longer in the external API
+    def cleanup_stale_mappings!(synced_location_mappings)
+      synced_ids = synced_location_mappings.to_set(&:external_id)
+      active_mappings = SpreeCmCommissioner::IntegrationMapping.where(
+        integration_id: @integration.id,
+        internal_type: 'SpreeCmCommissioner::VendorPlace',
+        status: :active
+      )
+
+      active_mappings.find_each do |mapping|
+        next if synced_ids.include?(mapping.external_id)
+
+        mapping.mark_as_archived!
+        @sync_result.increment_metric(:location, :archived)
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_nationality_pricing.rb

@@ -0,0 +1,93 @@
+module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
+  # SyncNationalityPricing - applies BookMeBus local/non-local pricing to a Route via a
+  # PricingModel, so BookMe+ charges the correct price based on the ACTUAL guest's nationality at
+  # checkout instead of always flatly charging non_local_price (Resources::Trip#sellable_price,
+  # unchanged by this class) to every customer.
+  #
+  # Deliberately keeps non_local_price as the base (matching sellable_price's existing default)
+  # and layers a DISCOUNT adjustment on top for guests who positively match the vendor's own
+  # nationality - the opposite direction from the sibling VireakBuntham integration's
+  # SyncNationalityPricing, which stores local as the base and surcharges foreigners. That
+  # direction is riskier here: real storefront checkout (spree/api/v2/storefront/guests_controller.rb)
+  # only ever permits `nationality_id`, never `nationality_group`, so any guest whose nationality
+  # can't be positively matched must fall back to today's already-approved default (non_local),
+  # not silently receive the cheaper local price.
+  #
+  # Uses PricingRules::Nationality (not NationalityGroup, which VET uses) for the same reason -
+  # Nationality matches on nationality_id, which real guests actually have; NationalityGroup
+  # requires nationality_group, which real storefront checkout never sets.
+  #
+  # One PricingModel per vendor; one PricingRuleGroup per route (so each route gets its own
+  # independent FlatRate calculator) - confirmed per-route granularity with the user: if two trips
+  # on the same route ever have genuinely different local/non-local differentials, the most
+  # recently synced one wins for the whole route.
+  #
+  # Skipped when there's no real differential to encode (either price missing, or they're equal -
+  # both are always present per BookMeBus's own price_by_nationalities, so equality is the
+  # meaningful no-op signal, not blankness).
+  class SyncNationalityPricing
+    PRICING_MODEL_NAME = 'BookMeBus Nationality Pricing'.freeze
+
+    def initialize(route:, vendor:, local_price:, non_local_price:)
+      @route = route
+      @vendor = vendor
+      @local_price = local_price&.to_f
+      @non_local_price = non_local_price&.to_f
+    end
+
+    def call
+      return if @local_price.nil? || @non_local_price.nil? || @local_price == @non_local_price
+      return if @route.blank? || @vendor.blank?
+
+      local_taxon = @vendor.service_origin
+      return if local_taxon.blank?
+
+      delta = @local_price - @non_local_price
+
+      model = find_or_create_pricing_model
+      group = find_or_create_rule_group(model, local_taxon)
+      action = find_or_create_action(group, delta)
+
+      action.calculator.update!(preferred_amount: delta)
+      find_or_create_model_route(model)
+    end
+
+    private
+
+    def find_or_create_pricing_model
+      @vendor.pricing_models.find_or_create_by!(name: PRICING_MODEL_NAME) do |m|
+        m.status = :active
+      end
+    end
+
+    def find_or_create_rule_group(model, local_taxon)
+      group_name = "Local (#{@route.route_name})"
+      model.pricing_rule_groups.find_or_create_by!(name: group_name) do |g|
+        g.status = :active
+        g.private_metadata = { match_type: 'any' }
+        g.pricing_rules.build(
+          type: 'SpreeCmCommissioner::PricingRules::Nationality',
+          private_metadata: { nationalities: [local_taxon.id], rule_type: 'any' }
+        )
+      end
+    end
+
+    def find_or_create_action(group, delta)
+      group.pricing_action || group.create_pricing_action!(
+        type: 'SpreeCmCommissioner::PricingActions::CreateGuestAdjustments',
+        calculator: Spree::Calculator::FlatRate.new(
+          preferred_amount: delta,
+          preferred_currency: Spree::Store.default.default_currency
+        )
+      )
+    end
+
+    def find_or_create_model_route(model)
+      model.pricing_model_routes.find_or_create_by!(
+        route: @route,
+        origin_place: @route.origin_place,
+        destination_place: @route.destination_place
+      )
+    end
+  end
+end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_product.rb

@@ -0,0 +1,70 @@
+module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
+  # SyncProduct handles product synchronization for BookMeBus trips
+  #
+  # This service is responsible for:
+  # - Creating or updating Product records from external trip data
+  # - Managing product attributes (name, status, pricing)
+  # - Handling integration mappings for products
+  #
+  # Usage:
+  #   sync_service = SyncProduct.new(integration: integration, sync_result: sync_result)
+  #   product = sync_service.call(external_trip: external_trip, price: 10.0)
+  #
+  class SyncProduct
+    def initialize(integration:, sync_result:)
+      @integration = integration
+      @sync_result = sync_result
+      @vendor = @integration.vendor
+    end
+
+    def call(external_trip:, price:)
+      external_id = "product-#{external_trip.trip_id}"
+
+      mapping = Spree::Product.find_or_initialize_integration_mapping(
+        integration_id: @integration.id,
+        external_id: external_id
+      )
+
+      product = mapping.internal
+
+      @sync_result.track(:product, product) do |tracker|
+        product.assign_attributes(
+          name: build_product_name(external_trip),
+          status: :active,
+          vendor: @vendor,
+          product_type: :transit,
+          available_on: Time.current,
+          shipping_category: default_shipping_category,
+          stores: [Spree::Store.default],
+          option_types: [seat_type_option].compact,
+          price: price
+        )
+        tracker.save_if_changed!(product)
+      end
+
+      mapping.mark_as_active!(external_payload: { trip_id: external_trip.trip_id })
+      product
+    end
+
+    private
+
+    def build_product_name(external_trip)
+      origin_name = external_trip.origin_location_name
+      destination_name = external_trip.destination_location_name
+      "#{origin_name} → #{destination_name}"
+    end
+
+    def seat_type_option
+      # find_or_create_by! (not find_by) - matches SyncVariant's own lookup for the same OptionType,
+      # so the very first sync in a fresh environment doesn't create a Product with no option_types
+      # just because SyncProduct happened to run before the type existed.
+      @seat_type_option ||= Spree::OptionType.find_or_create_by!(name: 'seat-type') do |ot|
+        ot.presentation = 'Seat Type'
+      end
+    end
+
+    def default_shipping_category
+      @default_shipping_category ||= Spree::ShippingCategory.first_or_create!(name: 'Default')
+    end
+  end
+end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_route_stops.rb

@@ -0,0 +1,121 @@
+module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
+  # SyncRouteStops synchronizes route stops from BookMeBus trips
+  #
+  # Structure follows SyncZones pattern:
+  # - initialize: Setup integration and sync_result
+  # - call: Main entry point, validates inputs, orchestrates sync
+  # - private methods: Implementation details
+  class SyncRouteStops
+    def initialize(integration:, sync_result:, route:)
+      @integration = integration
+      @sync_result = sync_result
+      @route = route
+      @location_mappings = {}
+    end
+
+    def call(external_trips:)
+      raise SpreeCmCommissioner::Integrations::SyncError, 'external_trips is required' if external_trips.blank?
+      raise SpreeCmCommissioner::Integrations::SyncError, 'route is required' if @route.blank?
+
+      preload_location_mappings!
+      sync_route_stops!(external_trips)
+    end
+
+    private
+
+    # Preload all location mappings to avoid N+1 queries
+    def preload_location_mappings!
+      @location_mappings = SpreeCmCommissioner::IntegrationMapping
+                           .where(
+                             integration_id: @integration.id,
+                             internal_type: 'SpreeCmCommissioner::VendorPlace',
+                             status: :active
+                           )
+                           .includes(:internal)
+                           .index_by(&:external_id)
+    end
+
+    def sync_route_stops!(external_trips)
+      return unless @route && external_trips.any?
+
+      route_stops = build_route_stops_from(external_trips)
+      return if route_stops.empty?
+
+      update_route_stops(route_stops)
+    end
+
+    def build_route_stops_from(external_trips)
+      external_trips.flat_map do |trip|
+        next [] unless trip.stop_times.is_a?(Array)
+
+        trip.stop_times.each_with_index.filter_map do |stop_time, index|
+          build_route_stop_from(stop_time, index + 1)
+        end
+      end
+    end
+
+    def build_route_stop_from(stop_time, sequence)
+      stop_data = stop_time['stop']
+      location_data = stop_time['location']
+      return nil unless stop_data && location_data
+
+      external_stop = SpreeCmCommissioner::Integrations::BookMeBusV1::Resources::Stop.new(stop_data.merge('location' => location_data))
+      vendor_place = find_vendor_place_for(external_stop.unique_external_id)
+      location_vendor_place = find_vendor_place_for(location_data['id'])
+      return nil unless vendor_place && location_vendor_place
+
+      # Use actual sequence from stop_times order to preserve trip structure
+      {
+        vendor_place_id: vendor_place.id,
+        location_id: location_vendor_place.id,
+        type: external_stop.branch? ? :branch : :stop,
+        sequence: sequence
+      }
+    end
+
+    def update_route_stops(new_stops, retried: false)
+      @sync_result.track(:route, @route) do |tracker|
+        # Merge new stops with existing ones, preserving existing stops not in new data
+        existing = @route.route_stops.to_h.index_by { |s| s[:vendor_place_id] || s['vendor_place_id'] }
+        new_stops.each { |stop| existing[stop[:vendor_place_id]] = stop }
+
+        # Sort by sequence to maintain trip order
+        sorted_stops = existing.values.sort_by { |s| s[:sequence] || 0 }
+
+        # Re-sequence to ensure continuous sequence from 0
+        sorted_stops.each_with_index { |stop, idx| stop[:sequence] = idx }
+
+        # Validate route_stops before assignment
+        route_stop_collection = SpreeCmCommissioner::Transit::RouteStopCollection.from_hash(sorted_stops)
+        unless route_stop_collection.valid?
+          error_message = route_stop_collection.errors.join(', ')
+          raise SpreeCmCommissioner::Integrations::SyncError, "Invalid route stops: #{error_message}"
+        end
+
+        @route.route_stops = sorted_stops if @route.route_stops.to_h != sorted_stops
+        tracker.save_if_changed!(@route)
+      end
+
+      CmAppLogger.log(
+        label: 'SyncRouteStops synced',
+        data: { route_id: @route.id, stops_count: new_stops.count }
+      )
+    rescue ActiveRecord::StaleObjectError
+      # A concurrent sync (full + incremental overlapping) updated this route's lock_version
+      # between our read and write. Reload to pick up the latest route_stops and merge again,
+      # once, rather than losing this sync's stops or aborting the whole run outright.
+      raise if retried
+
+      @route.reload
+      update_route_stops(new_stops, retried: true)
+    end
+
+    def find_vendor_place_for(external_id)
+      return nil unless external_id
+
+      # Use preloaded mappings to avoid N+1 queries
+      mapping = @location_mappings[external_id.to_s]
+      mapping&.internal
+    end
+  end
+end

data/app/services/spree_cm_commissioner/integrations/book_me_bus_v1/polling/sync_routes.rb

@@ -0,0 +1,128 @@
+module SpreeCmCommissioner::Integrations::BookMeBusV1::Polling
+  class SyncRoutes
+    # Initialize SyncRoutes service
+    # @param integration [SpreeCmCommissioner::Integrations::BookMeBusV1] The integration instance
+    # @param sync_result [SpreeCmCommissioner::Integrations::Base::SyncResult] Optional sync result tracker
+    def initialize(integration:, sync_result: nil)
+      @integration = integration
+      @sync_result = sync_result || SpreeCmCommissioner::Integrations::Base::SyncResult.new
+    end
+
+    def call
+      raise SpreeCmCommissioner::Integrations::SyncError, 'Integration must have a vendor to sync routes' if @integration.vendor.blank?
+
+      synced_route_mappings = sync_items!
+
+      cleanup_stale_mappings!(synced_route_mappings)
+    end
+
+    private
+
+    # Generate routes from location pairs and sync them
+    def sync_items!
+      location_pairs = build_location_pairs
+      return [] if location_pairs.empty?
+
+      location_pairs.map do |origin_mapping, destination_mapping|
+        sync_item!(origin_mapping, destination_mapping)
+      end.compact
+    end
+
+    # Sync a single route from location pair
+    def sync_item!(origin_mapping, destination_mapping)
+      # Extract places from the location mappings
+      origin_place = origin_mapping.internal&.place
+      destination_place = destination_mapping.internal&.place
+
+      # Skip if either place is missing (invalid location mapping)
+      return nil unless origin_place && destination_place
+
+      # Build unique external_id from mapping external_ids
+      external_id = build_route_external_id(origin_mapping, destination_mapping)
+
+      # Find or create integration mapping for this route
+      mapping = SpreeCmCommissioner::Route.find_or_initialize_integration_mapping(
+        integration_id: @integration.id,
+        external_id: external_id
+      )
+
+      # Get route from mapping (already created by find_or_initialize_integration_mapping)
+      route = mapping.internal
+      route.vendor = @integration.vendor if route.new_record?
+
+      # Update route attributes and save if changed
+      @sync_result.track(:route, route) do |tracker|
+        route.origin_place = origin_place
+        route.destination_place = destination_place
+        route.route_name = build_route_name(origin_place, destination_place)
+        route.short_name = build_short_name(origin_place, destination_place)
+        route.route_type ||= :bus
+        tracker.save_if_changed!(route)
+      end
+
+      mapping.mark_as_active!(
+        external_payload: {
+          origin_place_id: origin_mapping.external_id,
+          destination_place_id: destination_mapping.external_id,
+          origin_name: origin_mapping.external_payload&.dig('name'),
+          destination_name: destination_mapping.external_payload&.dig('name')
+        }
+      )
+
+      mapping
+    end
+
+    # Build external_id using mapping external_ids (stable across environments)
+    def build_route_external_id(origin_mapping, destination_mapping)
+      "route-#{origin_mapping.external_id}-#{destination_mapping.external_id}"
+    end
+
+    # Build all location pairs (A->B and B->A)
+    def build_location_pairs
+      location_mappings = SpreeCmCommissioner::IntegrationMapping
+                          .includes(internal: :place)
+                          .where(
+                            integration_id: @integration.id,
+                            internal_type: 'SpreeCmCommissioner::VendorPlace',
+                            status: :active
+                          )
+                          .to_a
+      pairs = []
+      location_mappings.combination(2).each do |origin, destination|
+        pairs << [origin, destination]
+        pairs << [destination, origin]
+      end
+
+      pairs
+    end
+
+    # Archive stale route mappings that are no longer in the generated pairs
+    def cleanup_stale_mappings!(synced_route_mappings)
+      synced_ids = synced_route_mappings.to_set(&:external_id)
+      active_mappings = SpreeCmCommissioner::IntegrationMapping.where(
+        integration_id: @integration.id,
+        internal_type: 'SpreeCmCommissioner::Route',
+        status: :active
+      )
+
+      active_mappings.find_each do |mapping|
+        next if synced_ids.include?(mapping.external_id)
+
+        mapping.mark_as_archived!
+        @sync_result.increment_metric(:route, :archived)
+      end
+    end
+
+    def build_route_name(origin_place, destination_place)
+      "#{origin_place.name} - #{destination_place.name}"
+    end
+
+    def build_short_name(origin_place, destination_place)
+      "#{place_code(origin_place)}-#{place_code(destination_place)}"
+    end
+
+    def place_code(place)
+      place.code.presence || place.id.to_s
+    end
+  end
+end