spree_core 3.0.10 → 3.1.0.rc1

data/app/models/spree/adjustable/adjuster/tax.rb

@@ -0,0 +1,26 @@
+module Spree
+  module Adjustable
+    module Adjuster
+      class Tax < Spree::Adjustable::Adjuster::Base
+        def update
+          tax = adjustments.tax
+          included_tax_total = tax.is_included.reload.map(&:update!).compact.sum
+          additional_tax_total = tax.additional.reload.map(&:update!).compact.sum
+
+          update_totals(included_tax_total, additional_tax_total)
+        end
+
+        private
+
+        def adjustments
+          adjustable.try(:all_adjustments) || adjustable.adjustments
+        end
+
+        def update_totals(included_tax_total, additional_tax_total)
+          @totals[:included_tax_total] = included_tax_total
+          @totals[:additional_tax_total] = additional_tax_total
+        end
+      end
+    end
+  end
+end

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

@@ -7,63 +7,40 @@ module Spree
 
       def initialize(adjustable)
         @adjustable = adjustable
-        adjustable.reload if shipment? && persisted?
+        adjustable.reload if shipment? && adjustable.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
+        return unless @adjustable.persisted?
+
+        totals = {
+          non_taxable_adjustment_total: 0,
+          taxable_adjustment_total: 0
+        }
+        adjusters.each do |klass|
+          klass.adjust(@adjustable, totals)
+        end
 
-      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
+        persist_totals totals
       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
+      private
 
-      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
-        )
+      def persist_totals(totals)
+        attributes = totals
+        attributes[:adjustment_total] = totals[:non_taxable_adjustment_total] +
+                                        totals[:taxable_adjustment_total] +
+                                        totals[:additional_tax_total]
+        attributes[:updated_at] = Time.current
+        @adjustable.update_columns(totals)
       end
 
       def shipment?
