spree_core 5.6.1 → 6.0.0.beta2

data/app/models/spree/import.rb

@@ -5,7 +5,7 @@ module Spree
     has_prefix_id :imp
 
     include Spree::NumberIdentifier
-    include Spree::Core::NumberGenerator.new(prefix: 'IM')
+    has_spree_number prefix: 'IM'
 
     # Where the downloadable example CSVs are served from — see `sample_csv_url`.
     #
@@ -22,10 +22,19 @@ module Spree
     # This ensures Spree::Imports::Products publishes 'import.create' not 'products.create'
     self.event_prefix = 'import'
 
+    include Spree::SingleStoreResource
+
     #
     # Associations
     #
-    belongs_to :owner, polymorphic: true # Store, Vendor, etc.
+    # Which marketplace this import belongs to, and — when a seller ran it —
+    # whose it is. A null seller means the operator's own, which is what lets
+    # one store-scoped list carry both (see `Spree::Export`, the same pair).
+    #
+    # `with_deleted` because a seller is soft-deleted and their import history
+    # has to stay readable afterwards; an operator debugging a departed
+    # seller's catalog is exactly when it matters.
+    belongs_to :seller, -> { with_deleted }, class_name: 'Spree::Seller', optional: true
     belongs_to :user, class_name: Spree.admin_user_class.to_s, optional: true
     has_many :mappings, class_name: 'Spree::ImportMapping', dependent: :destroy, inverse_of: :import
     alias import_mappings mappings
@@ -35,20 +44,28 @@ module Spree
     #
     # Validations
     #
-    validates :owner, :user, :type, presence: true
+    validates :user, :type, presence: true
     validates :attachment, presence: true, unless: -> { Rails.env.test? }
     validate :ensure_whitelisted_type
     validate :ensure_attachment_content_type
+    validate :ensure_seller_belongs_to_store
 
     #
     # Ransack configuration
     #
-    self.whitelisted_ransackable_attributes = %w[number type status]
+    self.whitelisted_ransackable_attributes = %w[number type status seller_id]
+    # Lets an operator filter their list by who ran the job — the seller's
+    # name, not an id they would have to look up first.
+    self.whitelisted_ransackable_associations = %w[seller]
 
     #
     # Scopes
     #
-    scope :for_store, ->(store) { where(owner: store) }
+    # `for_store` comes from Spree::SingleStoreResource and now includes a
+    # store's sellers' imports, which is what puts them in the operator's list.
+    scope :for_seller, ->(seller) { where(seller_id: seller) }
+    # The operator's own, as opposed to those their sellers ran.
+    scope :first_party, -> { where(seller_id: nil) }
 
     #
     # Attachments
@@ -56,42 +73,14 @@ module Spree
     has_one_attached :attachment, service: Spree.private_storage_service_name
 
     #
-    # State machine
+    # Status
     #
-    state_machine initial: :pending, attribute: :status do
-      event :start_mapping do
-        transition to: :mapping
-      end
-      before_transition to: :mapping, do: :create_mappings
-
-      event :complete_mapping do
-        transition from: :mapping, to: :completed_mapping
-      end
-      after_transition to: :completed_mapping, do: :create_rows_async
-
-      event :start_processing do
-        transition from: :completed_mapping, to: :processing
-      end
-
-      event :complete do
-        transition from: :processing, to: :completed
-      end
-      after_transition to: :completed, do: :touch_store
-      after_transition to: :completed, do: :publish_import_completed_event
-      # NOTE: send_import_completed_email and update_loader_in_import_view
-      # are now handled by Spree::Admin::ImportSubscriber listening to 'import.completed' event
-
-      event :fail do
-        transition to: :failed
-      end
-
-      # Re-processes rows that failed: the dispatcher targets pending_and_failed
-      # rows, so retry is just a transition + re-dispatch.
-      event :retry_failed_rows do
-        transition from: :completed, to: :processing, if: ->(import) { import.rows.failed.exists? }
-      end
-      after_transition on: :retry_failed_rows, do: :process_rows_async
-    end
+    # No state machine — the pipeline's steps are the Spree::Imports workflows
+    # (docs/plans/6.0-service-workflows.md), which is also what let the row
+    # dispatch stop tiptoeing around a transition's transaction.
+    include Spree::HasStatus
+    has_status :pending, :mapping, :completed_mapping, :processing, :completed, :failed,
+               default: :pending
 
     #
     # Preferences
