spree_cm_commissioner 2.5.1.pre.pre3 → 2.5.1.pre.pre4

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 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 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

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

@@ -0,0 +1,88 @@
+module SpreeCmCommissioner
+  module Trips
+    # Service class responsible for updating an existing single-leg trip.
+    # Handles updates to trip, product, variant, stops, and calendar in the booking system.
+    class UpdateSingleLeg
+      prepend Spree::ServiceModule::Base
+
+      # Main service method that orchestrates trip updates within a database transaction.
+      # Updates trip/product, variant if price provided, stops, and calendar conditionally.
+      # Returns success with updated objects or failure with error message.
+      def call(trip:, trip_form:)
+        ApplicationRecord.transaction do
+          update_trip_and_product(trip, trip_form)
+          update_variant(trip, trip_form) if trip_form.price.present?
+          update_trip_stops(trip, trip_form)
+          calendar = update_calendar(trip.product, trip_form.service_calendar) if trip_form.service_calendar.present?
+
+          success(trip: trip, variant: trip.product.variants.first, calendar: calendar)
+        rescue StandardError => e
+          CmAppLogger.error(
+            label: 'SpreeCmCommissioner::Trips::UpdateSingleLeg#call',
+            data: {
+              error_class: e.class.name,
+              error_message: e.message
+            }
+          )
+          failure(nil, 'Failed to update trip')
+        end
+      end
+
+      private
+
+      # Updates the trip record and associated product with attributes from the form.
+      def update_trip_and_product(trip, trip_form)
+        trip.update!(trip_attrs(trip_form))
+        trip.product.update!(product_attrs(trip_form))
+      end
+
+      # Updates the variant's price if a new price is provided in the form.
+      def update_variant(trip, trip_form)
+        variant = trip.product.variants.where.not(id: trip.product.master.id).first
+        return unless variant
+
+        variant.update!(price: trip_form.price)
+        trip.product.update!(price: trip_form.price)
+      end
+
+      # Iterates through stops and applies updates only if attributes are present.
+      def update_trip_stops(trip, trip_form)
+        trip.trip_stops.each_with_index do |stop, idx|
+          ts_form = trip_form.trip_stops[idx]
+          next unless ts_form
+
+          updates = {
+            allow_boarding: ts_form.allow_boarding?,
+            allow_drop_off: ts_form.allow_drop_off
+          }.compact
+
+          stop.update!(updates) if updates.any?
+        end
+      end
+
+      # Updates or creates the service calendar for the product using calendar form data.
+      def update_calendar(product, calendar_form)
+        result = 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 result.error unless result.success?
+
+        result.value[:calendar]
+      end
+
+      def trip_attrs(form)
+        { allow_booking: form.allow_booking, allow_seat_selection: form.allow_seat_selection }.compact
+      end
+
+      def product_attrs(form)
+        { name: form.name, short_name: form.short_name }.compact
+      end
+    end
+  end
+end

data/app/services/spree_cm_commissioner/trips/variants/create.rb

