spree_cm_commissioner 2.5.1.pre.pre1 → 2.5.1.pre.pre2

data/app/services/spree_cm_commissioner/pricing_models/create_with_rule_groups.rb

@@ -0,0 +1,56 @@
+module SpreeCmCommissioner
+  module PricingModels
+    class CreateWithRuleGroups
+      prepend ::Spree::ServiceModule::Base
+
+      def call(vendor:, params:, route: nil, origin_place_id: nil, destination_place_id: nil)
+        pricing_model = vendor.pricing_models.new(model_params(params))
+
+        ApplicationRecord.transaction do
+          pricing_model.save!
+          build_rule_groups(pricing_model, params[:rule_groups])
+          create_route_assignment(pricing_model, route, origin_place_id, destination_place_id) if route.present?
+        end
+
+        success(pricing_model)
+      rescue ActiveRecord::RecordInvalid => e
+        failure(pricing_model, e.message)
+      end
+
+      private
+
+      def model_params(params)
+        {
+          name: params[:name],
+          description: params[:description],
+          status: params[:status] || 'draft',
+          variant_ids: params[:variant_ids] || []
+        }
+      end
+
+      def build_rule_groups(pricing_model, rule_groups_params)
+        return if rule_groups_params.blank?
+
+        rule_groups_params.each do |template_key, group_params|
+          next if group_params.blank?
+
+          PricingRules::Create.call(
+            pricing_model: pricing_model,
+            params: group_params.merge(template_key: template_key)
+          )
+        end
+      end
+
+      def create_route_assignment(pricing_model, route, origin_place_id, destination_place_id)
+        return unless origin_place_id.present? && destination_place_id.present?
+
+        PricingModelRoute.create!(
+          route: route,
+          pricing_model: pricing_model,
+          origin_place_id: origin_place_id,
+          destination_place_id: destination_place_id
+        )
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/pricing_models/update_with_rule_groups.rb

@@ -0,0 +1,69 @@
+module SpreeCmCommissioner
+  module PricingModels
+    class UpdateWithRuleGroups
+      prepend ::Spree::ServiceModule::Base
+
+      def call(pricing_model:, params:, route: nil, origin_place_id: nil, destination_place_id: nil)
+        ApplicationRecord.transaction do
+          pricing_model.update!(model_params(params))
+          sync_rule_groups(pricing_model, params[:rule_groups])
+          update_route_assignment(pricing_model, route, origin_place_id, destination_place_id) if route.present?
+        end
+
+        success(pricing_model)
+      rescue ActiveRecord::RecordInvalid => e
+        failure(pricing_model, e.message)
+      end
+
+      private
+
+      def model_params(params)
+        {
+          name: params[:name],
+          description: params[:description],
+          status: params[:status],
+          variant_ids: params[:variant_ids] || []
+        }.compact
+      end
+
+      def sync_rule_groups(pricing_model, rule_groups_params)
+        return if rule_groups_params.nil?
+
+        keep_ids = []
+
+        rule_groups_params.each do |template_key, group_params|
+          next if group_params.blank?
+
+          if group_params[:id].present?
+            group = pricing_model.pricing_rule_groups.find(group_params[:id])
+            PricingRules::Update.call(
+              pricing_rule_group: group,
+              params: group_params.merge(template_key: template_key)
+            )
+            keep_ids << group.id
+          else
+            new_group = PricingRules::Create.call(
+              pricing_model: pricing_model,
+              params: group_params.merge(template_key: template_key)
+            )
+            keep_ids << new_group.id if new_group.persisted?
+          end
+        end
+        pricing_model.pricing_rule_groups.where.not(id: keep_ids).destroy_all
+      end
+
+      def update_route_assignment(pricing_model, route, origin_place_id, destination_place_id)
+        return unless origin_place_id.present? && destination_place_id.present?
+
+        route_assignment = PricingModelRoute.find_or_initialize_by(
+          route: route,
+          pricing_model: pricing_model
+        )
+        route_assignment.update!(
+          origin_place_id: origin_place_id,
+          destination_place_id: destination_place_id
+        )
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/pricing_rules/build_params.rb

