spree_core 4.2.7 → 4.3.0.rc1

data/app/models/spree/order.rb

@@ -2,6 +2,7 @@ require_dependency 'spree/order/checkout'
 require_dependency 'spree/order/currency_updater'
 require_dependency 'spree/order/payments'
 require_dependency 'spree/order/store_credit'
+require_dependency 'spree/order/emails'
 
 module Spree
   class Order < Spree::Base
@@ -13,10 +14,15 @@ module Spree
     include Spree::Order::Payments
     include Spree::Order::StoreCredit
     include Spree::Order::AddressBook
+    include Spree::Order::Emails
     include Spree::Core::NumberGenerator.new(prefix: 'R')
     include Spree::Core::TokenGenerator
 
     include NumberAsParam
+    include SingleStoreResource
+    include MemoizedData
+
+    MEMOIZED_METHODS = %w(tax_zone)
 
     extend Spree::DisplayMoney
     money_methods :outstanding_balance, :item_total,           :adjustment_total,
@@ -93,6 +99,7 @@ module Spree
     has_many :reimbursements, inverse_of: :order, class_name: 'Spree::Reimbursement'
     has_many :line_item_adjustments, through: :line_items, source: :adjustments
     has_many :inventory_units, inverse_of: :order, class_name: 'Spree::InventoryUnit'
+    has_many :return_items, through: :inventory_units, class_name: 'Spree::ReturnItem'
     has_many :variants, through: :line_items
     has_many :products, through: :variants
     has_many :refunds, through: :payments
@@ -121,6 +128,8 @@ module Spree
     # Needs to happen before save_permalink is called
     before_validation :ensure_store_presence
     before_validation :ensure_currency_presence
+    before_validation :uppercase_number
+
     before_validation :clone_billing_address, if: :use_billing?
     attr_accessor :use_billing
 
@@ -129,7 +138,9 @@ module Spree
     before_update :homogenize_line_item_currencies, if: :currency_changed?
 
     with_options presence: true do
-      validates :number, length: { maximum: 32, allow_blank: true }, uniqueness: { allow_blank: true, case_sensitive: false }
+      # we want to have this case_sentive: true as changing it to false causes all SQL to use LOWER(slug)
+      # which is very costly and slow on large set of records
+      validates :number, length: { maximum: 32, allow_blank: true }, uniqueness: { allow_blank: true, case_sensitive: true }
       validates :email, length: { maximum: 254, allow_blank: true }, email: { allow_blank: true }, if: :require_email
       validates :item_count, numericality: { greater_than_or_equal_to: 0, less_than: 2**31, only_integer: true, allow_blank: true }
       validates :store
@@ -158,6 +169,8 @@ module Spree
     scope :complete, -> { where.not(completed_at: nil) }
     scope :incomplete, -> { where(completed_at: nil) }
     scope :not_canceled, -> { where.not(state: 'canceled') }
+    scope :with_deleted_bill_address, -> { joins(:bill_address).where.not(Address.table_name => { deleted_at: nil }) }
+    scope :with_deleted_ship_address, -> { joins(:ship_address).where.not(Address.table_name => { deleted_at: nil }) }
 
     # shows completed orders first, by their completed_at date, then uncompleted orders by their created_at
     scope :reverse_chronological, -> { order(Arel.sql('spree_orders.completed_at IS NULL'), completed_at: :desc, created_at: :desc) }
@@ -326,6 +339,10 @@ module Spree
       complete? || resumed? || awaiting_return? || returned?
     end
 
+    def uneditable?
+      complete? || canceled? || returned?
+    end
+
     def credit_cards
       credit_card_ids = payments.from_credit_card.pluck(:source_id).uniq
       CreditCard.where(id: credit_card_ids)
@@ -356,7 +373,6 @@ module Spree
       touch :completed_at
 
       deliver_order_confirmation_email unless confirmation_delivered?
-
       deliver_store_owner_order_notification_email if deliver_store_owner_order_notification_email?
 
       consider_risk
@@ -368,17 +384,16 @@ module Spree
       save!
     end
 
-    def deliver_order_confirmation_email
-      OrderMailer.confirm_email(id).deliver_later
-      update_column(:confirmation_delivered, true)
-    end
-
     # Helper methods for checkout steps
     def paid?
       payment_state == 'paid' || payment_state == 'credit_owed'
     end
 
     def available_payment_methods(store = nil)
