spree_core 4.10.1 → 5.0.0.rc1

data/app/services/spree/products/duplicator.rb

@@ -0,0 +1,121 @@
+module Spree
+  module Products
+    class Duplicator
+      prepend ::Spree::ServiceModule::Base
+
+      def call(product:, include_images: true)
+        new_product = duplicate_product(product, include_images)
+
+        # don't dup the actual variants, just the characterising types
+        new_product.option_types = product.option_types if product.has_variants?
+
+        # allow site to do some customization
+        new_product.send(:duplicate_extra, product) if new_product.respond_to?(:duplicate_extra)
+        new_product.save
+
+        new_product.product_properties = duplicate_properties(product.product_properties) if new_product.persisted?
+
+        new_product.persisted? ? success(new_product) : failure(new_product, duplicate_error_message(new_product))
+      end
+
+      protected
+
+      def duplicate_product(product, include_images)
+        product.dup.tap do |new_product|
+          new_product.translations.each do |t|
+            t.name = "COPY OF #{t.name}"
+            t.slug = nil
+          end
+
+          new_product.status = :draft
+          new_product.name = "COPY OF #{product.name}"
+          new_product.taxons = product.taxons
+          new_product.stores = product.stores
+          new_product.created_at = nil
+          new_product.deleted_at = nil
+          new_product.updated_at = nil
+          new_product.tag_list = product.tag_list
+          new_product.master = duplicate_master(product.master, include_images)
+          new_product.variants = product.variants.map { |variant| duplicate_variant(variant, include_images) }
+        end
+      end
+
+      def duplicate_master(master, include_images)
+        master.dup.tap do |new_master|
+          new_master.sku = sku_generator(master.sku)
+          new_master.deleted_at = nil
+          new_master.prices = duplicate_prices(master.prices)
+          new_master.stock_items = duplicate_stock_items(master.stock_items)
+
+          master.images.each { |image| duplicate_image(image, new_master) } if include_images
+        end
+      end
+
+      def duplicate_variant(variant, include_images)
+        new_variant = variant.dup
+        new_variant.sku = sku_generator(new_variant.sku)
+        new_variant.deleted_at = nil
+        new_variant.option_values = variant.option_values.map { |option_value| option_value }
+        new_variant.prices = duplicate_prices(variant.prices)
+        new_variant.stock_items = duplicate_stock_items(variant.stock_items)
+
+        variant.images.each { |image| duplicate_image(image, new_variant) } if include_images
+
+        new_variant
+      end
+
+      def duplicate_prices(prices)
+        prices.map do |price|
+          new_price = price.dup
+          new_price.created_at = nil
+          new_price.updated_at = nil
+          new_price
+        end
+      end
+
+      def duplicate_stock_items(stock_items)
+        stock_items.map do |stock_item|
+          new_stock_item = stock_item.dup
+          new_stock_item.count_on_hand = 0
+          new_stock_item
+        end
+      end
+
+      def duplicate_image(image, viewable)
+        new_image = image.dup
+        new_image.viewable = viewable
+        new_image.attachment.attach(image.attachment.blob)
+        new_image.save
+        new_image
+      end
+
+      def duplicate_properties(product_properties)
+        product_properties.map do |prop|
+          new_prop = prop.dup
+          new_prop.product = nil
+          new_prop.created_at = nil
+          new_prop.updated_at = nil
+          new_prop
+        end
+      end
+
+      def sku_generator(sku)
+        return '' if sku.blank?
+
+        "COPY OF #{Variant.unscoped.where('sku like ?', "%#{sku}").order(:created_at).last.sku}"
+      end
+
+      def duplicate_error_message(new_product)
+        errors = []
+        errors << new_product.errors.full_messages
+        errors << new_product.master.errors.full_messages
+
+        new_product.variants.each do |variant|
+          errors << variant.errors.full_messages
+        end
+
+        errors.flatten.to_sentence
+      end
+    end
+  end
+end

data/app/services/spree/products/prepare_nested_attributes.rb