@@ -5,14 +5,16 @@ module SpreeCmCommissioner
 
       def permitted_group_params(params)
         group_params = params[:spree_cm_commissioner_pricing_rule_group] || params
+        template_key = group_params[:template_key] || params[:template_key]
+        template = PRICING_RULE_GROUP_TEMPLATES[template_key.to_sym] if template_key
 
         {
-          name: group_params[:name],
-          status: group_params[:status],
-          template_key: group_params[:template_key],
-          match_type: group_params[:match_type],
+          name: template&.dig(:name) || group_params[:name],
+          status: group_params[:status] || 'active',
+          template_key: template_key,
+          match_type: group_params[:match_type] || 'any',
           pricing_rules_attributes: build_rules_attributes(params[:pricing_rules]),
-          pricing_action_attributes: build_action_attributes(params[:pricing_action])
+          pricing_action_attributes: build_action_attributes(params[:pricing_action], template)
         }
       end
 
@@ -29,14 +31,21 @@ module SpreeCmCommissioner
         end
       end
 
-      def build_action_attributes(action_data)
+      def build_action_attributes(action_data, template = nil)
         return nil unless action_data&.dig(:calculator)
 
         calc_data = action_data[:calculator]
         calculator = calc_data[:type].safe_constantize&.new
+
         set_preferences(calculator, calc_data[:preferences]) if calculator
 
-        { id: action_data[:id], calculator: calculator }
+        action_type = action_data[:type] || template&.dig(:action, :type)
+
+        {
+          id: action_data[:id],
+          type: action_type,
+          calculator: calculator
+        }
       end
 
       def set_preferences(calculator, preferences)

data/app/services/spree_cm_commissioner/route_metrics/decrease_trip_count.rb

@@ -0,0 +1,31 @@
+module SpreeCmCommissioner
+  module RouteMetrics
+    class DecreaseTripCount
+      prepend ::Spree::ServiceModule::Base
+
+      def call(trip:)
+        return failure(nil, 'Trip not found') unless trip
+
+        route_metric = find_or_create_route_metric(trip)
+
+        route_metric.with_lock do
+          route_metric.update!(trip_count: [route_metric.trip_count - 1, 0].max)
+        end
+
+        success(trip: trip)
+      rescue StandardError => e
+        failure(nil, e.message)
+      end
+
+      private
+
+      def find_or_create_route_metric(trip)
+        SpreeCmCommissioner::RouteMetric.find_or_create_by!(
+          origin_place_id: trip.origin_place_id,
+          destination_place_id: trip.destination_place_id,
+          route_type: trip.route_type
+        )
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/{routes/increment_fulfilled_order_count.rb → route_metrics/increase_fulfilled_order_count.rb}

@@ -1,12 +1,12 @@
 module SpreeCmCommissioner
-  module Routes
-    class IncrementFulfilledOrderCount
+  module RouteMetrics
+    class IncreaseFulfilledOrderCount
       prepend ::Spree::ServiceModule::Base
 
       def call(order:)
         return failure(nil, 'Order not found') unless order
 
-        SpreeCmCommissioner::Routes::BaseUpdateOrderMetrics
+        SpreeCmCommissioner::RouteMetrics::UpdateRouteMetrics
           .call(order: order, attribute: :fulfilled_order_count)
 
         success(order: order)

data/app/services/spree_cm_commissioner/{routes/increment_order_count.rb → route_metrics/increase_order_count.rb}

@@ -1,12 +1,12 @@
 module SpreeCmCommissioner
-  module Routes
-    class IncrementOrderCount
+  module RouteMetrics
+    class IncreaseOrderCount
       prepend ::Spree::ServiceModule::Base
 
       def call(order:)
         return failure(nil, 'Order not found') unless order
 
