spree_core 5.1.0.beta3 → 5.1.0.rc1

data/app/models/spree/product.rb

@@ -20,14 +20,17 @@
 
 module Spree
   class Product < Spree.base_class
-    extend FriendlyId
+    acts_as_paranoid
+    acts_as_taggable_on :tags, :labels
+    auto_strip_attributes :name
+
     include Spree::ProductScopes
     include Spree::MultiStoreResource
     include Spree::TranslatableResource
-    include Spree::TranslatableResourceSlug
     include Spree::MemoizedData
     include Spree::Metadata
     include Spree::Product::Webhooks
+    include Spree::Product::Slugs
     if defined?(Spree::VendorConcern)
       include Spree::VendorConcern
     end
@@ -50,39 +53,10 @@ module Spree
       if defined?(PgSearch)
         include PgSearch::Model
 
-        if connected? && connection.extension_enabled?('pg_trgm')
-          pg_search_scope :search_by_name, against: { name: 'A', meta_title: 'B' }, using: { trigram: { threshold: 0.3, word_similarity: true } }
-        else
-          pg_search_scope :search_by_name, against: { name: 'A', meta_title: 'B' }, using: { tsearch: { any_word: true, prefix: true } }
-        end
-      end
-
-      before_save :set_slug
-      acts_as_paranoid
-      # deleted translation values also need to be accessible for index views listing deleted resources
-      default_scope { unscope(where: :deleted_at) }
-      def set_slug
-        self.slug = generate_slug
-      end
-
-      private
-
-      def generate_slug
-        if name.blank? && slug.blank?
-          translated_model.name.to_url
-        elsif slug.blank?
-          name.to_url
-        else
-          slug.to_url
-        end
+        pg_search_scope :search_by_name, against: { name: 'A', meta_title: 'B' }, using: { trigram: { threshold: 0.3, word_similarity: true } }
       end
     end
 
-    friendly_id :slug_candidates, use: [:history, :scoped, :mobility], scope: spree_base_uniqueness_scope
-    acts_as_paranoid
-    auto_strip_attributes :name
-    acts_as_taggable_on :tags, :labels
-
     # we need to have this callback before any dependent: :destroy associations
     # https://github.com/rails/rails/issues/3458
     before_destroy :ensure_not_in_complete_orders
@@ -148,17 +122,12 @@ module Spree
     after_initialize :ensure_master
     after_initialize :assign_default_tax_category
 
-    before_validation :downcase_slug
-    before_validation :normalize_slug, on: :update
     before_validation :validate_master
     before_validation :ensure_default_shipping_category
 
     after_create :add_associations_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
 
-    after_destroy :punch_slug
-    after_restore :update_slug_history
-
     after_save :save_master
     after_save :run_touch_callbacks, if: :anything_changed?
     after_save :reset_nested_changes
@@ -176,7 +145,6 @@ module Spree
       validates :price, if: :requires_price?
     end
 
-    validates :slug, presence: true, uniqueness: { allow_blank: true, case_sensitive: true, scope: spree_base_uniqueness_scope }
     validate :discontinue_on_must_be_later_than_make_active_at, if: -> { make_active_at && discontinue_on }
 
     scope :for_store, ->(store) { joins(:store_products).where(StoreProduct.table_name => { store_id: store.id }) }