@@ -164,6 +153,44 @@ module Spree
       nil
     end
 
+    # @deprecated Call the Spree::Imports workflows — removed in 6.1.
+    def start_mapping!
+      Spree::Deprecation.warn('Spree::Import#start_mapping! is deprecated and will be removed in Spree 6.1. Call Spree.import_start_mapping_workflow instead.')
+      run_pipeline_workflow(Spree.import_start_mapping_workflow)
+    end
+
+    # @deprecated Call Spree.import_complete_mapping_workflow — removed in 6.1.
+    def complete_mapping!
+      Spree::Deprecation.warn('Spree::Import#complete_mapping! is deprecated and will be removed in Spree 6.1. Call Spree.import_complete_mapping_workflow instead.')
+      run_pipeline_workflow(Spree.import_complete_mapping_workflow)
+    end
+
+    # @deprecated Call Spree.import_start_processing_workflow — removed in 6.1.
+    def start_processing!
+      Spree::Deprecation.warn('Spree::Import#start_processing! is deprecated and will be removed in Spree 6.1. Call Spree.import_start_processing_workflow instead.')
+      run_pipeline_workflow(Spree.import_start_processing_workflow)
+    end
+
+    # @deprecated Call Spree.import_complete_workflow — removed in 6.1.
+    def complete!
+      Spree::Deprecation.warn('Spree::Import#complete! is deprecated and will be removed in Spree 6.1. Call Spree.import_complete_workflow instead.')
+      run_pipeline_workflow(Spree.import_complete_workflow)
+    end
+
+    # @deprecated Set the status — removed in 6.1. Failure was never a step of
+    #   its own; the controller records the parse error directly.
+    def fail!
+      Spree::Deprecation.warn('Spree::Import#fail! is deprecated and will be removed in Spree 6.1. Write the status instead.')
+      update!(status: 'failed')
+    end
+
+    # @deprecated Call Spree.import_retry_failed_rows_workflow — removed in 6.1.
+    #   Returns false when there is nothing to retry, as the guarded event did.
+    def retry_failed_rows
+      Spree::Deprecation.warn('Spree::Import#retry_failed_rows is deprecated and will be removed in Spree 6.1. Call Spree.import_retry_failed_rows_workflow instead.')
+      Spree.import_retry_failed_rows_workflow.call(import: self).success?
+    end
+
     # Returns true if the import is in mapping state
     # @return [Boolean]
     def mapping?
@@ -183,7 +210,7 @@ module Spree
     end
 
     # Imports are deletable only while no processing jobs can be in flight —
-    # CreateRowsJob/ProcessGroupJob re-load the record mid-run.
+    # ProcessJob/ProcessGroupJob re-load the record mid-run.
     # @return [Boolean]
     def can_be_deleted?
       %w[pending mapping completed failed].include?(status)
@@ -239,7 +266,7 @@ module Spree
     # @return [Class]
     def model_class
       if type == 'Spree::Imports::Customers'
-        Spree.user_class
+        Spree.customer_class
       else
         "Spree::#{type.demodulize.singularize}".safe_constantize
       end
@@ -258,20 +285,20 @@ module Spree
     end
 
     # Returns the fields for the import schema
-    # If model supports metafields, it will include the metafield definitions for this model
+    # If model supports custom_fields, it will include the custom_field definitions for this model
     # @return [Array<Hash>]
     def schema_fields
       base_fields = import_schema.fields
 
