spree_core 2.4.10 → 3.0.0.rc1

data/app/models/spree/address.rb

@@ -16,8 +16,6 @@ module Spree
     alias_attribute :first_name, :firstname
     alias_attribute :last_name, :lastname
 
-    self.whitelisted_ransackable_attributes = %w[firstname lastname]
-
     def self.build_default
       country = Spree::Country.find(Spree::Config[:default_country_id]) rescue Spree::Country.first
       new(country: country)

data/app/models/spree/adjustable/adjustments_updater.rb

@@ -0,0 +1,70 @@
+module Spree
+  module Adjustable
+    class AdjustmentsUpdater
+      def self.update(adjustable)
+        new(adjustable).update
+      end
+
+      def initialize(adjustable)
+        @adjustable = adjustable
+        adjustable.reload if shipment? && persisted?
+      end
+
+      def update
+        return unless persisted?
+        update_promo_adjustments
+        update_tax_adjustments
+        persist_totals
+      end
+
+      private
+
+      attr_reader :adjustable
+      delegate :adjustments, :persisted?, to: :adjustable
+
+      def update_promo_adjustments
+        promo_adjustments = adjustments.competing_promos.reload.map { |a| a.update!(adjustable) }
+        promos_total = promo_adjustments.compact.sum
+        choose_best_promo_adjustment unless promos_total == 0
+        @promo_total = best_promo_adjustment.try(:amount).to_f
+      end
+
+      def update_tax_adjustments
+        tax = (adjustable.try(:all_adjustments) || adjustable.adjustments).tax
+        @included_tax_total = tax.is_included.reload.map(&:update!).compact.sum
+        @additional_tax_total = tax.additional.reload.map(&:update!).compact.sum
+      end
+
+      def persist_totals
+        adjustable.update_columns(
+          promo_total: @promo_total,
+          included_tax_total: @included_tax_total,
+          additional_tax_total: @additional_tax_total,
+          adjustment_total: @promo_total + @additional_tax_total,
+          updated_at: Time.now
+        )
+      end
+
+      def shipment?
+        adjustable.is_a?(Shipment)
+      end
+
+      # Picks one (and only one) competing discount to be eligible for
+      # this order. This adjustment provides the most discount, and if
+      # two adjustments have the same amount, then it will pick the
+      # latest one.
+      def choose_best_promo_adjustment
+        if best_promo_adjustment
+          other_promotions = adjustments.competing_promos.where.not(id: best_promo_adjustment.id)
+          other_promotions.update_all(eligible: false)
+        end
+      end
+
+      def best_promo_adjustment
+        @best_promo_adjustment ||= begin
+          adjustments.competing_promos.eligible.reorder("amount ASC, created_at DESC, id DESC").first
+        end
+      end
+    end
+  end
+end

data/app/models/spree/adjustable/promotion_accumulator.rb