@@ -231,7 +199,7 @@ module Spree
         having("SUM(#{Spree::StockItem.table_name}.count_on_hand) <= 0")
     }
     scope :out_of_stock, lambda {
-                           joins(:stock_items).where("#{Spree::StockItem.table_name}.count_on_hand <= ? OR #{Spree::Variant.table_name}.track_inventory = ?", 0, false)
+                           joins(:stock_items).where("#{Spree::Variant.table_name}.track_inventory = ? OR #{Spree::StockItem.table_name}.count_on_hand <= ?", false, 0)
                          }
 
     scope :by_best_selling, lambda { |order_direction = :desc|
@@ -515,17 +483,6 @@ module Spree
       where conditions.inject(:or)
     end
 
-    def self.slug_available?(slug, id)
-      !where(slug: slug).where.not(id: id).exists?
-    end
-
-    def ensure_slug_is_unique(candidate_slug)
-      return slug if candidate_slug.blank? || slug.blank?
-      return candidate_slug if self.class.slug_available?(candidate_slug, id)
-
-      normalize_friendly_id([candidate_slug, uuid_for_friendly_id])
-    end
-
     # Suitable for displaying only variants that has at least one option value.
     # There may be scenarios where an option type is removed and along with it
     # all option values. At that point all variants associated with only those
@@ -741,25 +698,6 @@ module Spree
       self.tax_category = Spree::TaxCategory.default if new_record?
     end
 
-    def normalize_slug
-      self.slug = normalize_friendly_id(slug)
-    end
-
-    def punch_slug
-      # punch slug with date prefix to allow reuse of original
-      return if frozen?
-
-      update_column(:slug, "#{Time.current.to_i}_#{slug}"[0..254])
-
-      translations.with_deleted.each do |t|
-        t.update_column :slug, "#{Time.current.to_i}_#{t.slug}"[0..254]
-      end
-    end
-
-    def update_slug_history
-      save!
-    end
-
     def anything_changed?
       saved_changes? || @nested_changes
     end
@@ -815,14 +753,6 @@ module Spree
       end
     end
 
-    # Try building a slug based on the following fields in increasing order of specificity.
-    def slug_candidates
-      [
-        :name,
-        [:name, :sku]
-      ]
-    end
-
     def run_touch_callbacks
       run_callbacks(:touch)
     end
@@ -870,10 +800,6 @@ module Spree
       previously_new_record? || tag_list_previously_changed? || available_on_previously_changed?
     end
 
-    def downcase_slug
-      slug&.downcase!
-    end
-
     def after_activate
       # Implement your logic here
     end

data/app/models/spree/product_property.rb

@@ -31,9 +31,9 @@ module Spree
     default_scope { order(:position) }
 
     scope :filterable, -> { joins(:property).where(Property.table_name => { filterable: true }) }
-    scope :for_products, ->(products) { joins(:product).merge(products) }
+    scope :for_products, ->(products) { where(product_id: products) }
     scope :sort_by_property_position, -> {
-      unscope(:order).joins(:property).order("spree_properties.position ASC")
+      unscope(:order).joins(:property).order(Spree::Property.table_name => { position: :asc })
     }
 
     self.whitelisted_ransackable_attributes = ['value', 'filter_param']

data/app/models/spree/promotion_handler/coupon.rb

@@ -11,6 +11,27 @@ module Spree
       end
 
       def apply
+        if load_gift_card_code
+
+          if @gift_card.expired?
+            set_error_code :gift_card_expired
+            return self
+          elsif @gift_card.redeemed?
+            set_error_code :gift_card_already_redeemed
+            return self
+          end
+
+          result = order.apply_gift_card(@gift_card)
+
+          if result.success?
+            set_success_code(:gift_card_applied)
+          else
+            set_error_code(result.value, result.error.value || {})
+          end
+
+          return self
+        end
+
         if order.coupon_code.present?
           if promotion.present? && promotion.actions.exists?
             handle_present_promotion
@@ -26,6 +47,18 @@ module Spree
       end
 
       def remove(coupon_code)
+        if order.gift_card
+          result = order.remove_gift_card
+
+          if result.success?
+            set_success_code(:gift_card_removed)
+          else
+            set_error_code(result.value)
+          end
+
+          return self
+        end
+
         promotion = order.promotions.with_coupon_code(coupon_code)
         if promotion.present?
           # Order promotion has to be destroyed before line item removing
@@ -179,6 +212,12 @@ module Spree
       def handle_coupon_code(discount, coupon_code)
         discount.source.promotion.coupon_codes.unused.find_by(code: coupon_code)&.apply_order!(order)
       end
+
+      def load_gift_card_code
+        return unless order.coupon_code.present?
+
+        @gift_card = order.store.gift_cards.find_by(code: order.coupon_code.downcase)
+      end
     end
   end
 end

data/app/models/spree/property.rb

@@ -9,19 +9,13 @@ module Spree
       include Spree::Webhooks::HasWebhooks
     end
 
-    if Spree.always_use_translations?
-      TRANSLATABLE_FIELDS = %i[name presentation].freeze
-      translates(*TRANSLATABLE_FIELDS)
-    else
-      TRANSLATABLE_FIELDS = %i[presentation].freeze
-      translates(*TRANSLATABLE_FIELDS, column_fallback: true)
-    end
+    TRANSLATABLE_FIELDS = %i[presentation].freeze
+    translates(*TRANSLATABLE_FIELDS, column_fallback: !Spree.always_use_translations?)
 
     self::Translation.class_eval do
       auto_strip_attributes :presentation
     end
 
-    auto_strip_attributes :name, :presentation
     acts_as_list
 
     has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'

data/app/models/spree/reimbursement_type/reimbursement_helpers.rb

@@ -49,7 +49,7 @@ module Spree
         user: reimbursement.order.user,
         amount: unpaid_amount,
         category: category,
-        created_by: Spree::StoreCredit.default_created_by,
+        created_by: reimbursement.order.store.users.first,
         memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
         currency: reimbursement.order.currency,
         store: reimbursement.order.store

data/app/models/spree/return_item.rb

@@ -13,6 +13,10 @@ module Spree
       @_return_quantity = value.to_i
     end
 
+    def pre_tax_amount=(amount)
+      self[:pre_tax_amount] = Spree::LocalizedNumber.parse(amount)
+    end
+
     def return_quantity
       @_return_quantity.nil? ? inventory_unit.quantity : @_return_quantity
     end

data/app/models/spree/shipment.rb

@@ -221,10 +221,27 @@ module Spree
       inventory_units.where(line_item_id: line_item.id, variant_id: line_item.variant_id || variant.id)
     end
 
+    # Returns the cost of the shipment
+    #
+    # @return [BigDecimal]
     def item_cost
       manifest.map { |m| (m.line_item.price + (m.line_item.adjustment_total / m.line_item.quantity)) * m.quantity }.sum
     end
 
+    # Returns the weight of the shipment
+    #
+    # @return [BigDecimal]
+    def item_weight
+      manifest.map { |m| m.line_item.item_weight }.sum
+    end
+
+    # Returns the weight unit of the shipment
+    #
+    # @return [String]
+    def weight_unit
+      manifest.first.line_item.weight_unit
+    end
+
     def line_items
       inventory_units.includes(:line_item).map(&:line_item).uniq
     end
@@ -416,6 +433,8 @@ module Spree
     end
 
     def can_get_rates?
+      return true unless order.requires_ship_address?
+
       order.ship_address&.valid?
     end
 

data/app/models/spree/shipping_method.rb

@@ -39,22 +39,21 @@ module Spree
                       joins(:calculator).where(spree_calculators: { type: Spree::Calculator::Shipping::DigitalDelivery.to_s })
                     }
 