-      # Dynamically add metafield definitions if the model supports metafields
-      if model_class_supports_metafields?
-        metafield_fields = metafield_definitions_for_model.map do |definition|
+      # Dynamically add custom_field definitions if the model supports custom_fields
+      if model_class_supports_custom_fields?
+        custom_field_fields = custom_field_definitions_for_model.map do |definition|
           {
             name: definition.csv_header_name,
-            label: definition.name
+            label: definition.label
           }
         end
-        base_fields + metafield_fields
+        base_fields + custom_field_fields
       else
         base_fields
       end
@@ -307,14 +334,6 @@ module Spree
       "#{Spree.t(type.demodulize.pluralize.downcase)} #{number}"
     end
 
-    def touch_store
-      store.touch
-    end
-
-    def publish_import_completed_event
-      publish_event('import.completed')
-    end
-
     # Returns the headers of the csv file
     # @return [Array<String>]
     def csv_headers
@@ -332,53 +351,46 @@ module Spree
       @attachment_file_content ||= attachment.attached? ? attachment.blob.download&.force_encoding('UTF-8') : nil
     end
 
-    # Creates mappings from the schema fields
-    # TODO: get mappings from the previous import if it exists, so user won't have to map the same columns again
-    def create_mappings
-      schema_fields.each do |schema_field|
-        mapping = mappings.find_or_create_by!(schema_field: schema_field[:name])
-        mapping.try_to_auto_assign_file_column(csv_headers)
-        mapping.save!
-      end
-    end
-
-    # Creates rows asynchronously
-    # @return [void]
-    def create_rows_async
-      # The 2s delay lets the attachment settle before the job reads it; running
-      # inline there is nothing to wait for.
-      return Spree::Imports::CreateRowsJob.perform_now(id) if preferred_inline
-
-      Spree::Imports::CreateRowsJob.set(wait: 2.seconds).perform_later(id)
-    end
-
-    # Processes rows asynchronously
-    # @return [void]
-    def process_rows_async
-      return Spree::Imports::ProcessRowsJob.perform_now(id) if preferred_inline
-
-      Spree::Imports::ProcessRowsJob.perform_later(id)
-    end
-
-    # Returns the store for the import
-    # @return [Spree::Store]
-    def store
-      if owner.is_a?(Spree::Store)
-        owner
+    # Who ran this import — the seller when one did, otherwise the store.
+    #
+    # @deprecated Read `seller` and `store` — removed in 6.1. Kept because the
+    #   polymorphic `owner` shipped in 5.6 and the v3 serializer still emits
+    #   `owner_type`/`owner_id` from it.
+    # @return [Spree::Seller, Spree::Store]
+    def owner
+      seller || store
+    end
+
+    # @deprecated Assign `seller:` or `store:` — removed in 6.1.
+    def owner=(record)
+      Spree::Deprecation.warn('Spree::Import#owner= is deprecated and will be removed in Spree 6.1. Assign seller: or store: instead.')
+
+      case record
+      when Spree::Seller
+        self.seller = record
+        self.store = record.store
       else
-        owner.respond_to?(:store) ? owner.store : Spree::Store.default
+        self.seller = nil
+        self.store = record
       end
     end
 
-    # Returns the current ability for the import
+    # The ability the row processors scope-fetch through.
+    #
+    # Built against whoever ran the import, because that is where the importing
+    # user holds their roles: a marketplace seller's staff hold theirs on the
+    # `Spree::Seller`, never on the store, so an ability resolved against the
+    # store compiles no rules at all and every scope-fetch through it comes
+    # back empty.
+    #
     # @return [Spree::Ability]
     def current_ability
-      @current_ability ||= Spree.ability_class.new(user, { store: store })
+      @current_ability ||= Spree.ability_class.new(user, { store: store, resource: seller || store })
     end
 
     # Per-instance cache shared by row processors within a single processing job.
     # Group jobs funnel every row through the same Import instance, so lookups of