@@ -0,0 +1,75 @@
+module Spree
+  module Adjustable
+    class PromotionAccumulator
+      attr_reader :adjustments, :sources, :promotions
+
+      # Adds accumulator as an attribute of adjustable to
+      # avoid changing number of passed arguments to
+      # adjustment#update! and concequential methods
+      def self.add_to(adjustable)
+        class << adjustable
+          attr_accessor :promotion_accumulator
+        end
+
+        adjustable.promotion_accumulator = new(adjustable)
+      end
+
+      def initialize(adjustable)
+        @adjustable = adjustable
+        @adjustments, @sources, @promotions = [], [], []
+        all_adjustments.each { |a| add_adjustment(a) }
+      end
+
+      def add_adjustment(adjustment, opts = {})
+        return unless adjustment.promotion?
+        source = opts[:source] || adjustment.source
+        promotion = opts[:promotion] || source.promotion
+
+        add(adjustments, adjustment, adjustment.id)
+        add(sources, source, adjustment.source_id)
+        add(promotions, promotion, source.promotion_id)
+      end
+
+      def promotions_adjustments(promotion_id, adjustments = adjustments)
+        where(sources, promotion_id: promotion_id).map do |source|
+          where(adjustments, source_id: source.id)
+        end.flatten
+      end
+
+      def promo_total(*args)
+        promotions_adjustments(*args).map(&:amount).reduce(0, &:+)
+      end
+
+      def total_with_promotion(promotion_id)
+        amount + ship_total + promo_total(promotion_id)
+      end
+
+      def item_total_with_promotion(promotion_id)
+        amount + promo_total(promotion_id, item_adjustments)
+      end
+
+      private
+
+      attr_reader :adjustable
+      delegate :order, to: :adjustable
+      delegate :amount, :ship_total, to: :order
+
+      def all_adjustments
+        order.all_adjustments.promotion.includes(source: [:promotion]).where.
+          not("adjustable_id = ? AND adjustable_type = ?", adjustable.id, adjustable.class.to_s)
+      end
+
+      def add(array, object, id)
+        array << object if array.none? { |a| a.id == id }
+      end
+
+      def item_adjustments
+        adjustments.select { |a| a.adjustable_type != 'Spree::Shipment' }
+      end
+
+      def where(array, opts = {})
+        array.select { |a| opts.all? { |k, v| a.respond_to?(k) && a.send(k) == v } }
+      end
+    end
+  end
+end

data/app/models/spree/adjustment.rb

@@ -24,7 +24,7 @@ module Spree
   class Adjustment < Spree::Base
     belongs_to :adjustable, polymorphic: true, touch: true
     belongs_to :source, polymorphic: true
-    belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments
+    belongs_to :order, class_name: "Spree::Order"
 
     validates :adjustable, presence: true
     validates :order, presence: true
@@ -44,6 +44,10 @@ module Spree
     after_create :update_adjustable_adjustment_total
     after_destroy :update_adjustable_adjustment_total
 
+    class_attribute :competing_promos_source_types
+
+    self.competing_promos_source_types = ['Spree::PromotionAction']
+
     scope :open, -> { where(state: 'open') }
     scope :closed, -> { where(state: 'closed') }
     scope :tax, -> { where(source_type: 'Spree::TaxRate') }
@@ -62,6 +66,10 @@ module Spree
     scope :return_authorization, -> { where(source_type: "Spree::ReturnAuthorization") }
     scope :is_included, -> { where(included: true) }
     scope :additional, -> { where(included: false) }
+    scope :competing_promos, -> { where(source_type: competing_promos_source_types) }
+
+    extend DisplayMoney
+    money_methods :amount
 
     def closed?
       state == "closed"
@@ -71,36 +79,19 @@ module Spree
       adjustable ? adjustable.currency : Spree::Config[:currency]
     end
 
-    def display_amount
-      Spree::Money.new(amount, { currency: currency })
-    end
-
     def promotion?
-      source.class < Spree::PromotionAction
+      source_type == 'Spree::PromotionAction'
     end
 
-    # Recalculate amount given a target e.g. Order, Shipment, LineItem
-    #
     # Passing a target here would always be recommended as it would avoid
     # hitting the database again and would ensure you're compute values over
     # the specific object amount passed here.
-    #
-    # Noop if the adjustment is locked.
-    #
-    # If the adjustment has no source, do not attempt to re-calculate the amount.
-    # Chances are likely that this was a manually created adjustment in the admin backend.
-    def update!(target = nil)
-      return amount if closed?
-      if source.present?
-        amount = source.compute_amount(target || adjustable)
-        self.update_columns(
-          amount: amount,
-          updated_at: Time.now,
-        )
-        if promotion?
-          self.update_column(:eligible, source.promotion.eligible?(adjustable))
-        end
-      end
+    def update!(target = adjustable)
+      return amount if closed? || source.blank?
+      amount = source.compute_amount(target)
+      attributes = { amount: amount, updated_at: Time.now }
+      attributes[:eligible] = source.promotion.eligible?(target) if promotion?
+      update_columns(attributes)
       amount
     end
 