-    if defined?(PgSearch)
-      # full text search
-      include PgSearch::Model
-      pg_search_scope :search_by_name, against: %i[name]
-    else
-      scope :search_by_name, ->(query) { where('name LIKE ?', "%#{query}%") }
-    end
+    scope :search_by_name, ->(query) { where(arel_table[:name].lower.matches("%#{query}%")) }
 
     def include?(address)
+      return true unless requires_zone_check?
       return false unless address
 
-      zones.includes(zone_members: :zoneable).any? do |zone|
+      zones.includes(:zone_members).any? do |zone|
         zone.include?(address)
       end
     end
 
+    def requires_zone_check?
+      !calculator.is_a?(Spree::Calculator::Shipping::DigitalDelivery)
+    end
+
     def build_tracking_url(tracking)
       return if tracking.blank?
 
@@ -93,7 +92,7 @@ module Spree
       if estimated_transit_business_days_min == estimated_transit_business_days_max
         estimated_transit_business_days_min.to_s
       else
-        "#{estimated_transit_business_days_min}-#{estimated_transit_business_days_max}"
+        [estimated_transit_business_days_min, estimated_transit_business_days_max].compact.join("-")
       end
     end
 

data/app/models/spree/store.rb

@@ -109,6 +109,8 @@ module Spree
 
     has_many :integrations, class_name: 'Spree::Integration'
 