@@ -0,0 +1,103 @@
+module SpreeCmCommissioner
+  module Trips
+    module Variants
+      # Service class responsible for creating product and variant for a trip.
+      # Handles validations, product creation with options, variant pricing, and stock setup.
+      class Create
+        prepend ::Spree::ServiceModule::Base
+
+        # Main method that validates inputs and creates product, options, variant, and stock in transaction.
+        # Returns success with product and variant or failure with error message.
+        def call(vendor:, trip_form:, price:, capacity:)
+          return failure(nil, 'vendor must be present') if vendor.blank?
+          return failure(nil, 'trip_form must be present') if trip_form.blank?
+          return failure(nil, 'price must be present') if price.blank?
+          return failure(nil, 'capacity must be present') if capacity.blank?
+          return failure(nil, 'capacity must be greater than 0') if capacity <= 0
+
+          ApplicationRecord.transaction do
+            product = create_product!(vendor, trip_form)
+            option_values = setup_option_values!(product)
+            variant = create_variant!(product, price, option_values)
+
+            create_stock_item!(variant, capacity)
+
+            success(product: product, variant: variant)
+          end
+        rescue StandardError => e
+          CmAppLogger.error(
+            label: 'SpreeCmCommissioner::Trips::Variants::Create#call',
+            data: {
+              error_class: e.class.name,
+              error_message: e.message
+            }
+          )
+          failure(nil, e.message)
+        end
+
+        private
+
+        # Creates a transit product with name based on stops, assigns vendor, type, and options.
+        # Includes seat-type option type and default store association.
+        def create_product!(vendor, trip_form)
+          vendor_stops = stops(vendor, trip_form)
+          first_stop = vendor_stops[trip_form.trip_stops.first.stop_id].place
+          last_stop = vendor_stops[trip_form.trip_stops.last.stop_id].place
+
+          Spree::Product.create!(
+            name: trip_form.name.presence || "#{first_stop.name} - #{last_stop.name}",
+            short_name: trip_form.short_name,
+            vendor: vendor,
+            product_type: 'transit',
+            status: 'active',
+            available_on: Time.current,
+            price: trip_form.price,
+            shipping_category: Spree::ShippingCategory.find_or_create_by!(name: 'Default'),
+            option_types: [Spree::OptionType.find_by(name: 'seat-type')].compact,
+            stores: [Spree::Store.default].compact
+          )
+        end
+
+        # Retrieves and indexes stops from the vendor for the trip form's stop IDs.
+        def stops(vendor, trip_form)
+          vendor.stops.where(id: trip_form.trip_stops.map(&:stop_id)).index_by(&:id)
+        end
+
+        # Sets up or finds the seat-type option type and creates normal option value.
+        # Associates the option type with the product if not already present.
+        def setup_option_values!(product)
+          option_type = Spree::OptionType.find_or_create_by!(
+            name: 'seat-type',
+            presentation: 'Seat Type'
+          )
+
+          product.option_types << option_type unless product.option_types.include?(option_type)
+
+          option_value = option_type.option_values.find_or_create_by_name!(option_type, 'Normal')
+
+          [option_value]
+        end
+
+        # Creates a product variant with the given price and associated option values.
+        # Saves the variant to the database.
+        def create_variant!(product, price, option_values)
+          variant = product.variants.new(price: price)
+          variant.option_values = option_values
+          variant.save!
+          variant
+        end
+
+        # Creates a stock item for the variant with the specified capacity.
+        # Uses stock movement creator to initialize inventory.
+        def create_stock_item!(variant, capacity)
+          result = SpreeCmCommissioner::Stock::StockMovementCreator.call(
+            variant_id: variant.id,
+            current_store: variant.product.stores.first,
+            stock_movement_params: { quantity: capacity }
+          )
+          result.stock_item
+        end
+      end
+    end
+  end
+end

data/app/views/spree/transit/trip_stops/index.html.erb

@@ -9,7 +9,8 @@
         <tr data-hook="option_header">
           <th class="no-border handel-head"></th>
           <th><%= Spree.t(:name) %></th>
-          <th><%= Spree.t(:stop_type) %></th>
+          <th><%= Spree.t(:allow_boarding) %></th>
+          <th><%= Spree.t(:allow_drop_off) %></th>
           <th><%= Spree.t(:sequence) %></th>
           <th><%= Spree.t(:created_at) %></th>
         </tr>
@@ -21,7 +22,8 @@
               <%= svg_icon name: "grip-vertical.svg", width: '18', height: '18' %>
             </td>
             <td><%= stop.stop_name %></td>
-            <td> <%= stop.stop_type %></td>
+            <td> <%= stop.allow_boarding ? 'Yes' : 'No' %></td>
+	           <td> <%= stop.allow_drop_off ? 'Yes' : 'No' %></td>
             <td> <%= stop.sequence %></td>
             <td> <%= stop.created_at.to_date %></td>
           </tr>

data/app/views/spree_cm_commissioner/guest_mailer/send_ticket_to_guest.html.erb

@@ -151,7 +151,6 @@
             <% @trip.trip_stops.order(:sequence).each do |stop| %>
               <tr>
                 <td>
-                  <span class="stop-type <%= stop.stop_type %>"><%= stop.stop_type.to_s.titleize %></span>
                   <div class="stop-name"><strong><%= stop.stop_name %></strong></div>
                   <% if stop.respond_to?(:location_place) && stop.location_place.present? %>
                     <% if stop.location_place.respond_to?(:address) && stop.location_place.address.present? %>

data/config/initializers/spree_permitted_attributes.rb

@@ -1,5 +1,8 @@
 module Spree
   module PermittedAttributes
+    ATTRIBUTES << :route_attributes unless ATTRIBUTES.include?(:route_attributes)
+    mattr_reader :route_attributes
+
     @@vendor_attributes << :logo
 
     # Permitted all guest attributes for now as permitting only some guest attributes is not working by design
@@ -86,5 +89,13 @@ module Spree
       originator_type
       originator_id
     ]
+
+    @@route_attributes = %i[
+      route_name
+      short_name
+      vendor_id
+      route_type
+      route_stops
+    ]
   end
 end

data/config/routes.rb

@@ -560,6 +560,12 @@ Spree::Core::Engine.add_routes do
         resources :trip_places, only: :index
         resources :trip_search, only: [:index]
         resources :trips, only: %i[show]