@@ -108,7 +99,7 @@ module Spree
 
     def update_adjustable_adjustment_total
       # Cause adjustable's total to be recalculated
-      ItemAdjustments.new(adjustable).update
+      Adjustable::AdjustmentsUpdater.update(adjustable)
     end
 
   end

data/app/models/spree/app_configuration.rb

@@ -25,31 +25,20 @@ module Spree
     preference :admin_products_per_page, :integer, default: 10
     preference :allow_checkout_on_gateway_error, :boolean, default: false
     preference :allow_guest_checkout, :boolean, default: true
-    preference :allow_return_item_amount_editing, :boolean, default: false # Determines whether an admin is allowed to change a return item's pre-calculated amount
-    preference :allow_ssl_in_development_and_test, :boolean, default: false
-    preference :allow_ssl_in_production, :boolean, default: true
-    preference :allow_ssl_in_staging, :boolean, default: true
-    preference :alternative_billing_phone, :boolean, default: false # Request extra phone for bill addr
     preference :alternative_shipping_phone, :boolean, default: false # Request extra phone for ship addr
     preference :always_include_confirm_step, :boolean, default: false # Ensures confirmation step is always in checkout_progress bar, but does not force a confirm step if your payment methods do not support it.
     preference :always_put_site_name_in_title, :boolean, default: true
     preference :auto_capture, :boolean, default: false # automatically capture the credit card (as opposed to just authorize and capture later)
     preference :auto_capture_on_dispatch, :boolean, default: false # Captures payment for each shipment in Shipment#after_ship callback, and makes Shipment.ready when payment authorized.
     preference :binary_inventory_cache, :boolean, default: false # only invalidate product cache when a stock item changes whether it is in_stock
-    preference :check_for_spree_alerts, :boolean, default: false
+    preference :check_for_spree_alerts, :boolean, default: true
     preference :checkout_zone, :string, default: nil # replace with the name of a zone if you would like to limit the countries
     preference :company, :boolean, default: false # Request company field for billing and shipping addr
     preference :currency, :string, default: "USD"
-    preference :currency_decimal_mark, :string, default: "."
-    preference :currency_symbol_position, :string, default: "before"
-    preference :currency_sign_before_symbol, :boolean, default: true
-    preference :currency_thousands_separator, :string, default: ","
-    preference :display_currency, :boolean, default: false
     preference :default_country_id, :integer
     preference :dismissed_spree_alerts, :string, default: ''
     preference :expedited_exchanges, :boolean, default: false # NOTE this requires payment profiles to be supported on your gateway of choice as well as a delayed job handler to be configured with activejob. kicks off an exchange shipment upon return authorization save. charge customer if they do not return items within timely manner.
     preference :expedited_exchanges_days_window, :integer, default: 14 # the amount of days the customer has to return their item after the expedited exchange is shipped in order to avoid being charged
-    preference :hide_cents, :boolean, default: false
     preference :last_check_for_spree_alerts, :string, default: nil
     preference :layout, :string, default: 'spree/layouts/spree_application'
     preference :logo, :string, default: 'logo/spree_50.png'
@@ -59,7 +48,6 @@ module Spree
     preference :products_per_page, :integer, default: 12
     preference :promotions_per_page, :integer, default: 15
     preference :customer_returns_per_page, :integer, default: 15
-    preference :redirect_https_to_http, :boolean, :default => false
     preference :require_master_price, :boolean, default: true
     preference :restock_inventory, :boolean, default: true # Determines if a return item is restocked automatically once it has been received
     preference :return_eligibility_number_of_days, :integer, default: 365
@@ -67,13 +55,13 @@ module Spree
     preference :show_only_complete_orders_by_default, :boolean, default: true
     preference :show_variant_full_price, :boolean, default: false #Displays variant full price or difference with product price. Default false to be compatible with older behavior
     preference :show_products_without_price, :boolean, default: false