-        SpreeCmCommissioner::Routes::BaseUpdateOrderMetrics
+        SpreeCmCommissioner::RouteMetrics::UpdateRouteMetrics
           .new(order: order, attribute: :order_count)
           .call
 

data/app/services/spree_cm_commissioner/route_metrics/increase_trip_count.rb

@@ -0,0 +1,31 @@
+module SpreeCmCommissioner
+  module RouteMetrics
+    class IncreaseTripCount
+      prepend ::Spree::ServiceModule::Base
+
+      def call(trip:)
+        return failure(nil, 'Trip not found') unless trip
+
+        route_metric = find_or_create_route_metric(trip)
+
+        route_metric.with_lock do
+          route_metric.update!(trip_count: route_metric.trip_count + 1)
+        end
+
+        success(trip: trip)
+      rescue StandardError => e
+        failure(nil, e.message)
+      end
+
+      private
+
+      def find_or_create_route_metric(trip)
+        SpreeCmCommissioner::RouteMetric.find_or_create_by!(
+          origin_place_id: trip.origin_place_id,
+          destination_place_id: trip.destination_place_id,
+          route_type: trip.route_type
+        )
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/{routes/base_update_order_metrics.rb → route_metrics/update_route_metrics.rb}

@@ -1,6 +1,6 @@
 module SpreeCmCommissioner
-  module Routes
-    class BaseUpdateOrderMetrics
+  module RouteMetrics
+    class UpdateRouteMetrics
       attr_reader :order, :attribute
 
       SUPPORTED_ATTRIBUTES = %i[order_count fulfilled_order_count].freeze
@@ -31,26 +31,21 @@ module SpreeCmCommissioner
         trip = product&.trip
         return unless trip
 
-        route = find_or_create_route_for_trip(trip)
-        ensure_trip_route(trip, route)
-        increment_route_by(route, line_item.quantity)
+        route_metric = find_or_create_route_metric_for_trip(trip)
+        increment_route_by(route_metric, line_item.quantity)
+
+        route = trip.route
+        increment_route_by(route, line_item.quantity) if route
       end
 