@@ -0,0 +1,169 @@
+module Spree
+  module Products
+    class PrepareNestedAttributes
+      def initialize(product, store, params, ability)
+        @product = product
+        @store = store
+        @params = params
+        @ability = ability
+      end
+
+      def call
+        if params[:variants_attributes]
+          params[:variants_attributes].each do |key, variant_params|
+            existing_variant = variant_params[:id].presence && @product.variants.find_by(id: variant_params[:id])
+            variants_to_remove.delete(variant_params[:id]) if variant_params[:id].present?
+
+            if can_update_prices?
+              # If the variant price is nil then mark it for destruction
+              variant_params[:prices_attributes]&.each do |price_key, price_params|
+                variant_params[:prices_attributes][price_key]['_destroy'] = '1' if price_params[:amount].blank?
+              end
+            else
+              variant_params.delete(:prices_attributes)
+            end
+
+            variant_params[:option_value_variants_attributes] = update_option_value_variants(variant_params.delete(:options), existing_variant)
+
+            variant_params.delete(:stock_items_attributes) unless can_update_stock_items?
+
+            params[:variants_attributes].delete(key) if variant_params.blank?
+          end
+          params[:variants_attributes] = params[:variants_attributes].merge(removed_variants_attributes)
+
+          params[:product_option_types_attributes] = product_option_types_params.merge(removed_product_option_types_attributes)
+        elsif params[:master_attributes]
+          params[:master_attributes].delete(:stock_items_attributes) unless can_update_stock_items?
+
+          if can_update_prices?
+            # If the master price is nil then mark it for destruction
+            params.dig(:master_attributes, :prices_attributes)&.each do |price_key, price_params|
+              params[:master_attributes][:prices_attributes][price_key]['_destroy'] = '1' if price_params[:amount].blank?
+            end
+          else
+            params[:master_attributes].delete(:prices_attributes)
+          end
+        end
+
+        params.delete(:variants_attributes) if params[:variants_attributes].blank?
+
+        # mark resource properties to be removed
+        # when value is left blank
+        if params[:product_properties_attributes].present?
+          params[:product_properties_attributes].each do |key, product_property_params|
+            next unless product_property_params[:id].present?
+            next if product_property_params[:value].present?
+
+            # https://api.rubyonrails.org/v7.1.3.4/classes/ActiveRecord/NestedAttributes/ClassMethods.html
+            params[:product_properties_attributes][key]['_destroy'] = '1'
+          end
+        end
+
+        # ensure there is at least one store
+        params[:store_ids] = [store.id] if params[:store_ids].blank?
+
+        params
+      end
+
+      private
+
+      attr_reader :product, :store, :params, :ability
+
+      delegate :can?, :cannot?, to: :ability
+
+      def product_option_types_params
+        @product_option_types_params ||= {}
+      end
+
+      def product_option_types_to_remove
+        @product_option_types_to_remove ||= product.product_option_type_ids
+      end
+
+      def variants_to_remove
+        @variants_to_remove ||= product.variant_ids.map(&:to_s)
+      end
+
+      def can_update_prices?
+        @can_update_prices ||= product.new_record? || can?(:manage, Spree::Price.new(variant_id: product.default_variant.id))
+      end
+
+      def can_manage_option_types?
+        @can_manage_option_types ||= product.new_record? || can?(:manage_option_types, product)
+      end
+
+      def can_update_stock_items?
+        @can_update_stock_items ||= product.new_record? || can?(:manage, Spree::StockItem.new(variant_id: product.default_variant.id))
+      end
+
+      def can_remove_variants?
+        @can_remove_variants ||= product.persisted? && can?(:destroy, product.default_variant)
+      end
+
+      def removed_variants_attributes
+        return {} unless can_remove_variants?
+
+        attributes = {}
+        last_index = params[:variants_attributes].keys.map(&:to_i).max
+        variants_to_remove.each_with_index do |variant_id, index|
+          attributes[(index + last_index + 1).to_s] = { id: variant_id, _destroy: '1' }
+        end
+
+        attributes
+      end
+
+      def removed_product_option_types_attributes
+        return {} unless can_manage_option_types?
+
+        attributes = {}
+        last_index = product_option_types_params.keys.map(&:to_i).max
+        product_option_types_to_remove.each_with_index do |product_option_type_id, index|
+          attributes[(last_index + index + 1).to_s] = { id: product_option_type_id, _destroy: '1' }
+        end
+
+        attributes
+      end
+
+      def update_option_value_variants(option_value_params, existing_variant)
+        return {} unless option_value_params.present?
+        return {} unless can_manage_option_types?
+
+        option_value_variant_params = {}
+
+        option_value_params.each_with_index do |opt, index|
+          option_type = Spree::OptionType.where(name: opt[:name].parameterize).first_or_initialize do |o|
+            o.name = o.presentation = opt[:name]
+            o.save!
+          end
+          option_value = option_type.option_values.where(name: opt[:value].parameterize).first_or_initialize do |o|
+            o.name = o.presentation = opt[:value]
+            o.save!
+          end
+
+          existing_option_value_variant = existing_variant&.option_value_variants&.find { |ovv| ovv.option_value_id == option_value.id }
+
+          option_value_variant_params[index.to_s] = { id: existing_option_value_variant&.id, option_value_id: option_value.id }.compact_blank
+
+          next if product_option_types_params.find { |_i, v| v[:option_type_id] == option_type.id }
+
+          existing_product_option_type = @product.product_option_types.find { |pot| pot.option_type_id == option_type.id }
+
+          if existing_product_option_type
+            product_option_types_to_remove.delete(existing_product_option_type.id)
+            product_option_types_params[opt[:position]] = {
+              id: existing_product_option_type.id,
+              position: opt[:position],
+              option_type_id: option_type.id
+            }
+          else
+            product_option_types_params[opt[:position]] = {
+              option_type_id: option_type.id,
+              position: opt[:position]
+            }
+          end
+        end
+
+        option_value_variant_params
+      end
+    end
+  end
+end

