spree_core 2.3.1 → 2.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 66920ae53fa26364425582e338582f7543cfde28
-  data.tar.gz: fec0a8ddbf653e8a1a21e5fc8ae1954745b77a23
+  metadata.gz: b7bfe527c1516e5d8393c4cb6a23bf795bff2f8d
+  data.tar.gz: dd9c6e528157dd843740ff2cd5bc86d6fa906192
 SHA512:
-  metadata.gz: 0223b441cc91485cb7d8c138ee3ca4f79120b03067b0374fd0f3b6ab5e4b1dfe88f0811719d7517c0a782ae2f1f421d0ad7e4257279b028d2f82071aeee604fc
-  data.tar.gz: 8a79116e5fed7a827e1f01c3ddc3b5893a8ce007c1e67fb620040b7dd1975a93f097df4714ea527801ee02e9559fda64375fecb939f9e9cf9a5c6d7381a38ac7
+  metadata.gz: 0fb13c6c497d8ab9d920e6f950a532e16524f305e2591e82b12bd1ae1aa47d53f2a8ca0fd293d588c8b8ed32d3bac49c2a2cfef851a1ba9b237b7149994c9f60
+  data.tar.gz: 5ea8cacb10c49bf4afaa936a9ae348d13979a1f30855214e491aff0abf9ca9ba3f495f7d38c295a1266b4be9ab26e5adbf47c5dc464b72fc0555b2fc2740f1d8

data/app/helpers/spree/base_helper.rb

@@ -68,10 +68,10 @@ module Spree
     end
 
     def flash_messages(opts = {})
-      opts[:ignore_types] = [:order_completed].concat(Array(opts[:ignore_types]) || [])
+      ignore_types = ["order_completed"].concat(Array(opts[:ignore_types]).map(&:to_s) || [])
 
       flash.each do |msg_type, text|
-        unless opts[:ignore_types].include?(msg_type)
+        unless ignore_types.include?(msg_type)
           concat(content_tag :div, text, class: "flash #{msg_type}")
         end
       end
@@ -118,7 +118,7 @@ module Spree
       countries.collect do |country|
         country.name = Spree.t(country.iso, scope: 'country_names', default: country.name)
         country
-      end.sort { |a, b| a.name.parameterize <=> b.name.parameterize }
+      end.sort_by { |c| c.name.parameterize }
     end
 
     def seo_url(taxon)

data/app/models/spree/ability.rb

@@ -50,6 +50,7 @@ module Spree
         can :update, Address do |address|
           user.bill_address == address || user.ship_address == address
         end
+        can :display, CreditCard, user_id: user.id
         can :display, Product
         can :display, ProductProperty
         can :display, Property

data/app/models/spree/app_configuration.rb

@@ -57,7 +57,6 @@ module Spree
     preference :promotions_per_page, :integer, default: 15
     preference :redirect_https_to_http, :boolean, :default => false
     preference :require_master_price, :boolean, default: true
-    preference :shipment_inc_vat, :boolean, default: false
     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

data/app/models/spree/base.rb

@@ -5,5 +5,11 @@ class Spree::Base < ActiveRecord::Base
     self.preferences = default_preferences.merge(preferences) if has_attribute?(:preferences)
   end
 
+  if Kaminari.config.page_method_name != :page
+    def self.page num
+      send Kaminari.config.page_method_name, num
+    end
+  end
+
   self.abstract_class = true
 end

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

@@ -8,9 +8,15 @@ module Spree
       Spree.t(:flat_percent)
     end
 
-    def compute(line_item)
-      value = line_item.amount * BigDecimal(self.preferred_flat_percent.to_s) / 100.0
-      (value * 100).round.to_f / 100
+    def compute(object)
+      computed_amount  = (object.amount * preferred_flat_percent / 100).round(2)
+
+      # We don't want to cause the promotion adjustments to push the order into a negative total.
+      if computed_amount > object.amount
+        object.amount
+      else
+        computed_amount
+      end
     end
   end
 end

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

@@ -18,7 +18,7 @@ module Spree
     def compute(object)
       sum = 0
       max = self.preferred_max_items.to_i
-      items_count = object.line_items.map(&:quantity).sum
+      items_count = object.quantity
       items_count.times do |i|
         if i == 0
           sum += self.preferred_first_item.to_f

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

@@ -8,7 +8,7 @@ module Spree
       end
 
       def compute(object)