+    has_many :gift_cards, class_name: 'Spree::GiftCard', dependent: :destroy
+
     #
     # Page Builder associations
     #

data/app/models/spree/store_credit.rb

@@ -16,13 +16,12 @@ module Spree
     AUTHORIZE_ACTION  = 'authorize'.freeze
     ALLOCATION_ACTION = 'allocation'.freeze
 
-    DEFAULT_CREATED_BY_EMAIL = 'spree@example.com'.freeze
-
+    belongs_to :store, class_name: 'Spree::Store'
     belongs_to :user, class_name: "::#{Spree.user_class}", foreign_key: 'user_id'
     belongs_to :category, class_name: 'Spree::StoreCreditCategory', optional: true
     belongs_to :created_by, class_name: "::#{Spree.admin_user_class}", foreign_key: 'created_by_id', optional: true
     belongs_to :credit_type, class_name: 'Spree::StoreCreditType', foreign_key: 'type_id', optional: true
-    belongs_to :store, class_name: 'Spree::Store'
+    belongs_to :originator, polymorphic: true, optional: true
 
     has_many :store_credit_events, class_name: 'Spree::StoreCreditEvent'
     has_many :payments, as: :source, class_name: 'Spree::Payment'
@@ -34,14 +33,16 @@ module Spree
     validate :amount_used_less_than_or_equal_to_amount
     validate :amount_authorized_less_than_or_equal_to_amount
 
-    delegate :name, to: :category, prefix: true
-    delegate :email, to: :created_by, prefix: true
+    delegate :name, to: :category, prefix: true, allow_nil: true
+    delegate :email, to: :created_by, prefix: true, allow_nil: true
 
     scope :order_by_priority, -> { includes(:credit_type).order('spree_store_credit_types.priority ASC') }
 
     scope :not_authorized, -> { where(amount_authorized: 0) }
     scope :not_used, -> { where("#{Spree::StoreCredit.table_name}.amount_used < #{Spree::StoreCredit.table_name}.amount") }
     scope :available, -> { not_authorized.not_used }
+    scope :with_gift_card, -> { where(originator_type: 'Spree::GiftCard') }
+    scope :without_gift_card, -> { where(originator_type: [nil, '']).or(where.not(originator_type: 'Spree::GiftCard')) }
 
     after_save :store_event
     before_destroy :validate_no_amount_used
@@ -184,7 +185,9 @@ module Spree
 
     class << self
       def default_created_by
-        Spree.user_class.find_by(email: DEFAULT_CREATED_BY_EMAIL)
+        Spree::Deprecation.warn('StoreCredit#default_created_by is deprecated and will be removed in Spree 6.0. Please use store.users.first instead.')
+
+        Spree::Store.current.users.first
       end
     end
 

data/app/models/spree/store_credit_event.rb

@@ -2,9 +2,15 @@ module Spree
   class StoreCreditEvent < Spree.base_class
     acts_as_paranoid
 
+    #
+    # Associations
     belongs_to :store_credit
     belongs_to :originator, polymorphic: true
+    has_one :payment, -> { where(source_type: Spree::StoreCredit.to_s) }, foreign_key: :response_code, primary_key: :authorization_code
+    has_one :order, through: :payment
 
+    #
+    # Scopes
     scope :exposed_events, -> { where.not(action: [Spree::StoreCredit::ELIGIBLE_ACTION, Spree::StoreCredit::AUTHORIZE_ACTION]) }
     scope :reverse_chronological, -> { order(created_at: :desc) }
 
@@ -21,15 +27,13 @@ module Spree
         Spree.t('store_credit.authorized')
       when Spree::StoreCredit::ALLOCATION_ACTION
         Spree.t('store_credit.allocated')