data/app/services/spree/seeds/admin_user.rb

@@ -0,0 +1,22 @@
+module Spree
+  module Seeds
+    class AdminUser
+      prepend Spree::ServiceModule::Base
+
+      def call
+        if Spree.admin_user_class.present? && Spree.admin_user_class.count.zero?
+          user = Spree.admin_user_class.create!(
+            email: 'spree@example.com',
+            password: 'spree123',
+            password_confirmation: 'spree123',
+            first_name: 'Spree',
+            last_name: 'Admin'
+          )
+
+          user.spree_roles << Spree::Role.find_or_create_by(name: :admin)
+          user.save!
+        end
+      end
+    end
+  end
+end

data/app/services/spree/seeds/all.rb

@@ -21,6 +21,7 @@ module Spree
           # store & stock location
           Stores.call
           StockLocations.call
+          AdminUser.call
 
           # add store resources
           PaymentMethods.call

data/app/services/spree/seeds/stores.rb

@@ -7,22 +7,17 @@ module Spree
         default_store = Spree::Store.default
 
         if default_store.persisted?
-          default_store.update!(default_country: Spree::Country.first)
+          default_store.update!(default_country: Spree::Country.find_by(iso: 'US') || Spree::Country.first)
         else
           Spree::Store.new do |s|
-            s.name                         = 'Spree Demo Site'
-            s.code                         = 'spree'
-            s.url                          = Rails.application.routes.default_url_options[:host] || 'demo.spreecommerce.org'
+            s.name                         = 'Shop'
+            s.code                         = 'shop'
+            s.url                          = Rails.application.routes.default_url_options[:host] || 'localhost:3000'
             s.mail_from_address            = 'no-reply@example.com'
             s.customer_support_email       = 'support@example.com'
             s.default_currency             = 'USD'
-            s.default_country              = Spree::Country.first
+            s.default_country              = Spree::Country.find_by(iso: 'US') || Spree::Country.first
             s.default_locale               = I18n.locale
