spree_core 5.1.8 → 5.2.0.rc1

data/app/models/spree/import.rb

@@ -0,0 +1,279 @@
+require 'csv'
+
+module Spree
+  class Import < Spree.base_class
+    include Spree::NumberIdentifier
+    include Spree::NumberAsParam
+
+    include Spree::Core::NumberGenerator.new(prefix: 'IM')
+
+    #
+    # Associations
+    #
+    belongs_to :owner, polymorphic: true # Store, Vendor, etc.
+    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
+    has_many :rows, class_name: 'Spree::ImportRow', dependent: :destroy_async, inverse_of: :import
+    alias import_rows rows
+
+    #
+    # Validations
+    #
+    validates :owner, :user, :type, presence: true
+    validates :attachment, presence: true, unless: -> { Rails.env.test? }
+    validate :ensure_whitelisted_type
+    validate :ensure_attachment_content_type
+
+    #
+    # Ransack configuration
+    #
+    self.whitelisted_ransackable_attributes = %w[number type]
+
+    #
+    # Attachments
+    #
+    has_one_attached :attachment, service: Spree.private_storage_service_name
+
+    #
+    # State machine
+    #
+    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: :send_import_completed_email
+      after_transition to: :completed, do: :update_loader_in_import_view
+
+      event :fail do
+        transition to: :failed
+      end
+    end
+
+    #
+    # Preferences
+    #
+    preference :delimiter, :string, default: ','
+
+    # Returns true if the import is in mapping state
+    # @return [Boolean]
+    def mapping?
+      status == 'mapping'
+    end
+
+    # Returns true if the import is processing or completed mapping
+    # @return [Boolean]
+    def processing?
+      ['processing', 'completed_mapping'].include?(status)
+    end
+
+    # Returns true if the import is complete
+    # @return [Boolean]
+    def complete?
+      status == 'completed'
+    end
+
+    # Returns the model class for the import
+    # @return [Class]
+    def model_class
+      if type == 'Spree::Imports::Customers'
+        Spree.user_class
+      else
+        "Spree::#{type.demodulize.singularize}".safe_constantize
+      end
+    end
+
+    # Returns the import schema for the import
+    # @return [Spree::ImportSchema]
+    def import_schema
+      "Spree::ImportSchemas::#{type.demodulize}".safe_constantize.new
+    end
+
+    # Returns the row processor class for the import
+    # @return [Class]
+    def row_processor_class
+      "Spree::ImportRowProcessors::#{type.demodulize.singularize}".safe_constantize
+    end
+
+    # Returns the fields for the import schema
+    # If model supports metafields, it will include the metafield 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|
+          {
+            name: definition.csv_header_name,
+            label: definition.name
+          }
+        end
+        base_fields + metafield_fields
+      else
+        base_fields
+      end
+    end
+
+    # Returns the file columns that are not mapped
+    # @return [Array<String>]
+    def unmapped_file_columns
+      csv_headers.reject { |header| mappings.mapped.exists?(file_column: header) }
+    end
+
+    # Returns the required fields for the import schema
+    # @return [Array<String>]
+    def required_fields
+      import_schema.required_fields
+    end
+
+    # Returns the mapped fields for the import schema
+    # @return [Array<String>]
+    def mapped_fields
+      @mapped_fields ||= mappings.mapped.where(schema_field: required_fields)
+    end
+
+    # Returns true if the mapping is done
+    # @return [Boolean]
+    def mapping_done?
+      mapped_fields.count == required_fields.count
+    end
+
+    # Returns the display name for the import
+    # @return [String]
+    def display_name
+      "#{Spree.t(type.demodulize.pluralize.downcase)} #{number}"
+    end
+
+    def send_import_completed_email
+      # Spree::ImportMailer.import_done(self).deliver_later
+    end
+
+    # Returns the headers of the csv file
+    # @return [Array<String>]
+    def csv_headers
+      return [] if attachment_file_content.blank?
+
+      @csv_headers ||= ::CSV.parse_line(
+        attachment_file_content,
+        col_sep: preferred_delimiter
+      )
+    end
+
+    # Returns the content of the attachment file
+    # @return [String]
+    def attachment_file_content
+      @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
+      Spree::Imports::CreateRowsJob.set(wait: 2.seconds).perform_later(id)
+    end
+
+    # Processes rows asynchronously
+    # @return [void]
+    def process_rows_async
+      Spree::Imports::ProcessRowsJob.perform_later(id)
+    end
+
+    # Returns the store for the import
+    # @return [Spree::Store]
+    def store
+      owner.is_a?(Spree::Store) ? owner : owner.respond_to?(:store) ? owner.store : Spree::Store.default
+    end
+
+    def update_loader_in_import_view
+      return unless defined?(broadcast_update_to)
+
+      broadcast_update_to "import_#{id}_loader", target: 'loader', partial: 'spree/admin/imports/loader', locals: { import: self }
+    end
+
+    # Returns the current ability for the import
+    # @return [Spree::Ability]
+    def current_ability
+      @current_ability ||= Spree::Dependencies.ability_class.constantize.new(user, { store: store })
+    end
+
+    class << self
+      # Returns the available types for the import
+      # @return [Array<Class>]
+      def available_types
+        Rails.application.config.spree.import_types
+      end
+
+      # Returns the available models for the import
+      # @return [Array<Class>]
+      def available_models
+        available_types.map(&:model_class)
+      end
+
+      # Returns the type for the model
+      # @return [Class]
+      def type_for_model(model)
+        available_types.find { |type| type.model_class.to_s == model.to_s }
+      end
+
+      # eg. Spree::Imports::Orders => Spree::Order
+      def model_class
+        klass = "Spree::#{to_s.demodulize.singularize}".safe_constantize
+
+        raise NameError, "Missing model class for #{to_s}" unless klass
+
+        klass
+      end
+    end
+
+    private
+
+    def ensure_whitelisted_type
+      return if type.blank?
+
+      allowed = self.class.available_types.map(&:to_s)
+      errors.add(:type, :inclusion) unless allowed.include?(type)
+    end
+
+    def ensure_attachment_content_type
+      return if attachment.blank?
+
+      errors.add(:attachment, :content_type) unless attachment.content_type.in?(%w[text/csv])
+    end
+
+    def model_class_supports_metafields?
+      return false unless model_class.present?
+
+      model_class.included_modules.include?(Spree::Metafields)
+    end
+
+    def metafield_definitions_for_model
+      return [] unless model_class.present?
+
+      Spree::MetafieldDefinition.for_resource_type(model_class.name)
+    end
+  end
+end