-        adjustable.is_a?(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
+      def adjusters
+        Rails.application.config.spree.adjusters
       end
     end
   end

data/app/models/spree/adjustment.rb

@@ -22,13 +22,13 @@
 # it might be reinstated.
 module Spree
   class Adjustment < Spree::Base
-    belongs_to :adjustable, polymorphic: true, touch: true
-    belongs_to :source, polymorphic: true
+    with_options polymorphic: true do
+      belongs_to :adjustable, touch: true
+      belongs_to :source
+    end
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments
 
-    validates :adjustable, presence: true
-    validates :order, presence: true
-    validates :label, presence: true
+    validates :adjustable, :order, :label, presence: true
     validates :amount, numericality: true
 
     state_machine :state, initial: :open do
@@ -67,14 +67,12 @@ module Spree
     scope :is_included, -> { where(included: true) }
     scope :additional, -> { where(included: false) }
     scope :competing_promos, -> { where(source_type: competing_promos_source_types) }
+    scope :for_complete_order, -> { joins(:order).merge(Spree::Order.complete) }
+    scope :for_incomplete_order, -> { joins(:order).merge(Spree::Order.incomplete) }
 
     extend DisplayMoney
     money_methods :amount
 
-    def closed?
-      state == "closed"
-    end
-
     def currency
       adjustable ? adjustable.currency : Spree::Config[:currency]
     end
@@ -89,7 +87,7 @@ module Spree
     def update!(target = adjustable)
       return amount if closed? || source.blank?
       amount = source.compute_amount(target)
-      attributes = { amount: amount, updated_at: Time.now }
+      attributes = { amount: amount, updated_at: Time.current }
       attributes[:eligible] = source.promotion.eligible?(target) if promotion?
       update_columns(attributes)
       amount

data/app/models/spree/app_configuration.rb

@@ -22,6 +22,7 @@ module Spree
     # Alphabetized to more easily lookup particular preferences
     preference :address_requires_state, :boolean, default: true # should state/state_name be required
     preference :admin_interface_logo, :string, default: 'logo/spree_50.png'
+    preference :admin_path, :string, default: '/admin'
     preference :admin_products_per_page, :integer, default: 10
     preference :allow_checkout_on_gateway_error, :boolean, default: false
     preference :allow_guest_checkout, :boolean, default: true
@@ -48,6 +49,7 @@ module Spree
     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
+    preference :send_core_emails, :boolean, default: true # Default mail headers settings
     preference :shipping_instructions, :boolean, default: false # Request instructions/info for shipping
     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
@@ -56,8 +58,9 @@ module Spree
     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
+    # Store credits configurations
+    preference :non_expiring_credit_types, :array, default: []
+    preference :credit_to_new_allocation, :boolean, default: false
 
     # searcher_class allows spree extension writers to provide their own Search class
     def searcher_class

data/app/models/spree/base.rb

@@ -17,4 +17,8 @@ class Spree::Base < ActiveRecord::Base
   end
 
   self.abstract_class = true
+
+  def self.spree_base_scopes
+    where(nil)
+  end
 end

data/app/models/spree/calculator.rb

@@ -27,11 +27,6 @@ module Spree
       'Base Calculator'
     end
 
-    ###################################################################
-
-    def self.register(*klasses)
-    end
-
     # Returns all calculators applicable for kind of work
     def self.calculators
       Rails.application.config.spree.calculators

data/app/models/spree/calculator/default_tax.rb

@@ -2,6 +2,7 @@ require_dependency 'spree/calculator'
 
 module Spree
   class Calculator::DefaultTax < Calculator
+    include VatPriceCalculation
     def self.description
       Spree.t(:default_tax)
     end
@@ -38,11 +39,7 @@ module Spree
     def compute_shipping_rate(shipping_rate)
       if rate.included_in_price
         pre_tax_amount = shipping_rate.cost / (1 + rate.amount)
-        if rate.zone == shipping_rate.shipment.order.tax_zone
-          deduced_total_by_rate(pre_tax_amount, rate)
-        else
-          deduced_total_by_rate(pre_tax_amount, rate) * - 1
-        end
+        deduced_total_by_rate(pre_tax_amount, rate)
       else
         with_tax_amount = shipping_rate.cost * rate.amount
         round_to_two_places(with_tax_amount)
@@ -55,13 +52,8 @@ module Spree
       self.calculable
     end
 
-    def round_to_two_places(amount)
-      BigDecimal.new(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
-    end
-
     def deduced_total_by_rate(pre_tax_amount, rate)
       round_to_two_places(pre_tax_amount * rate.amount)
     end
-
   end
 end

data/app/models/spree/classification.rb

@@ -2,10 +2,14 @@ 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 :taxon, class_name: "Spree::Taxon", inverse_of: :classifications, touch: true
 
+    with_options inverse_of: :classifications, touch: true do
+      belongs_to :product, class_name: "Spree::Product"
+      belongs_to :taxon, class_name: "Spree::Taxon"
+    end
+
+    validates :taxon, :product, presence: true
     # For #3494
-    validates_uniqueness_of :taxon_id, scope: :product_id, message: :already_linked
+    validates :taxon_id, uniqueness: { scope: :product_id, message: :already_linked, allow_blank: true }
   end
 end

data/app/models/spree/country.rb

@@ -1,7 +1,7 @@
 module Spree
   class Country < Spree::Base
-    has_many :states, -> { order('name ASC') }, dependent: :destroy
-    has_many :addresses, dependent: :nullify
+    has_many :states, dependent: :destroy
+    has_many :addresses, dependent: :restrict_with_error
 
     has_many :zone_members,
              -> { where(zoneable_type: 'Spree::Country') },
@@ -11,7 +11,9 @@ module Spree
 
     has_many :zones, through: :zone_members, class_name: 'Spree::Zone'
 
-    validates :name, :iso_name, presence: true
+    before_destroy :ensure_not_default
+
+    validates :name, :iso_name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
 
     def self.default
       country_id = Spree::Config[:default_country_id]
@@ -25,5 +27,14 @@ module Spree
     def to_s
       name
     end
+
+    private
+
+    def ensure_not_default
+      if id.eql?(Spree::Config[:default_country_id])
+        errors.add(:base, Spree.t(:default_country_cannot_be_deleted))
+        false
+      end
+    end
   end
 end

data/app/models/spree/credit_card.rb

@@ -8,15 +8,20 @@ module Spree
 
     after_save :ensure_one_default
 
+    # As of rails 4.2 string columns always return strings, we can override it on model level.
+    attribute :month, Type::Integer.new
+    attribute :year,  Type::Integer.new
+
+    attr_reader :number
     attr_accessor :encrypted_data,
-                    :number,
-                    :imported,
-                    :verification_value
+                  :imported,
+                  :verification_value
 
-    validates :month, :year, numericality: { only_integer: true }, if: :require_card_numbers?, on: :create
-    validates :number, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
-    validates :name, presence: true, if: :require_card_numbers?, on: :create
-    validates :verification_value, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
+    with_options if: :require_card_numbers?, on: :create do
+      validates :month, :year, numericality: { only_integer: true }
+      validates :number, :verification_value, presence: true, unless: :imported
+      validates :name, presence: true
+    end
 
     scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
     scope :default, -> { where(default: true) }
@@ -41,20 +46,6 @@ 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?
 
@@ -65,7 +56,7 @@ module Spree
         [match[1], match[2]]
       end
       if self[:year]
-        self[:year] = "20" + self[:year] if self[:year].length == 2
+        self[:year] = "20#{ self[:year] }" if self[:year] / 100 == 0
         self[:year] = self[:year].to_i
       end
       self[:month] = self[:month].to_i if self[:month]
@@ -144,12 +135,12 @@ module Spree
 
     def to_active_merchant
       ActiveMerchant::Billing::CreditCard.new(
-        :number => number,
-        :month => month,
-        :year => year,
-        :verification_value => verification_value,
-        :first_name => first_name,
-        :last_name => last_name,
+        number: number,
+        month: month,
+        year: year,
+        verification_value: verification_value,
+        first_name: first_name,
+        last_name: last_name,
       )
     end
 
@@ -161,9 +152,8 @@ module Spree
 
     def ensure_one_default
       if self.user_id && self.default
-        CreditCard.where(default: true).where.not(id: self.id).where(user_id: self.user_id).each do |ucc|
-          ucc.update_columns(default: false)
-        end
+        CreditCard.where(default: true, user_id: self.user_id).where.not(id: self.id)
+          .update_all(default: false)
       end
     end
   end

data/app/models/spree/customer_return.rb

@@ -1,5 +1,6 @@
 module Spree
   class CustomerReturn < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'CR', length: 9)
     belongs_to :stock_location
 
     has_many :reimbursements, inverse_of: :customer_return
@@ -7,11 +8,8 @@ module Spree
     has_many :return_items, inverse_of: :customer_return
 
     after_create :process_return!
-    before_create :generate_number
-
-    validates :return_items, presence: true
-    validates :stock_location, presence: true
 
+    validates :return_items, :stock_location, presence: true
     validate :must_have_return_authorization, on: :create
     validate :return_items_belong_to_same_order
 
@@ -20,6 +18,10 @@ module Spree
     extend DisplayMoney
     money_methods pre_tax_total: { currency: Spree::Config[:currency] }
 
+    self.whitelisted_ransackable_attributes = ['number']
+
+    delegate :id, to: :order, prefix: true, allow_nil: true
+
     def completely_decided?
       !return_items.undecided.exists?
     end
@@ -34,9 +36,6 @@ module Spree
       return_items.first.inventory_unit.order
     end
 
-    def order_id
-      order.try(:id)
-    end
 
     def pre_tax_total
       return_items.sum(:pre_tax_amount)
@@ -54,20 +53,13 @@ module Spree
       end
     end
 
-    def generate_number
-      self.number ||= loop do
-        random = "CR#{Array.new(9){rand(9)}.join}"
-        break random unless self.class.exists?(number: random)
-      end
-    end
-
     def process_return!
       return_items.each(&:receive!)
       order.return! if order.all_inventory_units_returned?
     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.any? { |return_item| return_item.inventory_unit.order_id != order_id }
         errors.add(:base, Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
       end
     end