-            s.seo_title                    = 'Spree Commerce Demo Shop'
-            s.meta_description             = 'This is the new Spree UX DEMO | OVERVIEW: http://bit.ly/new-spree-ux | DOCS: http://bit.ly/spree-ux-customization-docs | CONTACT: https://spreecommerce.org/contact/'
-            s.facebook                     = 'spreecommerce'
-            s.twitter                      = 'spreecommerce'
-            s.instagram                    = 'spreecommerce'
           end.save!
         end
       end

data/app/services/spree/seeds/zones.rb

@@ -10,12 +10,14 @@ module Spree
         Spree::Zone.where(name: 'South America', description: 'South America', kind: 'country').first_or_create!
         middle_east = Spree::Zone.where(name: 'Middle East', description: 'Middle East', kind: 'country').first_or_create!
         asia = Spree::Zone.where(name: 'Asia', description: 'Asia', kind: 'country').first_or_create!
+        australia_and_oceania = Spree::Zone.where(name: 'Australia and Oceania', description: 'Australia and Oceania', kind: 'country').first_or_create!
 
         create_zone_members(eu_vat, %w(PL FI PT RO DE FR SK HU SI IE AT ES IT BE SE LV BG LT CY LU MT DK NL EE HR CZ GR))
         create_zone_members(north_america, %w(US CA))
         create_zone_members(middle_east, %w(BH CY EG IR IQ IL JO KW LB OM QA SA SY TR AE YE))
         create_zone_members(asia, %w(AF AM AZ BH BD BT BN KH CN CX CC GE HK IN ID IR IQ IL JP JO KZ KW KG LA LB MO MY MV MN MM NP
                                      KP OM PK PS PH QA SA SG KR LK SY TW TJ TH TR TM AE UZ VN YE))
+        create_zone_members(australia_and_oceania, %w(AU NZ))
         uk_vat.zone_members.where(zoneable: Spree::Country.find_by(iso: 'GB')).first_or_create!
       end
 

data/app/services/spree/tags/bulk_add.rb

@@ -0,0 +1,38 @@
+module Spree
+  module Tags
+    class BulkAdd
+      prepend Spree::ServiceModule::Base
+
+      # Adds the given tags to the given records.
+      #
+      # @param tag_names [Array<String>] eg. ['tag1', 'tag2']
+      # @param records [Array<Spree::Taggable>] eg. Spree::Product, Spree::User
+      # @param context [String] default: 'tags'
+      # @return [Spree::ServiceModule::Base::Result]
+      def call(tag_names: [], records: [], context: 'tags')
+        tags = tag_names.map do |tag_name|
+          ActsAsTaggableOn::Tag.find_or_create_by(name: tag_name.strip)
+        end
+
+        record_class = records.first.class
+
+        taggings_to_upsert = records.pluck(:id).map do |record_id|
+          tags.map do |tag|
+            {
+              taggable_id: record_id,
+              taggable_type: record_class.to_s,
+              context: context,
+              tag_id: tag.id
+            }
+          end
+        end.flatten.compact
+
+        return if taggings_to_upsert.empty?
+
+        ActsAsTaggableOn::Tagging.insert_all(taggings_to_upsert)
+
+        record_class.where(id: records.pluck(:id)).touch_all
+      end
+    end
+  end
+end

data/app/services/spree/tags/bulk_remove.rb

@@ -0,0 +1,24 @@
+module Spree
+  module Tags
+    class BulkRemove
+      prepend Spree::ServiceModule::Base
+
+      def call(tag_names: [], records: [], context: 'tags')
+        tag_ids = ActsAsTaggableOn::Tag.where(name: tag_names.map(&:strip)).pluck(:id)
+
+        return if tag_ids.empty?
+
+        record_class = records.first.class
+
+        ActsAsTaggableOn::Tagging.where(
+          taggable_id: records.pluck(:id),
+          taggable_type: record_class.to_s,
+          context: context,
+          tag_id: tag_ids
+        ).delete_all
+
+        record_class.where(id: records.pluck(:id)).touch_all
+      end
+    end
+  end
+end