-      def find_or_create_route_for_trip(trip)
-        SpreeCmCommissioner::Route.find_or_create_by(
+      def find_or_create_route_metric_for_trip(trip)
+        SpreeCmCommissioner::RouteMetric.find_or_create_by(
           origin_place_id: trip.origin_place_id,
-          destination_place_id: trip.destination_place_id
+          destination_place_id: trip.destination_place_id,
+          route_type: trip.route_type
         )
       end
 
-      def ensure_trip_route(trip, route)
-        trip_route_id = trip.respond_to?(:route_id) ? trip.route_id : nil
-
-        return unless trip.respond_to?(:update_column) && trip_route_id != route.id
-
-        trip.update_column(:route_id, route.id) # rubocop:disable Rails/SkipsModelValidations
-      end
-
       def increment_route_by(route, qty)
         route.with_lock do
           current_value = route.public_send(attribute) || 0

data/app/services/spree_cm_commissioner/routes/create.rb

@@ -0,0 +1,51 @@
+module SpreeCmCommissioner
+  module Routes
+    class Create
+      prepend ::Spree::ServiceModule::Base
+
+      # @param vendor [Spree::Vendor]
+      # @param route_params [Hash]
+      # @param route_stops [SpreeCmCommissioner::Transit::RouteStopCollection]
+      def call(vendor:, route_params:, route_stops:)
+        # vendor_id, tenant_id, origin_place_id, destination_place_id are excluded and set automatically.
+        attrs = ::Spree::PermittedAttributes.route_attributes
+                                            .index_with { |attr_key| route_params[attr_key] }
+                                            .except(:vendor_id, :tenant_id, :route_stops, :origin_place_id, :destination_place_id)
+                                            .compact
+
+        return failure(nil, 'Route stops are required') if route_stops.length < 2
+
+        origin_place = find_place_for(route_stops, route_stops.first)
+        destination_place = find_place_for(route_stops, route_stops.last)
+
+        return failure(nil, 'Origin or destination place could not be determined') if origin_place.nil? || destination_place.nil?
+        return failure(nil, 'Route with origin & destination already exists') if vendor.routes.exists?(
+          origin_place_id: origin_place.id,
+          destination_place_id: destination_place.id
+        )
+
+        attrs = attrs.merge(
+          tenant_id: vendor.tenant_id,
+          route_name: attrs[:route_name] || "#{origin_place.name} -> #{destination_place.name}",
+          origin_place_id: origin_place.id,
+          destination_place_id: destination_place.id,
+          route_stops: route_stops
+        )
+
+        route = vendor.routes.new(attrs)
+        if route.save
+          success(route: route)
+        else
+          failure(route.errors)
+        end
+      end
+
+      def find_place_for(route_stops, route_stop)
+        return nil if route_stop.nil?
+
+        @locations ||= SpreeCmCommissioner::VendorPlace.where(id: route_stops.map(&:location_id).uniq).index_by(&:id)
+        @locations[route_stop.location_id]&.place
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/routes/update.rb

@@ -0,0 +1,25 @@
+module SpreeCmCommissioner
+  module Routes
+    class Update
+      prepend ::Spree::ServiceModule::Base
+
+      def call(vendor:, route:, route_params:)
+        # vendor_id, tenant_id, origin_place_id, destination_place_id are excluded and set automatically.
+        # route_stops is not updateable.
+        attrs = ::Spree::PermittedAttributes.route_attributes
+                                            .index_with { |attr_key| route_params[attr_key] }
+                                            .except(:vendor_id, :tenant_id, :route_stops, :origin_place_id, :destination_place_id)
+                                            .compact
+
+        route = vendor.routes.find_by(id: route.id)
+        return failure(nil, :route_not_found) if route.nil?
+
+        if route.update(attrs)
+          success(route: route)
+        else
+          failure(route.errors)
+        end
+      end
+    end
+  end
+end

data/app/{interactors/spree_cm_commissioner/transit/draft_order_creator.rb → services/spree_cm_commissioner/transit_order/create.rb}

@@ -1,4 +1,4 @@
-# DraftOrderCreator creates a new order for a entire journey, including outbound and (if present) inbound directions.
+# SpreeCmCommissioner::TransitOrder::Create creates a new order for a entire journey, including outbound and (if present) inbound directions.
 #
 # Attributes:
 # - outbound_date: [Date] The date of outbound transit
@@ -12,25 +12,22 @@
 #
 # Note: inbound_legs and inbound_date are optional; the order may represent a one-way (outbound only) journey.
 module SpreeCmCommissioner
-  module Transit
-    class DraftOrderCreator < BaseInteractor
-      delegate :outbound_date,
-               :inbound_date,
-               :outbound_legs,
-               :inbound_legs,
-               :user, to: :context
+  module TransitOrder
+    class Create
+      prepend ::Spree::ServiceModule::Base
 
-      def call
-        return context.fail!(message: 'Outbound legs are missing') if outbound_legs.blank?
+      def call(outbound_date:, inbound_date:, outbound_legs:, inbound_legs: [], user: nil)
+        return failure(nil, 'Outbound legs are missing') if outbound_legs.blank?
 
         begin
-          context.order = create_order!
+          order = create_order!(outbound_date, inbound_date, outbound_legs, inbound_legs, user)
+          success(order: order)
         rescue StandardError => e
-          context.fail!(message: e.message)
+          failure(nil, e.message)
         end
       end
 
-      def create_order!
+      def create_order!(outbound_date, inbound_date, outbound_legs, inbound_legs, user)
         order = Spree::Order.new(state: 'cart', use_billing: true, user: user)
 
         outbound_line_items = build_line_items_for_legs!(order: order, legs: outbound_legs, initial_date: outbound_date)
@@ -112,10 +109,10 @@ module SpreeCmCommissioner
 
       def insert_saved_guests_per_line_items_leg(line_items)
         line_items.flat_map(&:guests).each_with_index do |guest, index|
-          context.saved_guests ||= []
-          context.saved_guests << SpreeCmCommissioner::SavedGuest.new if context.saved_guests[index].blank?
+          @saved_guests ||= []
+          @saved_guests << SpreeCmCommissioner::SavedGuest.new if @saved_guests[index].blank?
 
-          guest.saved_guest = context.saved_guests[index]
+          guest.saved_guest = @saved_guests[index]
         end
 
         line_items

data/app/services/spree_cm_commissioner/trips/create_single_leg.rb

@@ -0,0 +1,123 @@
+module SpreeCmCommissioner
+  module Trips
+    # Service class responsible for creating a single-leg trip in the booking system.
+    # Orchestrates the creation of product variant, trip record, stops, calendar, and inventory.
+    class CreateSingleLeg
+      prepend Spree::ServiceModule::Base
+
+      # Main service method that validates the trip form and orchestrates creation.
+      # Creates variant, trip, calendar, and inventory within a database transaction.
+      # Returns success with created objects or failure with error message on exceptions.
+      def call(vendor:, trip_form:)
+        return failure(nil, trip_form.errors.full_messages.to_sentence) unless trip_form.valid_data?
+
+        ApplicationRecord.transaction do
+          variant = create_variant!(vendor, trip_form)
+          trip = create_trip!(vendor, trip_form, variant)
+          calendar = setup_calendar!(variant.product, trip_form.service_calendar)
+          generate_inventory!(variant)
+
+          success(trip: trip, variant: variant, calendar: calendar)
+        rescue StandardError => e
+          CmAppLogger.error(
+            label: 'SpreeCmCommissioner::Trips::CreateSingleLeg#call',
+            data: {
+              error_class: e.class.name,
+              error_message: e.message
+            }
+          )
+          failure(nil, e.message)
+        end
+      end
+
+      private
+
+      # Creates a product variant for the trip using the vehicle type's seat capacity.
+      def create_variant!(vendor, trip_form)
+        first_stop = trip_form.trip_stops.first
+        vehicle_type = SpreeCmCommissioner::VehicleType.find(first_stop.vehicle_type_id)
+        capacity = vehicle_type.number_of_seats
+
+        result = SpreeCmCommissioner::Trips::Variants::Create.call(
+          vendor: vendor,
+          trip_form: trip_form,
+          price: trip_form.price || 0.0,
+          capacity: capacity
+        )
+
+        raise StandardError, result.error unless result.success?
+
+        result.value[:variant]
+      end
+
+      # Creates the main trip record with details extracted from the trip form.
+      # Associates the trip with vendor, product, vehicle, route, and time.
+      def create_trip!(vendor, trip_form, variant)
+        first_stop = trip_form.trip_stops.first
+        last_stop  = trip_form.trip_stops.last
+
+        locations = vendor.locations.where(id: trip_form.trip_stops.map(&:location_id)).index_by(&:id)
+        stops = vendor.stops.where(id: trip_form.trip_stops.map(&:stop_id)).index_by(&:id)
+
+        trip = vendor.trips.create!(
+          product: variant.product,
+          vehicle_type: SpreeCmCommissioner::VehicleType.find_by(id: first_stop.vehicle_type_id),
+          vehicle: SpreeCmCommissioner::Vehicle.find_by(id: first_stop.vehicle_id),
+          origin_place: locations[first_stop.location_id].place,
+          destination_place: locations[last_stop.location_id].place,
+          route: vendor.routes.find(trip_form.route_id),
+          departure_time: first_stop.departure_time,
+          duration: trip_form.total_duration_seconds,
+          allow_booking: trip_form.allow_booking,
+          allow_seat_selection: trip_form.allow_seat_selection,
+          route_type: trip_form.route_type || vendor.routes.find(trip_form.route_id)&.route_type
+        )
+
+        create_trip_stops(trip, trip_form, locations, stops)
+        trip
+      end
+
+      # Creates individual trip stops based on the trip form stops.
+      # Each stop includes arrival/departure times and boarding/drop-off permissions.
+      def create_trip_stops(trip, trip_form, locations, stops)
+        previous_departure = nil
+
+        trip_form.trip_stops.each do |ts|
+          arrival_time = previous_departure || ts.departure_time
+
+          trip.trip_stops.create!(
+            stop_place: stops[ts.stop_id].place,
+            location_place: locations[ts.location_id].place,
+            allow_boarding: ts.allow_boarding?,
+            allow_drop_off: ts.allow_drop_off,
+            arrival_time: arrival_time,
+            departure_time: ts.departure_time
+          )
+
+          previous_departure = ts.departure_time
+        end
+      end
+
+      # Sets up the service calendar for the trip, defining operational dates, weekdays, and exceptions.
+      def setup_calendar!(product, calendar_form)
+        res = SpreeCmCommissioner::Trips::ServiceCalendars::CreateOrUpdate.call(
+          calendarable: product,
+          name: calendar_form.name,
+          start_date: calendar_form.start_date,
+          end_date: calendar_form.end_date,
+          weekdays: calendar_form.weekdays,
+          exception_rules: calendar_form.exception_rules || []
+        )
+
+        raise StandardError, res.error unless res.success?
+
+        res.value[:calendar]
+      end
+
+      # Triggers asynchronous generation of permanent inventory items for the variant.
+      def generate_inventory!(variant)
+        SpreeCmCommissioner::Stock::PermanentInventoryItemsGeneratorJob.perform_later(variant_ids: [variant[:id]])
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/trips/service_calendars/create_or_update.rb

@@ -0,0 +1,54 @@
+module SpreeCmCommissioner
+  module Trips
+    module ServiceCalendars
+      # Service to create or update a service calendar for a calendarable entity.
+      class CreateOrUpdate
+        prepend ::Spree::ServiceModule::Base
+
+        def call(calendarable:, name:, start_date:, end_date:, weekdays:, exception_rules: []) # rubocop:disable Metrics/ParameterLists
+          return failure(nil, 'calendarable must be present') if calendarable.blank?
+          return failure(nil, 'name must be present') if name.blank?
+          return failure(nil, 'start_date must be present') if start_date.blank?
+          return failure(nil, 'end_date must be present') if end_date.blank?
+          return failure(nil, 'weekdays must be present') if weekdays.blank?
+
+          ApplicationRecord.transaction do
+            calendar = create_or_update_calendar(calendarable, name, start_date, end_date, weekdays, exception_rules)
+            success(calendar: calendar)
+          end
+        rescue StandardError => e
+          CmAppLogger.error(
+            label: 'SpreeCmCommissioner::Trips::ServiceCalendars::CreateOrUpdate#call',
+            data: {
+              error_class: e.class.name,
+              error_message: e.message
+            }
+          )
+          failure(nil, 'Failed to create service calendar')
+        end
+
+        private
+
+        # Create or update calendar
+        def create_or_update_calendar(calendarable, name, start_date, end_date, weekdays, exception_rules) # rubocop:disable Metrics/ParameterLists
+          calendar = calendarable.service_calendar || calendarable.build_service_calendar
+
+          calendar.assign_attributes(
+            name: name,
+            start_date: start_date,
+            end_date: end_date,
+            exception_rules: exception_rules
+          )
+
+          # Set weekday attributes
+          weekdays.each do |day, enabled|
+            calendar.send("#{day}=", enabled)
+          end
+
+          calendar.save!
+          calendar
+        end
+      end
+    end
+  end
+end