-    preference :show_raw_product_description, :boolean, :default => false
+    preference :show_raw_product_description, :boolean, default: false
     preference :tax_using_ship_address, :boolean, default: true
     preference :track_inventory_levels, :boolean, default: true # Determines whether to track on_hand values for variants / products.
 
     # Default mail headers settings
-    preference :send_core_emails, :boolean, :default => true
-    preference :mails_from, :string, :default => 'spree@example.com'
+    preference :send_core_emails, :boolean, default: true
+    preference :mails_from, :string, default: 'spree@example.com'
 
     # searcher_class allows spree extension writers to provide their own Search class
     def searcher_class
@@ -83,22 +71,5 @@ module Spree
     def searcher_class=(sclass)
       @searcher_class = sclass
     end
-
-    # all the following can be deprecated when store prefs are no longer supported
-    DEPRECATED_STORE_PREFERENCES = {
-      site_name: :name,
-      site_url: :url,
-      default_meta_description: :meta_description,
-      default_meta_keywords: :meta_keywords,
-      default_seo_title: :seo_title,
-    }
-
-    DEPRECATED_STORE_PREFERENCES.each do |old_preference_name, store_method|
-      # support all the old preference methods with a warning
-      define_method "preferred_#{old_preference_name}" do
-        ActiveSupport::Deprecation.warn("#{old_preference_name} is no longer supported on Spree::Config, please access it through #{store_method} on Spree::Store")
-        Store.default.send(store_method)
-      end
-    end
   end
 end

data/app/models/spree/base.rb

@@ -1,9 +1,6 @@
 class Spree::Base < ActiveRecord::Base
   include Spree::Preferences::Preferable
   serialize :preferences, Hash
-
-  include Spree::RansackableAttributes
-
   after_initialize do
     self.preferences = default_preferences.merge(preferences) if has_attribute?(:preferences)
   end

data/app/models/spree/calculator.rb

@@ -1,10 +1,5 @@
 module Spree
   class Calculator < Spree::Base
-    # Conditional check for backwards compatibilty since acts as paranoid was added late https://github.com/spree/spree/issues/5858
-    if connection.table_exists?(:spree_calculators) && connection.column_exists?(:spree_calculators, :deleted_at)
-      acts_as_paranoid
-    end
-
     belongs_to :calculable, polymorphic: true
 
     # This method calls a compute_<computable> method. must be overriden in concrete calculator.

data/app/models/spree/classification.rb

@@ -2,7 +2,7 @@ module Spree
   class Classification < Spree::Base
     self.table_name = 'spree_products_taxons'
     acts_as_list scope: :taxon
-    belongs_to :product, class_name: "Spree::Product", inverse_of: :classifications, touch: true
+    belongs_to :product, class_name: "Spree::Product", inverse_of: :classifications
     belongs_to :taxon, class_name: "Spree::Taxon", inverse_of: :classifications, touch: true
 
     # For #3494

data/app/models/spree/country.rb

@@ -3,12 +3,18 @@ module Spree
     has_many :states, -> { order('name ASC') }, dependent: :destroy
     has_many :addresses, dependent: :nullify
 
+    has_many :zone_members,
+      -> { where(zoneable_type: 'Spree::Country') },
+      class_name: 'Spree::ZoneMember',
+      foreign_key: :zoneable_id
+
+    has_many :zones, through: :zone_members, class_name: 'Spree::Zone'
+
     validates :name, :iso_name, presence: true
 
-    def self.states_required_by_country_id
-      states_required = Hash.new(true)
-      all.each { |country| states_required[country.id.to_s]= country.states_required }
-      states_required
+    def self.default
+      country_id = Spree::Config[:default_country_id]
+      country_id.present? ? find(country_id) : find_by!(iso: 'US')
     end
 
     def <=>(other)

data/app/models/spree/credit_card.rb