+      if store.present?
+        ActiveSupport::Deprecation.warn('The `store` parameter is deprecated and will be removed in Spree 5. Order is already associated with Store')
+      end
+
       @available_payment_methods ||= collect_payment_methods(store)
     end
 
@@ -410,21 +425,15 @@ module Spree
     end
 
     def empty!
-      if completed?
-        raise Spree.t(:cannot_empty_completed_order)
-      else
-        line_items.destroy_all
-        updater.update_item_count
-        adjustments.destroy_all
-        shipments.destroy_all
-        state_changes.destroy_all
-        order_promotions.destroy_all
+      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
+        `Order#empty!` is deprecated and will be removed in Spree 5.0.
+        Please use `Spree::Cart::Empty.call(order: order)` instead.
+      DEPRECATION
 
-        update_totals
-        persist_totals
-        restart_checkout_flow
-        self
-      end
+      raise Spree.t(:cannot_empty_completed_order) if completed?
+
+      result = Spree::Dependencies.cart_empty_service.constantize.call(order: self)
+      result.value
     end
 
     def has_step?(step)
@@ -562,6 +571,10 @@ module Spree
       !approved?
     end
 
+    def can_be_destroyed?
+      !completed? && payments.completed.empty?
+    end
+
     def consider_risk
       considered_risky! if is_risky? && !approved?
     end
@@ -574,11 +587,6 @@ module Spree
       update_column(:considered_risky, false)
     end
 
-    def reload(options = nil)
-      remove_instance_variable(:@tax_zone) if defined?(@tax_zone)
-      super
-    end
-
     def tax_total
       included_tax_total + additional_tax_total
     end
@@ -617,12 +625,12 @@ module Spree
 
     def validate_payments_attributes(attributes)
       # Ensure the payment methods specified are allowed for this user
-      payment_methods = Spree::PaymentMethod.where(id: available_payment_methods.map(&:id))
+      payment_method_ids = available_payment_methods.map(&:id)
+
       attributes.each do |payment_attributes|
-        payment_method_id = payment_attributes[:payment_method_id]
+        payment_method_id = payment_attributes[:payment_method_id].to_i
 
-        # raise RecordNotFound unless it is an allowed payment method
-        payment_methods.find(payment_method_id) if payment_method_id
+        raise ActiveRecord::RecordNotFound unless payment_method_ids.include?(payment_method_id)
       end
     end
 
@@ -693,10 +701,6 @@ module Spree
       update_with_updater!
     end
 
-    def send_cancel_email
-      OrderMailer.cancel_email(id).deliver_later
-    end
-
     def after_resume
       shipments.each(&:resume!)
       consider_risk
@@ -715,23 +719,20 @@ module Spree
     end
 
     def collect_payment_methods(store = nil)
-      PaymentMethod.available_on_front_end.select { |pm| pm.available_for_order?(self) && pm.available_for_store?(store) }
+      if store.present?
+        ActiveSupport::Deprecation.warn('The `store` parameter is deprecated and will be removed in Spree 5. Order is already associated with Store')
+      end
+      store ||= self.store
+
+      store.payment_methods.available_on_front_end.select { |pm| pm.available_for_order?(self) }
     end
 
     def credit_card_nil_payment?(attributes)
       payments.store_credits.present? && attributes[:amount].to_f.zero?
     end
 
-    # Returns true if:
-    #   1. an email address is set for new order notifications AND
-    #   2. no notification for this order has been sent yet.
-    def deliver_store_owner_order_notification_email?
-      store.new_order_notifications_email.present? && !store_owner_notification_delivered?
-    end
-
-    def deliver_store_owner_order_notification_email
-      OrderMailer.store_owner_notification_email(id).deliver_later
-      update_column(:store_owner_notification_delivered, true)
+    def uppercase_number
+      number&.upcase!
     end
   end
 end

data/app/models/spree/payment.rb

@@ -112,6 +112,13 @@ module Spree
       end
     end
 
+    def source
+      return super if payment_method.nil?
+      return super unless payment_method.source_required?
+
+      payment_method.payment_source_class.unscoped { super }
+    end
+
     def money
       Spree::Money.new(amount, currency: currency)
     end