+      when Spree::StoreCredit::ELIGIBLE_ACTION
+        Spree.t('store_credit.eligible')
       when Spree::StoreCredit::VOID_ACTION, Spree::StoreCredit::CREDIT_ACTION
         Spree.t('store_credit.credit')
       end
     end
 
-    def order
-      store.payments.find_by(response_code: authorization_code).try(:order)
-    end
-
     def allocation?
       action == Spree::StoreCredit::ALLOCATION_ACTION
     end

data/app/models/spree/taxon.rb

@@ -17,10 +17,13 @@ module Spree
     include Spree::TranslatableResource
     include Spree::TranslatableResourceSlug
     include Spree::Metadata
+    include Spree::MemoizedData
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks
     end
 
+    MEMOIZED_METHODS = %w[cached_self_and_descendants_ids].freeze
+
     #
     # Magic methods
     #
@@ -154,6 +157,10 @@ module Spree
       sort_order == 'manual'
     end
 
+    def page_builder_image
+      square_image.presence || image
+    end
+
     def active_products_with_descendants
       @active_products_with_descendants ||= store.products.
                                             joins(:classifications).
@@ -368,7 +375,7 @@ module Spree
     end
 
     def cached_self_and_descendants_ids
-      Rails.cache.fetch("#{cache_key_with_version}/descendant-ids") do
+      @cached_self_and_descendants_ids ||= Rails.cache.fetch("#{cache_key_with_version}/descendant-ids") do
         self_and_descendants.ids
       end
     end

data/app/models/spree/theme.rb

@@ -155,7 +155,7 @@ module Spree
       end
     end
 
-    # Returns an array of available layout section classes for the theme
+    # Returns an array of available layout section classes for the theme, eg. header, footer, newsletter, etc.
     #
     # @return [Array<Class>]
     def available_layout_sections

data/app/models/spree/variant.rb

@@ -82,7 +82,7 @@ module Spree
 
     after_touch :clear_in_stock_cache
 
-    scope :in_stock, -> { left_joins(:stock_items).where("#{Spree::StockItem.table_name}.count_on_hand > ? OR #{Spree::Variant.table_name}.track_inventory = ?", 0, false) }
+    scope :in_stock, -> { left_joins(:stock_items).where("#{Spree::Variant.table_name}.track_inventory = ? OR #{Spree::StockItem.table_name}.count_on_hand > ?", false, 0) }
     scope :backorderable, -> { left_joins(:stock_items).where(spree_stock_items: { backorderable: true }) }
     scope :in_stock_or_backorderable, -> { in_stock.or(backorderable) }
 

data/app/models/spree/wishlist.rb

@@ -36,6 +36,13 @@ module Spree
       @wished_items_count ||= variant_ids.count
     end
 
+    # returns the variant ids in the wishlist
+    #
+    # @return [Array<Integer>]
+    def variant_ids
+      @variant_ids ||= wished_items.pluck(:variant_id)
+    end
+
     def self.get_by_param(param)
       find_by(token: param)
     end

data/app/presenters/spree/csv/product_variant_presenter.rb

@@ -1,6 +1,8 @@
 module Spree
   module CSV
     class ProductVariantPresenter