data/app/models/spree/import_mapping.rb

@@ -0,0 +1,46 @@
+module Spree
+  class ImportMapping < Spree.base_class
+    #
+    # Associations
+    #
+    belongs_to :import, class_name: 'Spree::Import', inverse_of: :mappings, required: true
+
+    #
+    # Validations
+    #
+    validates :import, :schema_field, presence: true
+    validates :schema_field, uniqueness: { scope: [:import_id] }
+    validates :file_column, uniqueness: { scope: [:import_id] }, allow_blank: true
+
+    #
+    # Scopes
+    #
+    scope :required, -> { where(schema_field: import.required_fields) }
+    scope :mapped, -> { where.not(file_column: [nil, '']) }
+
+    # Returns true if the mapping is required
+    # @return [Boolean]
+    def required?
+      import.required_fields.include?(schema_field)
+    end
+
+    # Returns true if the mapping has a file column
+    # @return [Boolean]
+    def mapped?
+      file_column.present?
+    end
+
+    def try_to_auto_assign_file_column(csv_headers)
+      self.file_column = csv_headers.find { |header| header.parameterize.underscore.downcase.strip == schema_field.parameterize.underscore.downcase.strip }
+    end
+
+    # Returns the label for the schema field
+    # @return [String]
+    def schema_field_label
+      @schema_field_label ||= begin
+        field = import.schema_fields.find { |field| field[:name] == schema_field }
+        field[:label] if field.present?
+      end
+    end
+  end
+end

data/app/models/spree/import_row.rb