+        resources :popular_route_places, only: [:index]
+        resources :routes, only: [:index]
+
+        namespace :transit do
+          resources :draft_orders, only: %i[create]
+        end
 
         namespace :intercity_taxi do
           resource :draft_orders, only: %i[create update]

data/db/migrate/20251224033103_migrate_cm_routes_to_cm_route_metrics.rb

@@ -0,0 +1,17 @@
+class MigrateCmRoutesToCmRouteMetrics < ActiveRecord::Migration[7.0]
+  def change
+    # 1. Rename cm_routes which we use to track order, trip count to cm_route_metrics instead.
+    remove_index :cm_routes, [:origin_place_id, :destination_place_id] if index_exists?(:cm_routes, [:origin_place_id, :destination_place_id])
+    rename_table :cm_routes, :cm_route_metrics unless table_exists?(:cm_route_metrics)
+    add_column :cm_route_metrics, :route_type, :integer, default: 0, null: false unless column_exists?(:cm_route_metrics, :route_type)
+
+    # 2. Drop the old index before renaming table to avoid index name length issues & re-add the index with a shorter name
+    unless index_exists?(:cm_route_metrics, [:route_type, :origin_place_id, :destination_place_id], name: 'index_cm_route_metrics_on_origin_dest')
+      add_index :cm_route_metrics, [:route_type, :origin_place_id, :destination_place_id], unique: true, name: 'index_cm_route_metrics_on_origin_dest'
+    end
+
+    # 3. Remove old route_id column from trips.
+    # it has route_metrics value, and trip don't need to have association with metric directly.
+    remove_column :cm_trips, :route_id if column_exists?(:cm_trips, :route_id)
+  end
+end

data/db/migrate/20251224033910_migrate_cm_vendor_routes_to_cm_routes.rb

@@ -0,0 +1,30 @@
+class MigrateCmVendorRoutesToCmRoutes < ActiveRecord::Migration[7.0]
+  def change
+    # 1. Remove cm_vendor_routes and add cm_routes instead for routes that associated with vendor.
+    drop_table :cm_vendor_routes, if_exists: true
+    create_table :cm_routes, if_not_exists: true do |t|
+      t.string :route_name
+      t.string :short_name
+      t.integer :order_count
+      t.integer :fulfilled_order_count
+      t.integer :route_type
+      t.jsonb :route_stops, default: "[]"
+      t.references :vendor, foreign_key: { to_table: :spree_vendors }, null: false
+      t.references :tenant, foreign_key: { to_table: :cm_tenants }, null: true
+
+      t.references :origin_place, foreign_key: { to_table: :cm_places }, null: false
+      t.references :destination_place, foreign_key: { to_table: :cm_places }, null: false
+
+      t.integer :lock_version, default: 0, null: false
+      t.timestamps
+    end
+
+    # 2. Add indexes for popular_routes association (vendor_id + order by fulfilled_order_count, order_count)
+    add_index :cm_routes, [:vendor_id, :route_type, :fulfilled_order_count, :order_count],
+              order: { fulfilled_order_count: :desc, order_count: :desc },
+              name: 'index_cm_routes_on_vendor_id_route_type_and_popular' unless index_exists?(:cm_routes, [:vendor_id, :route_type, :fulfilled_order_count, :order_count])
+
+    # 3. Add new route reference to cm_trips
+    add_reference :cm_trips, :route, foreign_key: { to_table: :cm_routes }, null: true unless column_exists?(:cm_trips, :route_id)
+  end
+end

data/db/migrate/20260105072450_migrate_cm_trip_stops_to_support_trip_connection.rb

@@ -0,0 +1,12 @@
+class MigrateCmTripStopsToSupportTripConnection < ActiveRecord::Migration[7.0]
+  def change
+    # 1. Replace stop_type with allow_boarding & allow_drop_off instead, it is more flexible.
+    # Useful for middle stops where both boarding & drop off can be allowed or both can be disallowed.
+    remove_column :cm_trip_stops, :stop_type if column_exists?(:cm_trip_stops, :stop_type)
+    add_column :cm_trip_stops, :allow_boarding, :boolean unless column_exists?(:cm_trip_stops, :allow_boarding)
+    add_column :cm_trip_stops, :allow_drop_off, :boolean unless column_exists?(:cm_trip_stops, :allow_drop_off)
+
+    # 2. Add references to link trip stops to trips for boarding, this will enable trip connections. Where current trip is main trip.
+    add_reference :cm_trip_stops, :board_to_trip, foreign_key: { to_table: :cm_trips }, null: true unless column_exists?(:cm_trip_stops, :board_to_trip_id)
+  end
+end

data/db/migrate/20260108101406_add_allow_booking_to_cm_trips.rb

