spree_core 4.1.1 → 4.5.0

data/app/models/spree/product_property.rb

@@ -1,29 +1,45 @@
 module Spree
   class ProductProperty < Spree::Base
+    include Spree::FilterParam
+
+    auto_strip_attributes :value
+
     acts_as_list scope: :product
 
     with_options inverse_of: :product_properties do
       belongs_to :product, touch: true, class_name: 'Spree::Product'
-      belongs_to :property, class_name: 'Spree::Property'
+      belongs_to :property, touch: true, class_name: 'Spree::Property'
     end
 
     validates :property, presence: true
-
-    validates :value, db_maximum_length: true
+    validates :property_id, uniqueness: { scope: :product_id }
+    validates :value, presence: true
 
     default_scope { order(:position) }
 
-    self.whitelisted_ransackable_attributes = ['value']
+    scope :filterable, -> { joins(:property).where(Property.table_name => { filterable: true }) }
+    scope :for_products, ->(products) { joins(:product).merge(products) }
+
+    self.whitelisted_ransackable_attributes = ['value', 'filter_param']
     self.whitelisted_ransackable_associations = ['property']
 
     # virtual attributes for use with AJAX completion stuff
     delegate :name, :presentation, to: :property, prefix: true, allow_nil: true
 
     def property_name=(name)
+      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+        `ProductProperty#property_name=` is deprecated and will be removed in Spree 5.0.
+      DEPRECATION
       if name.present?
         # don't use `find_by :name` to workaround globalize/globalize#423 bug
         self.property = Property.where(name: name).first_or_create(presentation: name)
       end
     end
+
+    protected
+
+    def param_candidate
+      value
+    end
   end
 end

data/app/models/spree/promotion/actions/create_item_adjustments.rb

@@ -23,7 +23,7 @@ module Spree
           order   = line_item.order
 
           # Prevent negative order totals
-          amounts << order.amount - order.adjustments.sum(:amount).abs if order.adjustments.any?
+          amounts << order.amount - order.adjustments.eligible.sum(:amount).abs if order.adjustments.eligible.any?
 
           amounts.min * -1
         end

data/app/models/spree/promotion/rules/country.rb

@@ -11,7 +11,7 @@ module Spree
 
         def eligible?(order, options = {})
           country_id = options[:country_id] || order.ship_address.try(:country_id)
-          unless country_id.eql?(preferred_country_id || Spree::Country.default)
+          unless country_id.eql?(preferred_country_id || order.store.default_country_id)
             eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
           end
 

data/app/models/spree/promotion/rules/first_order.rb

@@ -2,7 +2,7 @@ module Spree
   class Promotion
     module Rules
       class FirstOrder < PromotionRule
-        attr_reader :user, :email
+        attr_reader :user, :email, :store
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
@@ -11,6 +11,7 @@ module Spree
         def eligible?(order, options = {})
           @user = order.try(:user) || options[:user]
           @email = order.email
+          @store = order.store
 
           if user || email
             if !completed_orders.blank? && completed_orders.first != order
@@ -26,11 +27,11 @@ module Spree
         private
 
         def completed_orders
-          user ? user.orders.complete : orders_by_email
+          user ? user.orders.for_store(store).complete : orders_by_email
         end
 
         def orders_by_email
-          Spree::Order.where(email: email).complete
+          store.orders.where(email: email).complete
         end
       end
     end

data/app/models/spree/promotion/rules/option_value.rb

@@ -4,9 +4,9 @@ module Spree
       module OptionValueWithNumerificationSupport
         def preferred_eligible_values
           values = super || {}