@@ -0,0 +1,108 @@
+module Spree
+  class ImportRow < Spree.base_class
+    #
+    # Associations
+    #
+    belongs_to :import, class_name: 'Spree::Import', counter_cache: :rows_count
+    belongs_to :item, polymorphic: true, optional: true # eg. Spree::Variant, Spree::Order, etc.
+    delegate :store, to: :import
+
+    #
+    # Validations
+    #
+    validates :import, :data, presence: true
+    validates :row_number, uniqueness: { scope: :import_id }, numericality: { only_integer: true, greater_than: 0 }, presence: true
+
+    #
+    # State machine
+    #
+    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: :add_row_to_import_view
+      after_transition to: :failed, do: :update_footer_in_import_view
+
+      event :complete do
+        transition to: :completed
+      end
+
+      after_transition to: :completed, do: :add_row_to_import_view
+      after_transition to: :completed, do: :update_footer_in_import_view
+    end
+
+    #
+    # Scopes
+    #
+    scope :pending_and_failed, -> { where(status: %i[pending failed]) }
+    scope :completed, -> { where(status: :completed) }
+    scope :failed, -> { where(status: :failed) }
+    scope :processed, -> { where(status: %i[completed failed]) }
+
+    def data_json
+      @data_json ||= JSON.parse(data)
+    rescue JSON::ParserError
+      {}
+    end
+
+    def to_schema_hash
+      @to_schema_hash ||= begin
+        mappings = import.mappings.mapped
+        schema_fields = import.schema_fields
+
+        attributes = {}
+        schema_fields.each do |field|
+          attributes[field[:name]] = attribute_by_schema_field(field[:name], mappings)
+        end
+        attributes
+      end
+    end
+
+    def attribute_by_schema_field(schema_field, mappings = nil)
+      mappings ||= import.mappings.mapped
+
+      mapping = mappings.find { |m| m.schema_field == schema_field }
+      return unless mapping&.mapped?
+
+      data_json[mapping.file_column]
+    end
+
+    def process!
+      start_processing!
+      self.item = import.row_processor_class.new(self).process!
+      complete!
+    rescue StandardError => e
+      self.validation_errors = e.message
+      fail!
+    end
+
+    def add_row_to_import_view
+      return unless defined?(broadcast_append_to)
+
+      # we need to render this partial with store context to properly generate image URLs
+      with_store_context do
+        broadcast_append_to "import_#{import.id}_rows", target: 'rows', partial: 'spree/admin/imports/row', locals: { row: self, import: import }
+      end
+    end
+
+    def update_footer_in_import_view
+      return unless defined?(broadcast_replace_to)
+
+      broadcast_replace_to "import_#{import_id}_footer", target: 'footer', partial: 'spree/admin/imports/footer', locals: { import: import }
+    end
+
+    private
+
+    def with_store_context
+      Spree::Current.store = store
+      Rails.application.routes.default_url_options[:host] = store.url_or_custom_domain
+      yield
+    ensure
+      Spree::Current.reset if defined?(Spree::Current)
+    end
+  end
+end

data/app/models/spree/import_schema.rb

@@ -0,0 +1,25 @@
+module Spree
+  class ImportSchema
+    FIELDS = []
+
+    def fields
+      self.class::FIELDS
+    end
+
+    def label_for_field(field_name)
+      fields.find { |f| f[:name] == field_name }[:label]
+    end
+
+    def required_fields
+      self.class::FIELDS.select { |f| f[:required] }.map { |f| f[:name] }
+    end
+
+    def optional_fields
+      self.class::FIELDS.reject { |f| f[:required] }.map { |f| f[:name] }
+    end
+
+    def headers
+      self.class::FIELDS.map { |f| f[:name] }
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Spree
+  module ImportSchemas
+    class Products < Spree::ImportSchema
+      FIELDS = [
+        { name: 'slug', label: 'Slug', required: true },
+        { name: 'sku', label: 'SKU', required: true },
+        { name: 'name', label: 'Name', required: true },
+        { name: 'price', label: 'Price', required: true },
+        { name: 'status', label: 'Status' },
+        { name: 'description', label: 'Description' },
+        { name: 'meta_title', label: 'Meta Title' },
+        { name: 'meta_description', label: 'Meta Description' },
+        { name: 'meta_keywords', label: 'Meta Keywords' },
+        { name: 'tags', label: 'Tags' },
+        { name: 'compare_at_price', label: 'Compare at Price' },
+        { name: 'currency', label: 'Currency' },
+        { name: 'width', label: 'Width' },
+        { name: 'height', label: 'Height' },
+        { name: 'depth', label: 'Depth' },
+        { name: 'dimensions_unit', label: 'Dimensions Unit' },
+        { name: 'weight', label: 'Weight' },
+        { name: 'weight_unit', label: 'Weight Unit' },
+        { name: 'available_on', label: 'Available On' },
+        { name: 'discontinue_on', label: 'Discontinue On' },
+        { name: 'track_inventory', label: 'Track Inventory' },
+        { name: 'inventory_count', label: 'Inventory Count' },
+        { name: 'inventory_backorderable', label: 'Inventory Backorderable' },
+        { name: 'tax_category', label: 'Tax Category' },
+        { name: 'digital', label: 'Digital' },
+        { name: 'image1_src', label: 'Image 1 URL' },
+        { name: 'image2_src', label: 'Image 2 URL' },
+        { name: 'image3_src', label: 'Image 3 URL' },
+        { name: 'option1_name', label: 'Option 1 Name' },
+        { name: 'option1_value', label: 'Option 1 Value' },
+        { name: 'option2_name', label: 'Option 2 Name' },
+        { name: 'option2_value', label: 'Option 2 Value' },
+        { name: 'option3_name', label: 'Option 3 Name' },
+        { name: 'option3_value', label: 'Option 3 Value' },
+        { name: 'category1', label: 'Category 1' },
+        { name: 'category2', label: 'Category 2' },
+        { name: 'category3', label: 'Category 3' }
+      ].freeze
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Spree
+  module Imports
+    class Products < Spree::Import
+      def row_processor_class
+        Spree::Imports::RowProcessors::ProductVariant
+      end
+    end
+  end
+end