-    # shared records (tax/shipping categories, option types, metafield definitions)
+    # shared records (tax/shipping categories, option types, custom_field definitions)
     # resolve once per job instead of once per row.
     # @return [Hash]
     def row_lookup_cache
@@ -454,7 +466,7 @@ module Spree
 
       # eg. Spree::Imports::Orders => Spree::Order
       def model_class
-        return Spree.user_class if to_s == 'Spree::Imports::Customers'
+        return Spree.customer_class if to_s == 'Spree::Imports::Customers'
 
         klass = "Spree::#{to_s.demodulize.singularize}".safe_constantize
 
@@ -466,6 +478,30 @@ module Spree
 
     private
 
+    # Mirrors the machine's bang events: an illegal move raised.
+    def run_pipeline_workflow(workflow)
+      result = workflow.call(import: self)
+
+      if result.failure?
+        # ResultError#to_s unwraps an ActiveModel::Errors into its full
+        # messages; its `value` would inspect the object into the message.
+        errors.add(:base, result.error.to_s)
+        raise ActiveRecord::RecordInvalid, self
+      end
+
+      true
+    end
+
+    # A seller can only run imports for the marketplace they belong to. Without
+    # this a payload naming another store's seller would file the import under
+    # a store that seller has no standing in.
+    def ensure_seller_belongs_to_store
+      return if seller.blank? || store.blank?
+      return if seller.store_id == store_id
+
+      errors.add(:seller, :invalid)
+    end
+
     def ensure_whitelisted_type
       return if type.blank?
 
@@ -479,16 +515,18 @@ module Spree
       errors.add(:attachment, :content_type) unless attachment.content_type.in?(%w[text/csv])
     end
 
-    def model_class_supports_metafields?
+    def model_class_supports_custom_fields?
       return false unless model_class.present?
 
-      model_class.included_modules.include?(Spree::Metafields)
+      model_class.included_modules.include?(Spree::HasCustomFields)
     end
 
-    def metafield_definitions_for_model
+    def custom_field_definitions_for_model
       return [] unless model_class.present?
 
-      Spree::MetafieldDefinition.for_resource_type(model_class.name)
+      # `store` is assigned at before_validation, so the unsaved import the
+      # template CSV is built on has none yet.
+      (store || Spree::Current.store).custom_field_definitions.for_resource_type(model_class.name)
     end
   end
 end

data/app/models/spree/import_mapping.rb

@@ -10,7 +10,7 @@ module Spree
     #
     # Validations
     #
-    validates :import, :schema_field, presence: true
+    validates :schema_field, presence: true
     validates :schema_field, uniqueness: { scope: [:import_id] }
     validates :file_column, uniqueness: { scope: [:import_id] }, allow_blank: true
 

data/app/models/spree/import_row.rb

@@ -15,7 +15,7 @@ module Spree
     #
     # Validations
     #
-    validates :import, :data, presence: true
+    validates :data, presence: true
     validates :row_number, uniqueness: { scope: :import_id }, numericality: { only_integer: true, greater_than: 0 }, presence: true
 
     #
@@ -24,27 +24,13 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[status row_number]
 
     #
-    # State machine
+    # Status
     #
-    state_machine initial: :pending, attribute: :status do
-      event :start_processing do
-        transition to: :processing
-      end
-
-      event :fail do
-        transition to: :failed
-      end
-      after_transition to: :failed, do: :publish_import_row_failed_event
-      # NOTE: add_row_to_import_view and update_footer_in_import_view
-      # are now handled by Spree::Admin::ImportRowSubscriber
-
-      event :complete do
-        transition to: :completed
-      end
-      after_transition to: :completed, do: :publish_import_row_completed_event
-      # NOTE: add_row_to_import_view and update_footer_in_import_view
-      # are now handled by Spree::Admin::ImportRowSubscriber
-    end
+    # No state machine — a row's whole lifecycle already lives in +process!+,
+    # which is the only thing that moves it. The events publish from the write
+    # rather than a transition callback.
+    include Spree::HasStatus
+    has_status :pending, :processing, :completed, :failed, default: :pending
 
     # How long a row may sit in `processing` before we consider its owning worker dead
     # (OOM, SIGKILL, deploy without graceful drain — none of these trigger a Sidekiq