-        ((object.price * object.quantity) * preferred_percent) / 100
+        (object.amount * preferred_percent) / 100
       end
     end
   end

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

@@ -0,0 +1,37 @@
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::TieredFlatRate < Calculator
+    preference :base_amount, :decimal, default: 0
+    preference :tiers, :hash, default: {}
+
+    before_validation do
+      # Convert tier values to decimals. Strings don't do us much good.
+      if preferred_tiers.is_a?(Hash)
+        self.preferred_tiers = Hash[*preferred_tiers.flatten.map(&:to_f)]
+      end
+    end
+
+    validate :preferred_tiers_content
+
+    def self.description
+      Spree.t(:tiered_flat_rate)
+    end
+
+    def compute(object)
+      base, amount = preferred_tiers.sort.reverse.detect{ |b,_| object.amount >= b }
+      amount || preferred_base_amount
+    end
+
+    private
+    def preferred_tiers_content
+      if preferred_tiers.is_a? Hash
+        unless preferred_tiers.keys.all?{ |k| k.is_a?(Numeric) && k > 0 }
+          errors.add(:base, :keys_should_be_positive_number)
+        end
+      else
+        errors.add(:preferred_tiers, :should_be_hash)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::TieredPercent < Calculator
+    preference :base_percent, :decimal, default: 0
+    preference :tiers, :hash, default: {}
+
+    before_validation do
+      # Convert tier values to decimals. Strings don't do us much good.
+      if preferred_tiers.is_a?(Hash)
+        self.preferred_tiers = Hash[*preferred_tiers.flatten.map(&:to_f)]
+      end
+    end
+
+    validates :preferred_base_percent, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: 100
+    }
+    validate :preferred_tiers_content
+
+    def self.description
+      Spree.t(:tiered_percent)
+    end
+
+    def compute(object)
+      base, percent = preferred_tiers.sort.reverse.detect{ |b,_| object.amount >= b }
+      (object.amount * (percent || preferred_base_percent) / 100).round(2)
+    end
+
+    private
+    def preferred_tiers_content
+      if preferred_tiers.is_a? Hash
+        unless preferred_tiers.keys.all?{ |k| k.is_a?(Numeric) && k > 0 }
+          errors.add(:base, :keys_should_be_positive_number)
+        end
+        unless preferred_tiers.values.all?{ |k| k.is_a?(Numeric) && k >= 0 && k <= 100 }
+          errors.add(:base, :values_should_be_percent)
+        end
+      else
+        errors.add(:preferred_tiers, :should_be_hash)
+      end
+    end
+  end
+end

data/app/models/spree/credit_card.rb

@@ -3,14 +3,17 @@ module Spree
     belongs_to :payment_method
     has_many :payments, as: :source
 
-    before_save :set_last_digits
+    before_create :set_missing_info
 
-    attr_accessor :number, :verification_value, :encrypted_data
+    attr_accessor :encrypted_data,
+                    :number,
+                    :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
+    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
+    validates :verification_value, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
 
     validate :expiry_not_in_the_past
 
@@ -60,12 +63,6 @@ module Spree
       end
     end
 
-    def set_last_digits
-      number.to_s.gsub!(/\s/,'')
-      verification_value.to_s.gsub!(/\s/,'')
-      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
-    end
-
     def try_type_from_number
       numbers = number.delete(' ') if number
       CARD_TYPES.find{|type, pattern| return type.to_s if numbers =~ pattern}.to_s
@@ -91,7 +88,7 @@ module Spree
 
     # Indicates whether its possible to void the payment.
     def can_void?(payment)
-      !payment.void?
+      !payment.failed? && !payment.void?
     end
 
     # Indicates whether its possible to credit the payment.  Note that most gateways require that the
@@ -132,9 +129,13 @@ module Spree
 
     def expiry_not_in_the_past
       if year.present? && month.present?
-        time = Time.zone.parse("#{year}-#{month}-1")
-        if time < Time.zone.now.to_time.beginning_of_month
-          errors.add(:base, :card_expired)
+        if month.to_i < 1 || month.to_i > 12
+          errors.add(:base, :expiry_invalid)
+        else
+          time = Time.zone.parse("#{year}-#{month}-1")
+          if time < Time.zone.now.to_time.beginning_of_month
+            errors.add(:base, :card_expired)
+          end
         end
       end
     end