+      include Spree::ImagesHelper
+
       CSV_HEADERS = [
         'product_id',
         'sku',
@@ -99,9 +101,9 @@ module Spree
           variant.backorderable?,
           variant.tax_category&.name,
           variant.digital?,
-          variant.images[0]&.original_url,
-          variant.images[1]&.original_url,
-          variant.images[2]&.original_url,
+          spree_image_url(variant.images[0], image_url_options),
+          spree_image_url(variant.images[1], image_url_options),
+          spree_image_url(variant.images[2], image_url_options),
           index.positive? ? option_type(0)&.presentation : nil,
           index.positive? ? option_value(option_type(0)) : nil,
           index.positive? ? option_type(1)&.presentation : nil,
@@ -125,6 +127,15 @@ module Spree
       def option_value(option_type)
         variant.option_values.find { |ov| ov.option_type == option_type }&.presentation
       end
+
+      private
+
+      def image_url_options
+        {
+          width: 1000,
+          height: 1000
+        }
+      end
     end
   end
 end

data/app/services/spree/addresses/phone_validator.rb

@@ -0,0 +1,20 @@
+# This validator can be overridden to implement custom phone validation logic.
+# Currently uses the phonelib gem to validate phone numbers and ensure they
+# belong to the address country.
+
+require 'phonelib'
+
+module Spree
+  module Addresses
+    class PhoneValidator < ActiveModel::Validator
+      def validate(address)
+        return if !Spree::Config[:address_requires_phone] || address.phone.blank? || address.country.blank? || address.country_iso.blank?
+
+        phone = Phonelib.parse(address.phone)
+        unless phone.valid_for_country?(address.country_iso)
+          address.errors.add(:phone, :invalid)
+        end
+      end
+    end
+  end
+end

data/app/services/spree/cart/destroy.rb

@@ -14,7 +14,7 @@ module Spree
       private
 
       def check_if_can_be_destroyed(order:)
-        return failure(false, Spree.t(:cannot_be_destroyed)) unless order&.can_be_destroyed?
+        return failure(false, Spree.t(:cannot_be_destroyed)) unless order&.can_be_deleted?
 
         success(order: order)
       end

data/app/services/spree/cart/recalculate.rb

@@ -4,6 +4,7 @@ module Spree
       prepend Spree::ServiceModule::Base
 
       def call(order:, line_item:, line_item_created: false, options: {})
+        order.remove_gift_card if order.gift_card.present?
         order_updater = ::Spree::OrderUpdater.new(order)
 
         order.payments.store_credits.checkout.destroy_all

data/app/services/spree/gift_cards/apply.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+# Applies a gift card to an order
+# under the hood it creates a store credit payment record and updates the gift card amount used
+# @param gift_card [Spree::GiftCard] the gift card to apply
+# @param order [Spree::Order] the order to apply the gift card to
+# @return [Spree::Order] the order with the gift card applied
+module Spree
+  module GiftCards
+    class Apply
+      prepend Spree::ServiceModule::Base
+
+      def call(gift_card:, order:)
+        # we shouldn't mix an order with a gift card and a store credit
+        return failure(:gift_card_using_store_credit_error) if order.using_store_credit?
+
+        # we shouldn't allow a gift card to be applied to an order with a different currency
+        return failure(:gift_card_mismatched_currency) if gift_card.currency != order.currency
+
+        amount = [gift_card.amount_remaining, order.total].min
+        store = order.store
+
+        return failure(:gift_card_no_amount_remaining) unless amount.positive? || order.total.zero?
+
+        payment_method = ensure_store_credit_payment_method!(store)
+
+        gift_card.lock!
+        order.with_lock do
+          store_credit = gift_card.store_credits.create!(
+            store: store,
+            user: order.user,
+            amount: amount,
+            currency: order.currency,
+            originator: gift_card,
+            action_originator: gift_card
+          )
+          gift_card.amount_used += amount
+          gift_card.save!
+
+          order.update!(gift_card: gift_card)
+          order.payments.create!(
+            source: store_credit,
+            payment_method: payment_method,
+            amount: amount,
+            state: 'checkout',
+            response_code: store_credit.generate_authorization_code
+          )
+        end
+
+        success(order.reload)
+      end
+
+      private
+
+      def ensure_store_credit_payment_method!(store)
+        payment_method = store.payment_methods.find_or_initialize_by(
+          type: 'Spree::PaymentMethod::StoreCredit'
+        )
+        payment_method.name ||= Spree.t(:store_credit_name)
+        payment_method.active = true
+        payment_method.save! if payment_method.new_record?
+
+        payment_method
+      end
+    end
+  end
+end

data/app/services/spree/gift_cards/redeem.rb

@@ -0,0 +1,17 @@
+module Spree
+  module GiftCards
+    class Redeem
+      prepend Spree::ServiceModule::Base
+
+      def call(gift_card:)
+        if gift_card.amount_remaining.zero?
+          gift_card.redeem!
+        else
+          gift_card.partial_redeem!
+        end
+
+        success(gift_card)
+      end
+    end
+  end
+end