@@ -18,8 +18,6 @@ module Spree
     validates :name, presence: true, if: :require_card_numbers?, on: :create
     validates :verification_value, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
 
-    validate :expiry_not_in_the_past
-
     scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
     scope :default, -> { where(default: true) }
 
@@ -35,6 +33,20 @@ module Spree
       jcb: /^(?:2131|1800|35\d{3})\d{11}$/
     }
 
+    # As of rails 4.2 string columns always return strings, perhaps we should
+    # change these to integer columns on db level
+    def month
+      if type_casted = super
+        type_casted.to_i
+      end
+    end
+
+    def year
+      if type_casted = super
+        type_casted.to_i
+      end
+    end
+
     def expiry=(expiry)
       return unless expiry.present?
 
@@ -135,19 +147,6 @@ module Spree
 
     private
 
-    def expiry_not_in_the_past
-      if year.present? && month.present?
-        if month.to_i < 1 || month.to_i > 12
-          errors.add(:base, :expiry_invalid)
-        else
-          current = Time.current
-          if year.to_i < current.year or (year.to_i == current.year and month.to_i < current.month)
-            errors.add(:base, :card_expired)
-          end
-        end
-      end
-    end
-
     def require_card_numbers?
       !self.encrypted_data.present? && !self.has_payment_profile?
     end

data/app/models/spree/customer_return.rb

@@ -2,31 +2,24 @@ module Spree
   class CustomerReturn < Spree::Base
     belongs_to :stock_location
 
-    has_many :reimbursements, inverse_of: :customer_return
-    has_many :return_authorizations, through: :return_items
     has_many :return_items, inverse_of: :customer_return
+    has_many :return_authorizations, through: :return_items
+    has_many :reimbursements, inverse_of: :customer_return
 
     after_create :process_return!
     before_create :generate_number
 
     validates :return_items, presence: true
     validates :stock_location, presence: true
-
-    validate :must_have_return_authorization, on: :create
     validate :return_items_belong_to_same_order
 
     accepts_nested_attributes_for :return_items
 
-    def completely_decided?
-      !return_items.undecided.exists?
-    end
+    extend DisplayMoney
+    money_methods pre_tax_total: { currency: Spree::Config[:currency] }
 
-    def fully_reimbursed?
-      completely_decided? && return_items.accepted.includes(:reimbursement).all? { |return_item| return_item.reimbursement.try(:reimbursed?) }
-    end
-
-    def display_pre_tax_total
-      Spree::Money.new(pre_tax_total, { currency: Spree::Config[:currency] })
+    def pre_tax_total
+      return_items.sum(:pre_tax_amount)
     end
 
     # Temporarily tie a customer_return to one order
@@ -39,21 +32,15 @@ module Spree
       order.try(:id)
     end
 
-    def pre_tax_total
-      return_items.sum(:pre_tax_amount)
+    def fully_reimbursed?
+      completely_decided? && return_items.accepted.includes(:reimbursement).all? { |return_item| return_item.reimbursement.try(:reimbursed?) }
     end
 
-    private
-
-    def inventory_units
-      return_items.flat_map(&:inventory_unit)
+    def completely_decided?
+      !return_items.undecided.exists?
     end
 
-    def must_have_return_authorization
-      if item = return_items.find { |ri| ri.return_authorization.blank? }
-        errors.add(:base, Spree.t(:missing_return_authorization, item_name: item.inventory_unit.variant.name))
-      end
-    end
+    private
 
     def generate_number
       self.number ||= loop do
@@ -68,9 +55,15 @@ module Spree
     end
 
     def return_items_belong_to_same_order
-      if return_items.select { |return_item| return_item.inventory_unit.order_id != order_id }.any?
+      if return_items.select{ |return_item| return_item.inventory_unit.order_id != order_id }.any?
         errors.add(:base, Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
       end
     end
+
+    def inventory_units
+      return_items.flat_map(&:inventory_unit)
+    end
+
   end
 end
+