@@ -94,15 +80,40 @@ module Spree
       data_json[mapping.file_column]
     end
 
+    # @deprecated Write the status — removed in 6.1. A row's lifecycle belongs
+    #   to +process!+, which is the only thing that should move it.
+    def start_processing!
+      Spree::Deprecation.warn('Spree::ImportRow#start_processing! is deprecated and will be removed in Spree 6.1. Use #process! instead.')
+      update!(status: 'processing')
+    end
+
+    # @deprecated Write the status — removed in 6.1.
+    def complete!
+      Spree::Deprecation.warn('Spree::ImportRow#complete! is deprecated and will be removed in Spree 6.1. Use #process! instead.')
+      update!(status: 'completed')
+      publish_event('import_row.completed')
+      true
+    end
+
+    # @deprecated Write the status — removed in 6.1.
+    def fail!
+      Spree::Deprecation.warn('Spree::ImportRow#fail! is deprecated and will be removed in Spree 6.1. Use #process! instead.')
+      update!(status: 'failed')
+      publish_event('import_row.failed')
+      true
+    end
+
     def process!(mappings: nil, schema_fields: nil)
-      start_processing!
+      update!(status: 'processing')
       self.item = import.row_processor_class.new(self, mappings: mappings, schema_fields: schema_fields).process!
       self.validation_errors = nil # clear a stale error when a retried row succeeds
-      complete!
+      update!(status: 'completed')
+      publish_event('import_row.completed')
     rescue StandardError => e
       Rails.error.report(e, handled: true, context: { import_row_id: id }, source: 'spree.core')
       self.validation_errors = e.message
-      fail!
+      update!(status: 'failed')
+      publish_event('import_row.failed')
     end
 
     # Bulk processing mode for large imports.
@@ -117,12 +128,5 @@ module Spree
       update_columns(status: 'failed', validation_errors: e.message, updated_at: Time.current)
     end
 
-    def publish_import_row_completed_event
-      publish_event('import_row.completed')
-    end
-
-    def publish_import_row_failed_event
-      publish_event('import_row.failed')
-    end
   end
 end

data/app/models/spree/import_schemas/price_list_prices.rb

@@ -0,0 +1,13 @@
+module Spree
+  module ImportSchemas
+    class PriceListPrices < Spree::ImportSchema
+      FIELDS = [
+        { name: 'sku', label: 'SKU', required: true },
+        { name: 'currency', label: 'Currency' },
+        { name: 'min_quantity', label: 'Minimum quantity' },
+        { name: 'price', label: 'Price', required: true },
+        { name: 'compare_at_price', label: 'Compare at Price' }
+      ].freeze
+    end
+  end
+end

data/app/models/spree/import_schemas/products.rb

@@ -26,7 +26,14 @@ module Spree
         { name: 'inventory_count', label: 'Inventory Count' },
         { name: 'inventory_backorderable', label: 'Inventory Backorderable' },
         { name: 'tax_category', label: 'Tax Category' },
-        { name: 'shipping_category', label: 'Shipping Category' },
+        { name: 'product_type', label: 'Product Type' },
+        { name: 'hs_code', label: 'HS Code' },
+        { name: 'country_of_origin', label: 'Country of Origin' },
+        { name: 'customs_description', label: 'Customs Description' },
+        { name: 'carton', label: 'Carton' },
+        { name: 'units_per_carton', label: 'Units per Carton' },
+        { name: 'carton_weight', label: 'Carton Weight' },
+        { name: 'cartons_per_pallet', label: 'Cartons per Pallet' },
         { name: 'image1_src', label: 'Image 1 URL' },
         { name: 'image2_src', label: 'Image 2 URL' },
         { name: 'image3_src', label: 'Image 3 URL' },

