spree_cm_commissioner 2.5.1 → 2.5.2.pre.pre1

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)
+        end
+      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
+
+      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)
+        end
+      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
+
+      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 = {}
+
+          updates[:allow_boarding] = ts_form.allow_boarding? unless ts_form.allow_boarding.nil?
+          updates[:allow_drop_off] = ts_form.allow_drop_off unless ts_form.allow_drop_off.nil?
+
+          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/admin/inventory_items/prices.html.erb

@@ -0,0 +1,45 @@
+<%= turbo_frame_tag "inventory_item" do %>
+  <div>
+    <div class="p-3 mb-3 overflow-hidden border border-2 rounded bg-primary bg-opacity-10 border-primary position-relative">
+      <div class="text-white position-absolute top-50 translate-middle-y" style="right: -20px; opacity: 0.1;">
+        <%= svg_icon name: "money.svg", width: '120', height: '120' %>
+      </div>
+      <h5 class="mb-2 text-white modal-title position-relative">
+        <%= svg_icon name: "money.svg", width: '24', height: '24' %>
+        <span class="ml-2">Bulk Update Prices</span>
+      </h5>
+      <p class="mb-0 text-white position-relative"><%= @inventory_items.count %> items selected</p>
+    </div>
+
+    <%= form_with url: bulk_update_prices_admin_product_inventory_items_path(@product), method: :patch, local: true, html: { class: 'bulk-inventory-items-form' } do |form| %>
+      <%= form.hidden_field :inventory_ids, value: params[:inventory_ids] %>
+
+      <table class="table">
+        <tbody>
+          <% supported_currencies_for_all_stores.each do |currency| %>
+            <tr data-hook="bulk_prices_row">
+              <td><%= form.label "price_#{currency}", currency, class: 'form-label' %></td>
+              <td>
+                <%= form.hidden_field "prices[#{currency}][currency]", value: currency %>
+                <%= form.text_field "prices[#{currency}][price]",
+                    placeholder: "Price",
+                    class: 'form-control' %>
+              </td>
+              <td>
+                <%= form.text_field "prices[#{currency}][compare_at_price]",
+                    placeholder: "Compare at price",
+                    class: 'form-control' %>
+              </td>
+            </tr>
+          <% end %>
+        </tbody>
+      </table>
+
+      <div class="flex-row mt-2 d-flex justify-content-end">
+        <div class="form-actions" data-hook="buttons">
+          <%= button Spree.t('actions.save'), 'save.svg', 'submit', { class: 'btn-primary', data: { disable_with: "#{ Spree.t(:saving) }...", turbo_frame: "_top" } } %>
+        </div>
+      </div>
+    <% end %>
+  </div>
+<% end %>

data/app/views/spree/admin/inventory_items/stocks.html.erb

@@ -0,0 +1,36 @@
+<%= turbo_frame_tag "inventory_item" do %>
+  <div>
+    <div class="p-3 mb-3 overflow-hidden border border-2 rounded bg-success bg-opacity-10 border-success position-relative">
+      <div class="text-white position-absolute top-50 translate-middle-y" style="right: -20px; opacity: 0.1;">
+        <%= svg_icon name: "box-seam.svg", width: '120', height: '120' %>
+      </div>
+      <h5 class="mb-2 text-white modal-title position-relative">
+        <%= svg_icon name: "box-seam.svg", width: '24', height: '24' %>
+        <span class="ml-2">Bulk Update Stocks</span>
+      </h5>
+      <p class="mb-0 text-white position-relative"><%= @inventory_items.count %> items selected</p>
+    </div>
+
+    <%= form_with url: bulk_update_stocks_admin_product_inventory_items_path(@product), method: :patch, local: true, html: { class: 'bulk-inventory-items-form' } do |form| %>
+      <%= form.hidden_field :inventory_ids, value: params[:inventory_ids] %>
+
+      <div class="form-group">
+        <%= form.label :quantity, "Available Quantity", class: 'form-label' %>
+        <%= form.number_field :quantity,
+            placeholder: "Enter quantity",
+            class: 'form-control',
+            required: true,
+            min: 0 %>
+        <small class="form-text text-muted">
+          This quantity will be set for all <%= @inventory_items.count %> selected items and synced to Redis.
+        </small>
+      </div>
+
+      <div class="flex-row mt-2 d-flex justify-content-end">
+        <div class="form-actions" data-hook="buttons">
+          <%= button Spree.t('actions.save'), 'save.svg', 'submit', { class: 'btn-success', data: { disable_with: "#{ Spree.t(:saving) }...", turbo_frame: "_top" } } %>
+        </div>
+      </div>
+    <% end %>
+  </div>
+<% end %>