data/app/models/spree/invitation.rb

@@ -15,7 +15,7 @@ module Spree
     belongs_to :inviter, polymorphic: true # User or AdminUser
     belongs_to :invitee, polymorphic: true, optional: true # User or AdminUser
     belongs_to :role, class_name: 'Spree::Role'
-    has_one :role_user, dependent: :destroy, class_name: 'Spree::RoleUser'
+    has_one :role_user, dependent: :nullify, class_name: 'Spree::RoleUser', inverse_of: :invitation
 
     #
     # Validations

data/app/models/spree/legacy_user.rb

@@ -4,7 +4,6 @@ module Spree
     include Spree::UserAddress
     include Spree::UserPaymentSource
     include Spree::UserMethods
-    include Spree::Metadata
 
     self.table_name = 'spree_users'
 

data/app/models/spree/line_item.rb

@@ -1,5 +1,6 @@
 module Spree
   class LineItem < Spree.base_class
+    include Spree::Metafields
     include Spree::Metadata
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks
@@ -18,7 +19,7 @@ module Spree
     has_one :product, -> { with_deleted }, class_name: 'Spree::Product', through: :variant
 
     has_many :adjustments, as: :adjustable, dependent: :destroy
-    has_many :inventory_units, inverse_of: :line_item
+    has_many :inventory_units, class_name: 'Spree::InventoryUnit', inverse_of: :line_item, dependent: :destroy
     has_many :shipments, through: :inventory_units, source: :shipment
     has_many :digital_links, dependent: :destroy
 
@@ -41,8 +42,6 @@ module Spree
 
     before_destroy :verify_order_inventory_before_destroy, if: -> { order.has_checkout_step?('delivery') }
 
-    before_destroy :destroy_inventory_units
-
     after_save :update_inventory
     after_save :update_adjustments
 
@@ -226,10 +225,6 @@ module Spree
       Spree::OrderInventory.new(order, self).verify(target_shipment)
     end
 
-    def destroy_inventory_units
-      throw(:abort) unless inventory_units.destroy_all
-    end
-
     def update_adjustments
       if saved_change_to_quantity?
         recalculate_adjustments

data/app/models/spree/metafield.rb

@@ -0,0 +1,53 @@
+module Spree
+  class Metafield < Spree.base_class
+    #
+    # Associations
+    #
+    belongs_to :resource, polymorphic: true, touch: true
+    belongs_to :metafield_definition, class_name: 'Spree::MetafieldDefinition'
+
+    #
+    # Delegations
+    #
+    delegate :key, :full_key, :name, :display_on, to: :metafield_definition, allow_nil: true
+
+    #
+    # Callbacks
+    #
+    before_validation :set_type_from_metafield_definition, on: :create
+
+    #
+    # Validations
+    #
+    validates :metafield_definition, :type, :resource, :value, presence: true
+    validates :metafield_definition_id, uniqueness: { scope: [:resource_type, :resource_id] }
+    validate :type_must_match_metafield_definition
+
+    #
+    # Scopes
+    #
+    scope :available_on_front_end, -> { joins(:metafield_definition).merge(Spree::MetafieldDefinition.available_on_front_end) }
+    scope :available_on_back_end, -> { joins(:metafield_definition).merge(Spree::MetafieldDefinition.available_on_back_end) }
+    scope :with_key, ->(namespace, key) { joins(:metafield_definition).where(spree_metafield_definitions: { namespace: namespace, key: key }) }
+
+    def serialize_value
+      value
+    end
+
+    def csv_value
+      value.to_s
+    end
+
+    private
+
+    def set_type_from_metafield_definition
+      self.type ||= metafield_definition.metafield_type
+    end
+
+    def type_must_match_metafield_definition
+      return if metafield_definition.blank?
+
+      errors.add(:type, 'must match metafield definition') unless type == metafield_definition.metafield_type
+    end
+  end
+end