data/app/services/spree/taxons/add_products.rb

@@ -0,0 +1,39 @@
+module Spree
+  module Taxons
+    class AddProducts
+      prepend Spree::ServiceModule::Base
+
+      # Creates classifications for the given taxons and products in bulk.
+      #
+      # @param taxons [Array<Spree::Taxon>]
+      # @param products [Array<Spree::Product>]
+      # @return [Spree::ServiceModule::Base::Result]
+      def call(taxons:, products:)
+        return if taxons.blank? || products.blank?
+
+        # build the params for the insert_all
+        classifications_params = taxons.pluck(:id).flat_map do |taxon_id|
+          position = Spree::Classification.where(taxon_id: taxon_id).count
+
+          products.pluck(:id).map do |product_id|
+            {
+              taxon_id: taxon_id,
+              product_id: product_id,
+              position: (position += 1),
+              created_at: Time.current,
+              updated_at: Time.current
+            }
+          end
+        end
+        # doing a quick insert_all here to avoid the overhead of instantiating
+        Spree::Classification.insert_all(classifications_params)
+
+        # clearing cache
+        Spree::Product.where(id: products.pluck(:id)).touch_all
+        Spree::Taxon.where(id: taxons.pluck(:id)).touch_all
+
+        success(true)
+      end
+    end
+  end
+end

data/app/services/spree/taxons/regenerate_products.rb

@@ -0,0 +1,53 @@
+module Spree
+  module Taxons
+    class RegenerateProducts
+      prepend ::Spree::ServiceModule::Base
+
+      def call(taxon:)
+        return if taxon.nil?
+        return if taxon.manual?
+
+        previous_products_ids = taxon.classifications.order(position: :asc).pluck(:product_id)
+
+        # https://api.rubyonrails.org/classes/ActiveRecord/Associations/CollectionProxy.html#method-i-delete_all
+        # we don't want to run destroy_all here to avoid callbacks
+        # default dependent value is nullify and that won't work for us
+        taxon.classifications.delete_all(:delete_all)
+
+        products_matching_rules = taxon.products_matching_rules
+        product_ids_to_insert = products_matching_rules.ids
+
+        previous_filtered_products_ids = previous_products_ids & product_ids_to_insert
+        max_products_position = previous_filtered_products_ids.size || 0
+
+        if product_ids_to_insert.any?
+          records_to_insert = product_ids_to_insert.map do |product_id|
+            position = previous_filtered_products_ids.index(product_id)
+            position = position.present? ? position + 1 : max_products_position += 1
+
+            classification_attributes(product_id, taxon, position)
+          end
+
+          Spree::Classification.insert_all(records_to_insert)
+
+          # expire product cache
+          Spree::Product.where(id: (previous_products_ids + product_ids_to_insert).uniq).touch_all
+        end
+
+        success(taxon)
+      end
+
+      private
+
+      def classification_attributes(product_id, taxon, position)
+        {
+          product_id: product_id,
+          taxon_id: taxon.id,
+          position: position,
+          created_at: Time.current,
+          updated_at: Time.current
+        }
+      end
+    end
+  end
+end

data/app/services/spree/taxons/remove_products.rb