@@ -142,5 +143,25 @@ module Spree
     def require_card_numbers?
       !self.encrypted_data.present? && !self.has_payment_profile?
     end
+
+    def set_last_digits
+      number.to_s.gsub!(/\s/,'')
+      verification_value.to_s.gsub!(/\s/,'')
+      self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
+    end
+
+    def set_missing_info
+      set_last_digits
+      if has_payment_profile?
+        if matching_card = self.class.where(gateway_customer_profile_id: self.gateway_customer_profile_id, gateway_payment_profile_id: self.gateway_payment_profile_id).first
+          self.cc_type     = matching_card.cc_type
+          self.last_digits = matching_card.last_digits
+          self.month       = matching_card.month
+          self.name        = matching_card.name
+          self.year        = matching_card.year
+        end
+      end
+    end
+
   end
 end

data/app/models/spree/inventory_unit.rb

@@ -70,6 +70,7 @@ module Spree
       end
 
       def update_order
+        self.reload
         order.update!
       end
   end

data/app/models/spree/item_adjustments.rb

@@ -47,8 +47,9 @@ module Spree
       included_tax_total = 0
       additional_tax_total = 0
       run_callbacks :tax_adjustments do
-        included_tax_total = adjustments.tax.included.reload.map(&:update!).compact.sum
-        additional_tax_total = adjustments.tax.additional.reload.map(&:update!).compact.sum
+        tax = (item.respond_to?(:all_adjustments) ? item.all_adjustments : item.adjustments).tax
+        included_tax_total = tax.included.reload.map(&:update!).compact.sum
+        additional_tax_total = tax.additional.reload.map(&:update!).compact.sum
       end
 
       item.update_columns(

data/app/models/spree/line_item.rb

@@ -97,7 +97,7 @@ module Spree
 
     private
       def update_inventory
-        if changed? || target_shipment.present?
+        if (changed? || target_shipment.present?) && self.order.has_checkout_step?("delivery")
           Spree::OrderInventory.new(self.order, self).verify(target_shipment)
         end
       end
@@ -119,7 +119,7 @@ module Spree
 
       def ensure_proper_currency
         unless currency == order.currency
-          errors.add(:currency, t(:must_match_order_currency))
+          errors.add(:currency, :must_match_order_currency)
         end
       end
   end

data/app/models/spree/order.rb

@@ -3,25 +3,20 @@ require 'spree/order/checkout'
 
 module Spree
   class Order < Spree::Base
-    include Checkout
-    include CurrencyUpdater
+    include Spree::Order::Checkout
+    include Spree::Order::CurrencyUpdater
 
     checkout_flow do
       go_to_state :address
       go_to_state :delivery
-      go_to_state :payment, if: ->(order) do
-        # TODO there should be a better fix work around for the issues this is
-        # resolving we shouldn't be setting shipments cost every time a order
-        # object is loaded
-        order.set_shipments_cost if order.shipments.any?
-        order.payment_required?
-      end
+      go_to_state :payment, if: ->(order) { order.payment_required? }
       go_to_state :confirm, if: ->(order) { order.confirmation_required? }
       go_to_state :complete
       remove_transition from: :delivery, to: :confirm
     end
 
     attr_reader :coupon_code
+    attr_accessor :temporary_address
 
     if Spree.user_class
       belongs_to :user, class_name: Spree.user_class.to_s
@@ -79,6 +74,7 @@ module Spree
 
     validates :email, presence: true, if: :require_email
     validates :email, email: true, if: :require_email, allow_blank: true
+    validates :number, uniqueness: true
     validate :has_available_shipment
 
     make_permalink field: :number
@@ -95,6 +91,8 @@ module Spree
     scope :created_between, ->(start_date, end_date) { where(created_at: start_date..end_date) }
     scope :completed_between, ->(start_date, end_date) { where(completed_at: start_date..end_date) }
 
+    scope :reverse_chronological, -> { order(created_at: :desc) }
+
     def self.by_customer(customer)
       joins(:user).where("#{Spree.user_class.table_name}.email" => customer)
     end
@@ -258,15 +256,18 @@ module Spree
       end
     end
 
-    # FIXME refactor this method and implement validation using validates_* utilities
-    def generate_order_number
-      record = true
-      while record
-        random = "R#{Array.new(9){rand(9)}.join}"
-        record = self.class.where(number: random).first
-      end
-      self.number = random if self.number.blank?
-      self.number
+    def generate_order_number(digits = 9)
+      self.number ||= loop do
+         # Make a random number.
+         random = "R#{Array.new(digits){rand(10)}.join}"
+         # Use the random  number if no other order exists with it.
+         if self.class.exists?(number: random)
+           # If over half of all possible options are taken add another digit.
+           digits += 1 if self.class.count > (10 ** digits / 2)
+         else
+           break random
+         end
+       end
     end
 
     def shipped_shipments
@@ -296,7 +297,11 @@ module Spree
     end
 
     def outstanding_balance
-      total - payment_total
+      if self.state == 'canceled' && self.payments.present? && self.payments.completed.size > 0
+        -1 * payment_total
+      else
+        total - payment_total
+      end
     end
 
     def outstanding_balance?
@@ -403,6 +408,12 @@ module Spree
      line_items.select(&:insufficient_stock?)
     end
 
+    def ensure_line_items_are_in_stock
+      if insufficient_stock_lines.present?
+        errors.add(:base, Spree.t(:insufficient_stock_lines_present)) and return false
+      end
+    end
+
     def merge!(order, user = nil)
       order.line_items.each do |line_item|
         next unless line_item.currency == currency
@@ -572,7 +583,7 @@ module Spree
       self.ensure_updated_shipments
     end
 
-    def reload
+    def reload(options=nil)
       remove_instance_variable(:@tax_zone) if defined?(@tax_zone)
       super
     end
@@ -581,6 +592,10 @@ module Spree
       included_tax_total + additional_tax_total
     end
 
+    def quantity
+      line_items.sum(:quantity)
+    end
+
     private
 
       def link_by_email
@@ -620,6 +635,7 @@ module Spree
 
         send_cancel_email
         self.update_column(:payment_state, 'credit_owed') unless shipped?
+        self.update!
       end
 
       def send_cancel_email

data/app/models/spree/order/checkout.rb

@@ -38,8 +38,8 @@ module Spree
             # To avoid multiple occurrences of the same transition being defined
             # On first definition, state_machines will not be defined
             state_machines.clear if respond_to?(:state_machines)
-            state_machine :state, :initial => :cart, :use_transactions => false, :action => :save_state do
-              klass.next_event_transitions.each { |t| transition(t.merge(:on => :next)) }
+            state_machine :state, initial: :cart, use_transactions: false, action: :save_state do
+              klass.next_event_transitions.each { |t| transition(t.merge(on: :next)) }
 
               # Persist the state on the order
               after_transition do |order, transition|
@@ -54,23 +54,23 @@ module Spree
               end
 
               event :cancel do
-                transition :to => :canceled, :if => :allow_cancel?
+                transition to: :canceled, if: :allow_cancel?
               end
 
               event :return do
-                transition :to => :returned, :from => :awaiting_return, :unless => :awaiting_returns?
+                transition to: :returned, from: :awaiting_return, unless: :awaiting_returns?
               end
 
               event :resume do
-                transition :to => :resumed, :from => :canceled, :if => :canceled?
+                transition to: :resumed, from: :canceled, if: :canceled?
               end
 
               event :authorize_return do
-                transition :to => :awaiting_return
+                transition to: :awaiting_return
               end
 
               if states[:payment]
-                before_transition :to => :complete do |order|
+                before_transition to: :complete do |order|
                   if order.payment_required? && order.payments.empty?
                     order.errors.add(:base, Spree.t(:no_payment_found))
                     false
@@ -80,28 +80,32 @@ module Spree
                 end
               end
 
-              before_transition :from => :cart, :do => :ensure_line_items_present
+              before_transition from: :cart, do: :ensure_line_items_present
 
               if states[:address]
-                before_transition :from => :address, :do => :create_tax_charge!
+                before_transition from: :address, do: :create_tax_charge!
+                before_transition to: :address, do: :assign_default_addresses!
+                before_transition from: :address, do: :persist_user_address!
               end
 
               if states[:payment]
-                before_transition :to => :payment, :do => :set_shipments_cost
-                before_transition :to => :payment, :do => :create_tax_charge!
+                before_transition to: :payment, do: :set_shipments_cost
+                before_transition to: :payment, do: :create_tax_charge!
               end
 
               if states[:delivery]
-                before_transition :to => :delivery, :do => :create_proposed_shipments
-                before_transition :to => :delivery, :do => :ensure_available_shipping_rates
-                before_transition :from => :delivery, :do => :apply_free_shipping_promotions
+                before_transition to: :delivery, do: :create_proposed_shipments
+                before_transition to: :delivery, do: :ensure_available_shipping_rates
+                before_transition from: :delivery, do: :apply_free_shipping_promotions
               end
 
-              after_transition :to => :complete, :do => :finalize!
-              after_transition :to => :resumed,  :do => :after_resume
-              after_transition :to => :canceled, :do => :after_cancel
+              before_transition to: :resumed, do: :ensure_line_items_are_in_stock
 
-              after_transition :from => any - :cart, :to => any - [:confirm, :complete] do |order|
+              after_transition to: :complete, do: :finalize!
+              after_transition to: :resumed,  do: :after_resume
+              after_transition to: :canceled, do: :after_cancel
+
+              after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
                 order.update_totals
                 order.persist_totals
               end
@@ -113,7 +117,7 @@ module Spree
           def self.go_to_state(name, options={})
             self.checkout_steps[name] = options
             previous_states.each do |state|
-              add_transition({:from => state, :to => name}.merge(options))
+              add_transition({from: state, to: name}.merge(options))
             end
             if options[:if]
               self.previous_states << name
@@ -217,12 +221,17 @@ module Spree
             success = false
             @updating_params = params
             run_callbacks :updating_from_params do
-              attributes = @updating_params[:order] ? @updating_params[:order].permit(permitted_params) : {}
+              attributes = @updating_params[:order] ? @updating_params[:order].permit(permitted_params).delete_if { |k,v| v.nil? } : {}
 
               # Set existing card after setting permitted parameters because
               # rails would slice parameters containg ruby objects, apparently
-              if @updating_params[:existing_card].present?
-                credit_card = CreditCard.find(@updating_params[:existing_card])
+              #
+              # Need to check both outside and inside :order beacuse frontend
+              # sends existing_card out of :order
+              existing_card_id = @updating_params[:existing_card] || (@updating_params[:order] ? @updating_params[:order][:existing_card] : nil)
+
+              if existing_card_id.present?
+                credit_card = CreditCard.find existing_card_id
                 if credit_card.user_id != self.user_id || credit_card.user_id.blank?
                   raise Core::GatewayError.new Spree.t(:invalid_credit_card)
                 end
@@ -239,27 +248,54 @@ module Spree
               end
 
               success = self.update_attributes(attributes)
+              set_shipments_cost if self.shipments.any?
             end
 
             @updating_params = nil
             success
           end
 
+          def assign_default_addresses!
+            if self.user
+              self.bill_address = user.bill_address.try(:clone) if !self.bill_address_id && user.bill_address.try(:valid?)
+              # Skip setting ship address if order doesn't have a delivery checkout step
+              # to avoid triggering validations on shipping address
+              self.ship_address = user.ship_address.try(:clone) if !self.ship_address_id && user.ship_address.try(:valid?) && self.checkout_steps.include?("delivery")
+            end
+          end
+
+          def persist_user_address!
+            if !self.temporary_address && self.user && self.user.respond_to?(:persist_order_address) && self.bill_address_id
+              self.user.persist_order_address(self)
+            end
+          end
+
           private
           # For payment step, filter order parameters to produce the expected nested
           # attributes for a single payment and its source, discarding attributes
           # for payment methods other than the one selected
+          #
+          # In case a existing credit card is provided it needs to build the payment
+          # attributes from scratch so we can set the amount. example payload:
+          #
+          #   {
+          #     "order": {
+          #       "existing_card": "2"
+          #     }
+          #   }
+          #
           def update_params_payment_source
             if has_checkout_step?("payment") && self.payment?
               if @updating_params[:payment_source].present?
-                source_params = @updating_params.delete(:payment_source)[@updating_params[:order][:payments_attributes].first[:payment_method_id].underscore]
+                source_params = @updating_params.delete(:payment_source)[@updating_params[:order][:payments_attributes].first[:payment_method_id].to_s]
 
                 if source_params
                   @updating_params[:order][:payments_attributes].first[:source_attributes] = source_params
                 end
               end
 
-              if (@updating_params[:order][:payments_attributes])
+              if @updating_params[:order][:payments_attributes] || @updating_params[:order][:existing_card]
+                @updating_params[:order][:payments_attributes] ||= [{}]
                 @updating_params[:order][:payments_attributes].first[:amount] = self.total
               end
             end