@@ -0,0 +1,5 @@
+class AddAllowBookingToCmTrips < ActiveRecord::Migration[7.0]
+  def change
+    add_column :cm_trips, :allow_booking, :boolean, default: true, if_not_exists: true
+  end
+end

data/lib/spree_cm_commissioner/test_helper/factories/route_factory.rb

@@ -1,10 +1,11 @@
 FactoryBot.define do
-  factory :cm_route, class: 'SpreeCmCommissioner::Route' do
+  factory :cm_route, class: SpreeCmCommissioner::Route do
+    association :vendor, factory: :vendor
+    association :tenant, factory: :cm_tenant
+    association :origin_place, factory: :cm_place
+    association :destination_place, factory: :cm_place
+
     sequence(:route_name) { |n| "Route #{n}" }
-    origin_place_id { create(:cm_place).id }
-    destination_place_id { create(:cm_place).id }
-    trip_count { 0 }
-    order_count { 0 }
-    fulfilled_order_count { 0 }
+    sequence(:short_name) { |n| "R#{n}" }
   end
 end

data/lib/spree_cm_commissioner/test_helper/factories/route_metric_factory.rb

@@ -0,0 +1,12 @@
+FactoryBot.define do
+  factory :cm_route_metric, class: SpreeCmCommissioner::RouteMetric do
+    association :origin_place, factory: :cm_place
+    association :destination_place, factory: :cm_place
+
+    route_name { "#{origin_place.name} - #{destination_place.name}" } 
+    route_type { :bus }
+    trip_count { 0 }
+    order_count { 0 }
+    fulfilled_order_count { 0 }
+  end
+end

data/lib/spree_cm_commissioner/test_helper/factories/route_photo_factory.rb

@@ -0,0 +1,5 @@
+FactoryBot.define do
+  factory :cm_route_photo, class: SpreeCmCommissioner::RoutePhoto do
+    attachment { Rack::Test::UploadedFile.new(SpreeMultiVendor::Engine.root.join('spec', 'fixtures', 'thinking-cat.jpg'), 'image/jpeg') }
+  end
+end

data/lib/spree_cm_commissioner/test_helper/factories/trip_factory.rb

@@ -11,7 +11,10 @@ FactoryBot.define do
     association :vehicle, factory: :cm_vehicle
     association :origin_place, factory: :cm_place
     association :destination_place, factory: :cm_place
-    association :route, factory: :cm_route
+
+    # Don't create route by default to avoid uniqueness conflicts
+    # Tests that need these should create them explicitly
+    route { nil }
   end
 
   factory :cm_trip_with_seat_counts, parent: :cm_trip do

data/lib/spree_cm_commissioner/test_helper/factories/trip_stop_factory.rb

@@ -4,7 +4,9 @@ FactoryBot.define do
     association :stop_place, factory: :cm_place
     association :location_place, factory: :cm_place
 
-    stop_type { :boarding }
+    allow_boarding { true }
+    allow_drop_off { true }
+
     stop_name { stop_place.name }
 
     arrival_time { Time.current }

data/lib/spree_cm_commissioner/test_helper/factories/vendor_factory.rb

@@ -1,5 +1,6 @@
 FactoryBot.define do
   factory :cm_transit_vendor, parent: :vendor do
+    from_email { FFaker::Internet.email } # required only when tenant exist.
     sequence(:name) { |n| "#{FFaker::Company.name} #{n}#{Kernel.rand(9999)}" }
     state { :active }
     primary_product_type { :transit }
@@ -7,6 +8,7 @@ FactoryBot.define do
 
   factory :cm_vendor, parent: :vendor do
     sequence(:name) { |n| "#{FFaker::Company.name} #{n}#{Kernel.rand(9999)}" }
+    from_email { FFaker::Internet.email } # required only when tenant exist.
     state { :active }
     default_state_id { Spree::State.first&.id }
     primary_product_type { :ecommerce }

data/lib/spree_cm_commissioner/test_helper/factories/vendor_place_factory.rb

@@ -7,6 +7,17 @@ FactoryBot.define do
     position  { FFaker::Number.number }
 
     place_type { :location }
+
+    transient do
+      place_name { nil }
+    end
+
+    before :create do |vendor_place, evaluator|
+      if evaluator.place_name.present?
+        vendor_place.place.name = evaluator.place_name
+        vendor_place.place.save!
+      end
+    end
   end
 
   factory :cm_vendor_place, class: SpreeCmCommissioner::VendorPlace do
@@ -30,5 +41,16 @@ FactoryBot.define do
       place_type { :location }
       location { nil }
     end
+
+    transient do
+      place_name { nil }
+    end
+
+    before :create do |vendor_place, evaluator|
+      if evaluator.place_name.present?
+        vendor_place.place.name = evaluator.place_name
+        vendor_place.place.save!
+      end
+    end
   end
 end