data/app/models/spree/payment_method.rb

@@ -3,6 +3,8 @@ module Spree
     acts_as_paranoid
     acts_as_list
 
+    include MultiStoreResource
+
     DISPLAY = [:both, :front_end, :back_end].freeze
 
     scope :active,                 -> { where(active: true).order(position: :asc) }
@@ -31,6 +33,8 @@ module Spree
     # e.g. CreditCard in the case of a the Gateway payment type
     # nil means the payment method doesn't require a source e.g. check
     def payment_source_class
+      return unless source_required?
+
       raise ::NotImplementedError, 'You must implement payment_source_class method for this gateway.'
     end
 

data/app/models/spree/preferences/preferable.rb

@@ -58,6 +58,11 @@ module Spree::Preferences::Preferable
     send self.class.preference_default_getter_method(name)
   end
 
+  def preference_deprecated(name)
+    has_preference! name
+    send(self.class.preference_deprecated_getter_method(name))
+  end
+
   def has_preference!(name)
     raise NoMethodError, "#{name} preference not defined" unless has_preference? name
   end
@@ -72,6 +77,13 @@ module Spree::Preferences::Preferable
     end
   end
 
+  def deprecated_preferences
+    defined_preferences.each_with_object([]) do |pref_name, array|
+      deprecated_message = preference_deprecated(pref_name)
+      array << { name: pref_name, message: deprecated_message } unless deprecated_message.nil?
+    end
+  end
+
   def default_preferences
     Hash[
       defined_preferences.map do |preference|

data/app/models/spree/preferences/preferable_class_methods.rb

@@ -2,9 +2,10 @@ module Spree::Preferences
   module PreferableClassMethods
     def preference(name, type, *args)
       options = args.extract_options!
-      options.assert_valid_keys(:default)
+      options.assert_valid_keys(:default, :deprecated)
       default = options[:default]
       default = -> { options[:default] } unless default.is_a?(Proc)
+      deprecated = options[:deprecated]
 
       # cache_key will be nil for new objects, then if we check if there
       # is a pending preference before going to default
@@ -29,6 +30,10 @@ module Spree::Preferences
       define_method preference_type_getter_method(name) do
         type
       end
+
+      define_method preference_deprecated_getter_method(name) do
+        deprecated
+      end
     end
 
     def preference_getter_method(name)
@@ -43,6 +48,10 @@ module Spree::Preferences
       "preferred_#{name}_default".to_sym
     end
 
+    def preference_deprecated_getter_method(name)
+      "preferred_#{name}_deprecated".to_sym
+    end
+
     def preference_type_getter_method(name)
       "preferred_#{name}_type".to_sym
     end

data/app/models/spree/product.rb

@@ -21,7 +21,13 @@
 module Spree
   class Product < Spree::Base
     extend FriendlyId
-    include Spree::ProductScopes
+    include ProductScopes
+    include MultiStoreResource
+    include MemoizedData
+
+    MEMOIZED_METHODS = %w(total_on_hand taxonomy_ids taxon_and_ancestors category
+                          default_variant_id tax_category default_variant
+                          purchasable? in_stock? backorderable?)
 
     friendly_id :slug_candidates, use: :history
 
@@ -36,6 +42,8 @@ module Spree
     has_many :product_properties, dependent: :destroy, inverse_of: :product
     has_many :properties, through: :product_properties
 
+    has_many :menu_items, as: :linked_resource
+
     has_many :classifications, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
 
@@ -77,6 +85,9 @@ module Spree
     has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
     has_many :variant_images_without_master, -> { order(:position) }, source: :images, through: :variants
 
+    has_many :store_products, class_name: 'Spree::StoreProduct'
+    has_many :stores, through: :store_products, class_name: 'Spree::Store'
+
     after_create :add_associations_from_prototype
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
 
@@ -90,10 +101,7 @@ module Spree
     after_save :reset_nested_changes
     after_touch :touch_taxons
 
-    # reset cache on save inside trasaction and transaction commit
-    after_save :reset_memoized_data
-    after_commit :reset_memoized_data
-
+    before_validation :downcase_slug
     before_validation :normalize_slug, on: :update
     before_validation :validate_master
 
@@ -107,7 +115,7 @@ module Spree
       validates :price, if: :requires_price?
     end
 
-    validates :slug, presence: true, uniqueness: { allow_blank: true, case_sensitive: false }
+    validates :slug, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
     validate :discontinue_on_must_be_later_than_available_on, if: -> { available_on && discontinue_on }
 
     attr_accessor :option_values_hash
@@ -122,7 +130,7 @@ module Spree
 
     [
       :sku, :price, :currency, :weight, :height, :width, :depth, :is_master,
-      :cost_currency, :price_in, :amount_in, :cost_price, :compare_at_price
+      :cost_currency, :price_in, :amount_in, :cost_price, :compare_at_price, :compare_at_amount_in
     ].each do |method_name|
       delegate method_name, :"#{method_name}=", to: :find_or_build_master
     end
@@ -132,13 +140,6 @@ module Spree
 
     alias master_images images
 
-    def reload
-      %w(total_on_hand taxonomy_ids taxon_and_ancestors category category default_variant_id tax_category default_variant).each do |v|
-        instance_variable_set(:"@#{v}", nil)
-      end
-      super
-    end
-
     # Cant use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
     def purchasable?
       variants_including_master.any?(&:purchasable?)
@@ -173,8 +174,8 @@ module Spree
     # @return [Spree::Variant]
     def default_variant
       @default_variant ||= Rails.cache.fetch(default_variant_cache_key) do
-        if Spree::Config[:track_inventory_levels] && variants.in_stock_or_backorderable.any?
-          variants.in_stock_or_backorderable.first
+        if Spree::Config[:track_inventory_levels] && available_variant = variants.detect(&:purchasable?)
+          available_variant
         else
           has_variants? ? variants.first : master
         end
@@ -322,6 +323,12 @@ module Spree
       @category ||= taxons.joins(:taxonomy).order(depth: :desc).find_by(spree_taxonomies: { name: Spree.t(:taxonomy_categories_name) })
     end
 
+    def taxons_for_store(store)
+      Rails.cache.fetch("#{cache_key_with_version}/taxons-per-store/#{store.id}") do
+        taxons.for_store(store)
+      end
+    end
+
     private
 
     def add_associations_from_prototype
@@ -481,12 +488,6 @@ module Spree
       end
     end
 
-    def reset_memoized_data
-      %w(total_on_hand taxonomy_ids taxon_and_ancestors category default_variant_id tax_category default_variant).each do |v|
-        instance_variable_set(:"@#{v}", nil)
-      end
-    end
-
     def requires_price?
       Spree::Config[:require_master_price]
     end
@@ -494,5 +495,9 @@ module Spree
     def requires_shipping_category?
       true
     end
+
+    def downcase_slug
+      slug&.downcase!
+    end
   end
 end

data/app/models/spree/product_property.rb

@@ -1,29 +1,44 @@
 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 }
 
     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/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/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.rb

@@ -1,5 +1,7 @@
 module Spree
   class Promotion < Spree::Base
+    include MultiStoreResource
+
     MATCH_POLICIES = %w(all any)
     UNACTIVATABLE_ORDER_STATES = ['complete', 'awaiting_return', 'returned']
 
@@ -16,19 +18,18 @@ module Spree
     has_many :order_promotions, class_name: 'Spree::OrderPromotion'
     has_many :orders, through: :order_promotions, class_name: 'Spree::Order'
 
+    has_and_belongs_to_many :stores, class_name: 'Spree::Store', join_table: 'spree_promotions_stores'
+
     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
-
-    before_validation :normalize_code
+    auto_strip_attributes :code, :path, :name
 
     scope :coupons, -> { where.not(code: nil) }
     scope :advertised, -> { where(advertise: true) }
@@ -44,7 +45,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
@@ -212,16 +213,6 @@ module Spree
       end
     end
 
-    def normalize_blank_values
-      [:code, :path].each do |column|
-        self[column] = nil if self[column].blank?
-      end
-    end
-
-    def normalize_code
-      self.code = code.strip if code.present?
-    end
-
     def match_all?
       match_policy == 'all'
     end

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
@@ -51,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
@@ -75,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.constantize.call(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