data/app/models/spree/import_schemas/purchase_orders.rb

@@ -0,0 +1,19 @@
+module Spree
+  module ImportSchemas
+    # One row per line; rows sharing a reference become one draft order.
+    class PurchaseOrders < Spree::ImportSchema
+      FIELDS = [
+        { name: 'reference', label: 'Reference', required: true },
+        { name: 'supplier', label: 'Supplier', required: true },
+        { name: 'destination', label: 'Destination', required: true },
+        { name: 'sku', label: 'SKU', required: true },
+        { name: 'quantity', label: 'Quantity', required: true },
+        { name: 'unit_cost', label: 'Unit cost', required: true },
+        { name: 'currency', label: 'Currency' },
+        { name: 'expected_at', label: 'Expected on' },
+        { name: 'cancel_by', label: 'Cancel by' },
+        { name: 'notes', label: 'Notes' }
+      ].freeze
+    end
+  end
+end

data/app/models/spree/imports/price_list_prices.rb

@@ -0,0 +1,72 @@
+module Spree
+  module Imports
+    # Prices for one price list, one rung per row, merged into the list: a row
+    # writes or updates its rung, a blank price removes it, and rungs the file
+    # does not mention stay as they are (docs/plans/6.0-volume-pricing.md).
+    #
+    # The list is a preference rather than a column because it is the only
+    # import type with a parent, and the same serialized store already carries
+    # the other per-type settings.
+    class PriceListPrices < Spree::Import
+      preference :price_list_id, :string, default: nil
+
+      # On create only: the list can be deleted while rows are still being
+      # processed, and the import must still be able to finish (its rows fail
+      # with a message) and to be deleted afterwards.
+      validate :price_list_present, on: :create
+
+      def row_processor_class
+        Spree::Imports::RowProcessors::PriceListPrice
+      end
+
+      # Every rung of a variant is processed together, so the break cap is
+      # judged on the whole ladder the file carries for it.
+      def group_column
+        'sku'
+      end
+
+      def model_class
+        Spree::Price
+      end
+
+      def self.model_class
+        Spree::Price
+      end
+
+      # Price lists are gated by the products scope family, like their own
+      # endpoints (see Admin::PriceListsController).
+      def self.required_scope
+        :products
+      end
+
+      # The list being written. Read through the store, so a preference
+      # pointing at another store's list answers nil and the import is refused.
+      #
+      # @return [Spree::PriceList, nil]
+      def price_list
+        return if preferred_price_list_id.blank? || store.nil?
+
+        store.price_lists.find_by(id: preferred_price_list_id)
+      end
+
+      # @param list [Spree::PriceList, nil]
+      def price_list=(list)
+        self.preferred_price_list_id = list&.id&.to_s
+      end
+
+      # The list's public id without loading it — the serializer emits this
+      # on every poll, and the id was resolved through the store at create.
+      #
+      # @return [String, nil]
+      def price_list_prefixed_id
+        Spree::PriceList.prefixed_id_for(preferred_price_list_id) if preferred_price_list_id.present?
+      end
+
+      private
+
+      def price_list_present
+        errors.add(:price_list, :blank) if price_list.nil?
+      end
+    end
+  end
+end

data/app/models/spree/imports/purchase_orders.rb

@@ -0,0 +1,28 @@
+module Spree
+  module Imports
+    # Draft purchase orders from a supplier's line sheet. Rows sharing a
+    # `reference` are one order; every order this import creates is a draft,
+    # to be checked and placed from its own screen.
+    class PurchaseOrders < Spree::Import
+      def row_processor_class
+        Spree::Imports::RowProcessors::PurchaseOrder
+      end
+
+      def group_column
+        'reference'
+      end
+
+      def model_class
+        Spree::PurchaseOrder
+      end
+
+      def self.model_class
+        Spree::PurchaseOrder
+      end
+
+      def self.required_scope
+        :purchasing
+      end
+    end
+  end
+end