-          Hash[values.keys.map(&:to_i).zip(
+          Hash[values.keys.zip(
             values.values.map do |v|
-              (v.is_a?(Array) ? v : v.split(',')).map(&:to_i)
+              (v.is_a?(Array) ? v : v.split(','))
             end
           )]
         end
@@ -31,7 +31,7 @@ module Spree
         end
 
         def actionable?(line_item)
-          product_id = line_item.product.id
+          product_id = line_item.product_id
           option_values_ids = line_item.variant.option_value_ids
           eligible_product_ids = preferred_eligible_values.keys
           eligible_value_ids = preferred_eligible_values[product_id]

data/app/models/spree/promotion/rules/product.rb

@@ -1,6 +1,6 @@
 # A rule to limit a promotion based on products in the order.
 # Can require all or any of the products to be present.
-# Valid products either come from assigned product group or are assingned directly to the rule.
+# Valid products either come from assigned product group or are assigned directly to the rule.
 module Spree
   class Promotion
     module Rules
@@ -58,7 +58,8 @@ module Spree
         end
 
         def product_ids_string=(s)
-          self.product_ids = s.to_s.split(',').map(&:strip)
+          # check this
+          self.product_ids = s
         end
       end
     end

data/app/models/spree/promotion/rules/taxon.rb

@@ -30,7 +30,12 @@ module Spree
         end
 
         def actionable?(line_item)
-          taxon_product_ids.include? line_item.variant.product_id
+          store = line_item.order.store
+
+          store.products.
+            joins(:classifications).
+            where(Spree::Classification.table_name => { taxon_id: taxon_ids, product_id: line_item.product_id }).
+            exists?
         end
 
         def taxon_ids_string
@@ -39,14 +44,16 @@ module Spree
 
         def taxon_ids_string=(s)
           ids = s.to_s.split(',').map(&:strip)
-          self.taxons = Spree::Taxon.find(ids)
+          self.taxons = Spree::Taxon.for_stores(stores).find(ids)
         end
 
         private
 
         # All taxons in an order
         def order_taxons(order)
-          Spree::Taxon.joins(products: { variants_including_master: :line_items }).where(spree_line_items: { order_id: order.id }).distinct
+          taxon_ids = Spree::Classification.where(product_id: order.product_ids).pluck(:taxon_id).uniq
+
+          order.store.taxons.where(id: taxon_ids)
         end
 
         # ids of taxons rules and taxons rules children
@@ -62,10 +69,6 @@ module Spree
         def taxons_in_order_including_parents(order)
           order_taxons_in_taxons_and_children(order).inject([]) { |taxons, taxon| taxons << taxon.self_and_ancestors }.flatten.uniq
         end
-
-        def taxon_product_ids
-          Spree::Product.joins(:taxons).where(spree_taxons: { id: taxons.pluck(:id) }).pluck(:id).uniq
-        end
       end
     end
   end

data/app/models/spree/promotion/rules/user.rb

@@ -22,7 +22,8 @@ module Spree
         end
 
         def user_ids_string=(s)
-          self.user_ids = s.to_s.split(',').map(&:strip)
+          # check this
+          self.user_ids = s
         end
       end
     end

data/app/models/spree/promotion.rb

@@ -1,5 +1,14 @@
 module Spree
   class Promotion < Spree::Base
+    include MultiStoreResource
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+    if defined?(Spree::Security::Promotions)
+      include Spree::Security::Promotions
+    end
+
     MATCH_POLICIES = %w(all any)
     UNACTIVATABLE_ORDER_STATES = ['complete', 'awaiting_return', 'returned']
 
@@ -16,17 +25,19 @@ module Spree
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
     has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
 
+    has_many :store_promotions, class_name: 'Spree::StorePromotion'
+    has_many :stores, class_name: 'Spree::Store', through: :store_promotions
+
     accepts_nested_attributes_for :promotion_actions, :promotion_rules
 
     validates_associated :rules
 
     validates :name, presence: true
-    validates :path, :code, uniqueness: { case_sensitive: false, allow_blank: true }
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
     validates :description, length: { maximum: 255 }, allow_blank: true
     validate :expires_at_must_be_later_than_starts_at, if: -> { starts_at && expires_at }
 
-    before_save :normalize_blank_values
+    auto_strip_attributes :code, :path, :name
 
     scope :coupons, -> { where.not(code: nil) }
     scope :advertised, -> { where(advertise: true) }
@@ -42,7 +53,7 @@ module Spree
     def self.with_coupon_code(coupon_code)
       where("lower(#{table_name}.code) = ?", coupon_code.strip.downcase).
         includes(:promotion_actions).where.not(spree_promotion_actions: { id: nil }).
-        first
+        last
     end
 
     def self.active
@@ -192,21 +203,10 @@ module Spree
     end
 
     def used_by?(user, excluded_orders = [])
-      [
-        :adjustments,
-        :line_item_adjustments,
-        :shipment_adjustments
-      ].any? do |adjustment_type|
-        user.orders.complete.joins(adjustment_type).where(
-          spree_adjustments: {
-            source_type: 'Spree::PromotionAction',
-            source_id: actions.map(&:id),
-            eligible: true
-          }
-        ).where.not(
-          id: excluded_orders.map(&:id)
-        ).any?
-      end
+      user.orders.complete.joins(:promotions).joins(:all_adjustments).
+        where.not(spree_orders: { id: excluded_orders.map(&:id) }).
+        where(spree_promotions: { id: id }).
+        where(spree_adjustments: { source_type: 'Spree::PromotionAction', eligible: true }).any?
     end
 
     private
@@ -221,12 +221,6 @@ module Spree
       end
     end
 
-    def normalize_blank_values
-      [:code, :path].each do |column|
-        self[column] = nil if self[column].blank?
-      end
-    end
-
     def match_all?
       match_policy == 'all'
     end

data/app/models/spree/promotion_action.rb

@@ -8,7 +8,7 @@ module Spree
 
     scope :of_type, ->(t) { where(type: t) }
 
-    # This method should be overriden in subclass
+    # This method should be overridden in subclass
     # Updates the state of the order or performs some other action depending on the subclass
     # options will contain the payload from the event that activated the promotion. This will include
     # the key :user which allows user based actions to be performed in addition to actions on the order

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

@@ -13,12 +13,13 @@ module Spree
     # the promotions system accurate and performant. Here they can plug custom
     # handler to activate promos as they wish once an item is added to cart
     class Cart
-      attr_reader :line_item, :order
+      attr_reader :line_item, :order, :store
       attr_accessor :error, :success
 
       def initialize(order, line_item = nil)
         @order = order
         @line_item = line_item
+        @store = order.store
       end
 
       def activate
@@ -34,7 +35,11 @@ module Spree
       private
 
       def promotions
-        Promotion.find_by_sql("#{order.promotions.active.to_sql} UNION #{Promotion.active.where(code: nil, path: nil).to_sql}")
+        promotion_scope.find_by_sql("#{order.promotions.active.to_sql} UNION #{promotion_scope.active.where(code: nil, path: nil).to_sql}")
+      end
+
+      def promotion_scope
+        ::Spree::Promotion.for_store(store)
       end
     end
   end

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

@@ -1,18 +1,19 @@
 module Spree
   module PromotionHandler
     class Coupon
-      attr_reader :order
+      attr_reader :order, :store
       attr_accessor :error, :success, :status_code
 
       def initialize(order)
         @order = order
+        @store = order.store
       end
 
       def apply
         if order.coupon_code.present?
           if promotion.present? && promotion.actions.exists?
             handle_present_promotion
-          elsif Promotion.with_coupon_code(order.coupon_code).try(:expired?)
+          elsif store.promotions.with_coupon_code(order.coupon_code).try(:expired?)
             set_error_code :coupon_code_expired
           else
             set_error_code :coupon_code_not_found
@@ -25,10 +26,9 @@ module Spree
 
       def remove(coupon_code)
         promotion = order.promotions.with_coupon_code(coupon_code)
-
         if promotion.present?
           # Order promotion has to be destroyed before line item removing
-          order.order_promotions.find_by!(promotion_id: promotion.id).destroy
+          order.order_promotions.where(promotion_id: promotion.id).destroy_all
 
           remove_promotion_adjustments(promotion)
           remove_promotion_line_items(promotion)
@@ -52,7 +52,7 @@ module Spree
       end
 
       def promotion
-        @promotion ||= Promotion.active.includes(
+        @promotion ||= store.promotions.active.includes(
           :promotion_rules, :promotion_actions
         ).with_coupon_code(order.coupon_code)
       end
@@ -76,7 +76,7 @@ module Spree
           line_item = order.find_line_item_by_variant(item.variant)
           next if line_item.blank?
 
-          Spree::Dependencies.cart_remove_item_service(order: order, item: item.variant, quantity: item.quantity)
+          Spree::Dependencies.cart_remove_item_service.constantize.call(order: order, variant: item.variant, quantity: item.quantity)
         end
       end
 

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

@@ -2,12 +2,13 @@ module Spree
   module PromotionHandler
     # Used for activating promotions with shipping rules
     class FreeShipping
-      attr_reader :order, :order_promo_ids
+      attr_reader :order, :order_promo_ids, :store
       attr_accessor :error, :success
 
       def initialize(order)
         @order = order
-        @order_promo_ids = order.promotions.pluck(:id)
+        @store = order.store
+        @order_promo_ids = order.promotions.ids
       end
 
       def activate
@@ -21,10 +22,8 @@ module Spree
       private
 
       def promotions
-        Spree::Promotion.active.where(
-          id: Spree::Promotion::Actions::FreeShipping.pluck(:promotion_id),
-          path: nil
-        )
+        store.promotions.active.joins(:promotion_actions).
+          where(Spree::PromotionAction.table_name => { type: 'Spree::Promotion::Actions::FreeShipping' }, path: nil).distinct
       end
     end
   end

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

@@ -1,10 +1,11 @@
 module Spree
   module PromotionHandler
     class Page
-      attr_reader :order, :path
+      attr_reader :order, :path, :store
 
       def initialize(order, path)
         @order = order
+        @store = order.store
         @path = path.gsub(/\A\//, '')
       end
 
@@ -17,7 +18,7 @@ module Spree
       private
 
       def promotion
-        @promotion ||= Promotion.active.find_by(path: path)
+        @promotion ||= store.promotions.active.find_by(path: path)
       end
     end
   end

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

@@ -1,15 +1,17 @@
 module Spree
   module PromotionHandler
     class PromotionDuplicator
-      def initialize(promotion)
+      def initialize(promotion, random_string: nil)
         @promotion = promotion
+        @random_string = random_string || generate_random_string(4)
       end
 
       def duplicate
         @new_promotion = @promotion.dup
-        @new_promotion.path = "#{@promotion.path}_new"
+        @new_promotion.path = "#{@promotion.path}_#{@random_string}"
         @new_promotion.name = "New #{@promotion.name}"
-        @new_promotion.code = "#{@promotion.code}_new"
+        @new_promotion.code = "#{@promotion.code}_#{@random_string}"
+        @new_promotion.stores = @promotion.stores
 
         ActiveRecord::Base.transaction do
           @new_promotion.save
@@ -33,6 +35,11 @@ module Spree
         end
       end
 
+      def generate_random_string(number)
+        charset = Array('A'..'Z') + Array('a'..'z')
+        Array.new(number) { charset.sample }.join
+      end
+
       def copy_actions
         @promotion.promotion_actions.each do |action|
           new_action = action.dup

data/app/models/spree/promotion_rule.rb

@@ -3,6 +3,8 @@ module Spree
   class PromotionRule < Spree::Base
     belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
 
+    delegate :stores, to: :promotion
+
     scope :of_type, ->(t) { where(type: t) }
 
     validate :unique_per_promotion, on: :create
@@ -33,7 +35,7 @@ module Spree
 
     def unique_per_promotion
       if Spree::PromotionRule.exists?(promotion_id: promotion_id, type: self.class.name)
-        errors[:base] << 'Promotion already contains this rule type'
+        errors.add(:base, 'Promotion already contains this rule type')
       end
     end
 

data/app/models/spree/promotion_rule_user.rb

@@ -1,7 +1,7 @@
 module Spree
   class PromotionRuleUser < Spree::Base
     belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
-    belongs_to :user, class_name: Spree.user_class.to_s
+    belongs_to :user, class_name: "::#{Spree.user_class}"
 
     validates :user, :promotion_rule, presence: true
     validates :user_id, uniqueness: { scope: :promotion_rule_id }, allow_nil: true

data/app/models/spree/property.rb

@@ -1,5 +1,13 @@
 module Spree
   class Property < Spree::Base
+    include Spree::FilterParam
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
+    auto_strip_attributes :name, :presentation
+
     has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
     has_many :prototypes, through: :property_prototypes, class_name: 'Spree::Prototype'
 
@@ -9,15 +17,38 @@ module Spree
     validates :name, :presentation, presence: true
 
     scope :sorted, -> { order(:name) }
+    scope :filterable, -> { where(filterable: true) }
 
     after_touch :touch_all_products
+    after_save :ensure_product_properties_have_filter_params
 
-    self.whitelisted_ransackable_attributes = ['presentation']
+    self.whitelisted_ransackable_attributes = ['presentation', 'filterable']
+
+    def uniq_values(product_properties_scope: nil)
+      with_uniq_values_cache_key(product_properties_scope) do
+        properties = product_properties
+        properties = properties.where(id: product_properties_scope) if product_properties_scope.present?
+        properties.where.not(value: [nil, '']).pluck(:filter_param, :value).uniq
+      end
+    end
 
     private
 
     def touch_all_products
       products.update_all(updated_at: Time.current)
     end
+
+    def with_uniq_values_cache_key(product_properties_scope, &block)
+      return block.call if product_properties_scope.present?
+
+      uniq_values_cache_key = ['property-uniq-values', cache_key_with_version]
+      Rails.cache.fetch(uniq_values_cache_key) { block.call }
+    end
+
+    def ensure_product_properties_have_filter_params
+      return unless filterable?
+
+      product_properties.where(filter_param: [nil, '']).where.not(value: [nil, '']).find_each(&:save)
+    end
   end
 end

data/app/models/spree/prototype.rb

@@ -1,5 +1,10 @@
 module Spree
   class Prototype < Spree::Base
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+
     has_many :property_prototypes, class_name: 'Spree::PropertyPrototype'
     has_many :properties, through: :property_prototypes, class_name: 'Spree::Property'
 

data/app/models/spree/refund.rb

@@ -1,5 +1,13 @@
 module Spree
   class Refund < Spree::Base
+    include Metadata
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
+    if defined?(Spree::Security::Refunds)
+      include Spree::Security::Refunds
+    end
+
     with_options inverse_of: :refunds do
       belongs_to :payment
       belongs_to :reimbursement, optional: true
@@ -21,6 +29,8 @@ module Spree
 
     scope :non_reimbursement, -> { where(reimbursement_id: nil) }
 
+    attr_reader :response
+
     def money
       Spree::Money.new(amount, currency: payment.currency)
     end
@@ -61,14 +71,14 @@ module Spree
                  end
 
       unless response.success?
-        logger.error(Spree.t(:gateway_error) + "  #{response.to_yaml}")
+        Rails.logger.error(Spree.t(:gateway_error) + "  #{response.to_yaml}")
         text = response.params['message'] || response.params['response_reason_text'] || response.message
         raise Core::GatewayError, text
       end
 
       response
     rescue ActiveMerchant::ConnectionError => e
-      logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
+      Rails.logger.error(Spree.t(:gateway_error) + "  #{e.inspect}")
       raise Core::GatewayError, Spree.t(:unable_to_connect_to_gateway)
     end
 

data/app/models/spree/reimbursement.rb

@@ -1,6 +1,10 @@
 module Spree
   class Reimbursement < Spree::Base
     include Spree::Core::NumberGenerator.new(prefix: 'RI', length: 9)
+    include NumberIdentifier
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
 
     class IncompleteReimbursementError < StandardError; end
 
@@ -15,7 +19,6 @@ module Spree
       has_many :return_items
     end
 
-    validates :number, uniqueness: true
     validates :order, presence: true
     validate :validate_return_items_belong_to_same_order
 
@@ -60,6 +63,8 @@ module Spree
     class_attribute :reimbursement_failure_hooks
     self.reimbursement_failure_hooks = []
 
+    delegate :store, :currency, to: :order
+
     state_machine :reimbursement_status, initial: :pending do
       event :errored do
         transition to: :errored, from: :pending
@@ -137,7 +142,9 @@ module Spree
     end
 
     def send_reimbursement_email
-      Spree::ReimbursementMailer.reimbursement_email(id).deliver_later
+      # you can overwrite this method in your application / extension to send out the confirmation email
+      # or use `spree_emails` gem
+      # YourEmailVendor.deliver_reimbursement_email(id) # `id` = ID of the Reimbursement being sent, you can also pass the entire object using `self`
     end
 
     # If there are multiple different reimbursement types for a single

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

@@ -51,7 +51,8 @@ module Spree
         category: category,
         created_by: Spree::StoreCredit.default_created_by,
         memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
-        currency: reimbursement.order.currency
+        currency: reimbursement.order.currency,
+        store: reimbursement.order.store
       }
     end
 

data/app/models/spree/return_authorization.rb

@@ -1,6 +1,10 @@
 module Spree
   class ReturnAuthorization < Spree::Base
     include Spree::Core::NumberGenerator.new(prefix: 'RA', length: 9)
+    include NumberIdentifier
+    if defined?(Spree::Webhooks)
+      include Spree::Webhooks::HasWebhooks
+    end
 
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations
 
@@ -17,7 +21,6 @@ module Spree
 
     accepts_nested_attributes_for :return_items, allow_destroy: true
 
-    validates :number, uniqueness: true
     validates :order, :reason, :stock_location, presence: true
     validate :must_have_shipped_units, on: :create
 
@@ -38,13 +41,15 @@ module Spree
     money_methods :pre_tax_total
 
     self.whitelisted_ransackable_attributes = ['memo', 'number', 'state']
+    self.whitelisted_ransackable_associations = ['order']
 
     def pre_tax_total
       return_items.sum(:pre_tax_amount)
     end
 
     def currency
-      order.nil? ? Spree::Config[:currency] : order.currency
+      # FIXME: we should associate ReturnAuthorization with Store
+      order.nil? ? Spree::Store.default.default_currency : order.currency
     end
 
     def refundable_amount