@@ -0,0 +1,53 @@
+module Spree
+  module Taxons
+    class RemoveProducts
+      prepend Spree::ServiceModule::Base
+
+      # Removes the given products from the given taxons.
+      #
+      # @param taxons [Array<Spree::Taxon>]
+      # @param products [Array<Spree::Product>]
+      # @return [Spree::ServiceModule::Base::Result]
+      def call(taxons:, products:)
+        return if taxons.blank? || products.blank?
+
+        ApplicationRecord.transaction do
+          taxons.pluck(:id).each do |taxon_id|
+            Spree::Classification.where(taxon_id: taxon_id, product_id: products.pluck(:id)).delete_all
+          end
+
+          classifications_params = taxons.pluck(:id).flat_map do |taxon_id|
+            position = 0
+            existing_product_ids = Spree::Classification.where(taxon_id: taxon_id).pluck(:product_id)
+
+            existing_product_ids.map do |product_id|
+              {
+                taxon_id: taxon_id,
+                product_id: product_id,
+                position: (position += 1),
+                created_at: Time.current,
+                updated_at: Time.current
+              }
+            end
+          end
+
+          if classifications_params.any?
+            opts = {}
+            opts[:unique_by] = :index_spree_products_taxons_on_product_id_and_taxon_id unless ActiveRecord::Base.connection.adapter_name == 'Mysql2'
+
+            Spree::Classification.upsert_all(
+              classifications_params,
+              **opts
+            )
+          end
+        end
+
+        # clear cache
+        Spree::Product.where(id: products.pluck(:id)).touch_all
+        Spree::Taxon.where(id: taxons.pluck(:id)).touch_all
+
+        success(true)
+      end
+    end
+  end
+end

data/app/services/spree/taxons/touch_featured_sections.rb

@@ -0,0 +1,21 @@
+module Spree
+  module Taxons
+    class TouchFeaturedSections
+      prepend Spree::ServiceModule::Base
+
+      def call(taxon_ids:)
+        return if taxon_ids.empty?
+
+        featured_taxons = Spree::PageSections::FeaturedTaxon.published.by_taxon_id(taxon_ids)
+
+        return if featured_taxons.empty?
+
+        featured_taxons.touch_all
+        pages = Spree::Page.where(id: featured_taxons.where(pageable_type: 'Spree::Page').pluck(:pageable_id))
+        pages.touch_all
+        themes = Spree::Theme.where(id: pages.where(pageable_type: 'Spree::Theme').pluck(:pageable_id).uniq)
+        themes.touch_all
+      end
+    end
+  end
+end

data/app/services/spree/themes/duplicator.rb

@@ -0,0 +1,40 @@
+module Spree
+  module Themes
+    class Duplicator
+      def initialize(theme)
+        @theme = theme
+      end
+
+      def duplicate
+        duplicated_theme = @theme.dup
+        duplicated_theme.duplicating = true
+        duplicated_theme.default = false
+        duplicated_theme.ready = false
+        duplicated_theme.name = generate_new_name(@theme.name)
+        duplicated_theme.save!
+
+        # We need to duplicate files, pages and sections in the background
+        Spree::Themes::DuplicateComponentsJob.set(wait: 5.seconds).perform_later(@theme.id, duplicated_theme.id)
+
+        duplicated_theme
+      end
+
+      protected
+
+      def generate_new_name(name)
+        depth_of_name = name.count('#')
+        highest_number_for_each_depth = Spree::Theme.where('spree_themes.name LIKE ?', "%#{name}").
+                                        pluck(:name).
+                                        group_by { |theme_name| theme_name.count('#') }.
+                                        transform_values do |names|
+                                          # ['Copy #3 of Theme', 'Copy #2 of Theme', Copy #1 of Theme'] => '3'
+                                          names.map{ |n| n.split.select { |s| s.starts_with?('#') }.first&.delete('#') }.max
+                                        end
+
+        next_usable_number = highest_number_for_each_depth[depth_of_name + 1].to_i + 1
+
+        "Copy ##{next_usable_number} of #{name}"
+      end
+    end
+  end
+end

data/app/services/spree/variants/remove_line_items.rb

@@ -4,7 +4,7 @@ module Spree
       prepend Spree::ServiceModule::Base
 
       def call(variant:)
-        variant.line_items.joins(:order).where.not(spree_orders: { state: 'complete' }).find_each do |line_item|
+        variant.line_items.joins(:order).where(spree_orders: { state: Spree::Order::LINE_ITEM_REMOVABLE_STATES }).find_each do |line_item|
           Spree::Variants::RemoveLineItemJob.perform_later(line_item: line_item)
         end