spree_core 2.4.10 → 3.0.0.rc1

data/app/models/spree/order_contents.rb

@@ -22,10 +22,10 @@ module Spree
         # Update totals, then check if the order is eligible for any cart promotions.
         # If we do not update first, then the item total will be wrong and ItemTotal
         # promotion rules would not be triggered.
-        persist_totals
+        reload_totals
         PromotionHandler::Cart.new(order).activate
         order.ensure_updated_shipments
-        persist_totals
+        reload_totals
         true
       else
         false
@@ -34,12 +34,12 @@ module Spree
 
     private
       def after_add_or_remove(line_item, options = {})
-        persist_totals
+        reload_totals
         shipment = options[:shipment]
         shipment.present? ? shipment.update_amounts : order.ensure_updated_shipments
         PromotionHandler::Cart.new(order, line_item).activate
-        ItemAdjustments.new(line_item).update
-        persist_totals
+        Adjustable::AdjustmentsUpdater.update(line_item)
+        reload_totals
         line_item
       end
 
@@ -61,9 +61,10 @@ module Spree
         @updater ||= OrderUpdater.new(order)
       end
 
-      def persist_totals
+      def reload_totals
         order_updater.update_item_count
         order_updater.update
+        order.reload
       end
 
       def add_to_line_item(variant, quantity, options = {})
@@ -89,8 +90,8 @@ module Spree
         line_item.quantity -= quantity
         line_item.target_shipment= options[:shipment]
 
-        if line_item.quantity.zero?
-          order.line_items.destroy(line_item)
+        if line_item.quantity == 0
+          line_item.destroy
         else
           line_item.save!
         end

data/app/models/spree/order_updater.rb

@@ -30,7 +30,9 @@ module Spree
     end
 
     def recalculate_adjustments
-      all_adjustments.includes(:adjustable).map(&:adjustable).uniq.each { |adjustable| Spree::ItemAdjustments.new(adjustable).update }
+      all_adjustments.includes(:adjustable).map(&:adjustable).uniq.each do |adjustable|
+        Adjustable::AdjustmentsUpdater.update(adjustable)
+      end
     end
 
     # Updates the following Order total values:
@@ -168,5 +170,10 @@ module Spree
       order.state_changed('payment') if last_state != order.payment_state
       order.payment_state
     end
+
+    private
+      def round_money(n)
+        (n * 100).round / 100.0
+      end
   end
 end

data/app/models/spree/payment.rb

@@ -1,8 +1,18 @@
 module Spree
   class Payment < Spree::Base
+    extend FriendlyId
+    friendly_id :number, slug_column: :number, use: :slugged
+
     include Spree::Payment::Processing
+    include Spree::NumberGenerator
+
+    def generate_number(options = {})
+      options[:prefix] ||= 'P'
+      options[:letters] ||= true
+      options[:length] ||= 7
+      super(options)
+    end
 
-    IDENTIFIER_CHARS    = (('A'..'Z').to_a + ('0'..'9').to_a - %w(0 1 I O)).freeze
     NON_RISKY_AVS_CODES = ['B', 'D', 'H', 'J', 'M', 'Q', 'T', 'V', 'X', 'Y'].freeze
     RISKY_AVS_CODES     = ['A', 'C', 'E', 'F', 'G', 'I', 'K', 'L', 'N', 'O', 'P', 'R', 'S', 'U', 'W', 'Z'].freeze
 
@@ -13,12 +23,10 @@ module Spree
     has_many :offsets, -> { offset_payment }, class_name: "Spree::Payment", foreign_key: :source_id
     has_many :log_entries, as: :source
     has_many :state_changes, as: :stateful
-    has_many :capture_events, :class_name => 'Spree::PaymentCaptureEvent'
+    has_many :capture_events, class_name: 'Spree::PaymentCaptureEvent'
     has_many :refunds, inverse_of: :payment
 
-    validates_presence_of :payment_method
     before_validation :validate_source
-    before_create :set_unique_identifier
 
     after_save :create_payment_profile, if: :profiles_supported?
 
@@ -34,7 +42,7 @@ module Spree
 
     validates :amount, numericality: true
 
-    default_scope -> { order("#{self.table_name}.created_at") }
+    default_scope { order("#{self.table_name}.created_at") }
 
     scope :from_credit_card, -> { where(source_type: 'Spree::CreditCard') }
     scope :with_state, ->(s) { where(state: s.to_s) }
@@ -165,10 +173,6 @@ module Spree
       amount - captured_amount
     end
 
-    def editable?
-      checkout? || pending?
-    end
-
     private
 
       def validate_source
@@ -236,19 +240,5 @@ module Spree
         end
       end
 
-      # Necessary because some payment gateways will refuse payments with
-      # duplicate IDs. We *were* using the Order number, but that's set once and
-      # is unchanging. What we need is a unique identifier on a per-payment basis,
-      # and this is it. Related to #1998.
-      # See https://github.com/spree/spree/issues/1998#issuecomment-12869105
-      def set_unique_identifier
-        begin
-          self.identifier = generate_identifier
-        end while self.class.exists?(identifier: self.identifier)
-      end
-
-      def generate_identifier
-        Array.new(8){ IDENTIFIER_CHARS.sample }.join
-      end
   end
 end

data/app/models/spree/payment/gateway_options.rb

@@ -0,0 +1,86 @@
+module Spree
+  class Payment
+    class GatewayOptions
+      def initialize(payment)
+        @payment = payment
+      end
+
+      def email
+        order.email
+      end
+
+      def customer
+        order.email
+      end
+
+      def customer_id
+        order.user_id
+      end
+
+      def ip
+        order.last_ip_address
+      end
+
+      def order_id
+        "#{order.number}-#{@payment.number}"
+      end
+
+      def shipping
+        order.ship_total * 100
+      end
+
+      def tax
+        order.additional_tax_total * 100
+      end
+
+      def subtotal
+        order.item_total * 100
+      end
+
+      def discount
+        order.promo_total * 100
+      end
+
+      def currency
+        @payment.currency
+      end
+
+      def billing_address
+        order.bill_address.try(:active_merchant_hash)
+      end
+
+      def shipping_address
+        order.ship_address.try(:active_merchant_hash)
+      end
+
+      def hash_methods
+        [
+          :email,
+          :customer,
+          :customer_id,
+          :ip,
+          :order_id,
+          :shipping,
+          :tax,
+          :subtotal,
+          :discount,
+          :currency,
+          :billing_address,
+          :shipping_address
+        ]
+      end
+
+      def to_hash
+        Hash[hash_methods.map do |method|
+          [method, send(method)]
+        end]
+      end
+
+      private
+
+      def order
+        @payment.order
+      end
+    end
+  end
+end

data/app/models/spree/payment/processing.rb

@@ -1,6 +1,12 @@
 module Spree
   class Payment < Spree::Base
     module Processing
+      extend ActiveSupport::Concern
+      included do
+        class_attribute :gateway_options_class
+        self.gateway_options_class = Spree::Payment::GatewayOptions
+      end
+
       def process!
         if payment_method && payment_method.auto_capture?
           purchase!
@@ -26,7 +32,6 @@ module Spree
         amount ||= money.money.cents
         started_processing!
         protect_from_connection_error do
-          check_environment
           # Standard ActiveMerchant capture usage
           response = payment_method.capture(
             amount,
@@ -43,7 +48,6 @@ module Spree
       def void_transaction!
         return true if void?
         protect_from_connection_error do
-          check_environment
 
           if payment_method.payment_profiles_supported?
             # Gateways supporting payment profiles will need access to credit card object because this stores the payment profile information
@@ -65,32 +69,12 @@ module Spree
       end
 
       def cancel!
-        response = payment_method.cancel(response_code)
-        handle_response(response, :void, :failure)
+        payment_method.cancel(response_code)
       end
 
       def gateway_options
         order.reload
-        options = { :email       => order.email,
-                    :customer    => order.email,
-                    :customer_id => order.user_id,
-                    :ip          => order.last_ip_address,
-                    # Need to pass in a unique identifier here to make some
-                    # payment gateways happy.
-                    #
-                    # For more information, please see Spree::Payment#set_unique_identifier
-                    :order_id    => gateway_order_id }
-
-        options.merge!({ :shipping => order.ship_total * 100,
-                         :tax      => order.additional_tax_total * 100,
-                         :subtotal => order.item_total * 100,
-                         :discount => order.promo_total * 100,
-                         :currency => currency })
-
-        options.merge!({ :billing_address  => order.bill_address.try(:active_merchant_hash),
-                        :shipping_address => order.ship_address.try(:active_merchant_hash) })
-
-        options
+        gateway_options_class.new(self).to_hash
       end
 
       private
@@ -130,8 +114,6 @@ module Spree
 
       def gateway_action(source, action, success_state)
         protect_from_connection_error do
-          check_environment
-
           response = payment_method.send(action, money.money.cents,
                                          source,
                                          gateway_options)
@@ -184,19 +166,6 @@ module Spree
         raise Core::GatewayError.new(text)
       end
 
-      # Saftey check to make sure we're not accidentally performing operations on a live gateway.
-      # Ex. When testing in staging environment with a copy of production data.
-      def check_environment
-        return if payment_method.environment == Rails.env
-        message = Spree.t(:gateway_config_unavailable) + " - #{Rails.env}"
-        raise Core::GatewayError.new(message)
-      end
-
-      # The unique identifier to be passed in to the payment gateway
-      def gateway_order_id
-        "#{order.number}-#{self.identifier}"
-      end
-
       def token_based?
         source.gateway_customer_profile_id.present? || source.gateway_payment_profile_id.present?
       end

data/app/models/spree/payment_method.rb

@@ -2,9 +2,7 @@ module Spree
   class PaymentMethod < Spree::Base
     acts_as_paranoid
     DISPLAY = [:both, :front_end, :back_end]
-    default_scope -> { where(deleted_at: nil) }
-
-    scope :production, -> { where(environment: 'production') }
+    default_scope { where(deleted_at: nil) }
 
     validates :name, presence: true
 
@@ -29,13 +27,12 @@ module Spree
     def self.available(display_on = 'both')
       all.select do |p|
         p.active &&
-        (p.display_on == display_on.to_s || p.display_on.blank?) &&
-        (p.environment == Rails.env || p.environment.blank?)
+        (p.display_on == display_on.to_s || p.display_on.blank?)
       end
     end
 
     def self.active?
-      where(type: self.to_s, environment: Rails.env, active: true).count > 0
+      where(type: self.to_s, active: true).count > 0
     end
 
     def method_type

data/app/models/spree/price.rb

@@ -7,12 +7,8 @@ module Spree
     validates :amount, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
     validate :validate_amount_maximum
 
-    def display_amount
-      money
-    end
-    alias :display_price :display_amount
-
-    self.whitelisted_ransackable_attributes = ['amount']
+    extend DisplayMoney
+    money_methods :amount, :price
 
     def money
       Spree::Money.new(amount || 0, { currency: currency })

data/app/models/spree/product.rb

@@ -74,7 +74,6 @@ module Spree
     after_create :build_variants_from_option_values_hash, if: :option_values_hash
 
     after_destroy :punch_slug
-    after_restore :update_slug_history
 
     after_initialize :ensure_master
 
@@ -99,9 +98,6 @@ module Spree
 
     alias :options :product_option_types
 
-    self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
-    self.whitelisted_ransackable_attributes = %w[slug]
-
     # the master variant is not a member of the variants array
     def has_variants?
       variants.any?
@@ -267,12 +263,7 @@ module Spree
     end
 
     def punch_slug
-      # punch slug with date prefix to allow reuse of original
-      update_column :slug, "#{Time.now.to_i}_#{slug}"[0..254] unless frozen?
-    end
-
-    def update_slug_history
-      self.save!
+      update_column :slug, "#{Time.now.to_i}_#{slug}" # punch slug with date prefix to allow reuse of original
     end
 
     def anything_changed?
@@ -283,11 +274,25 @@ module Spree
       @nested_changes = false
     end
 
+    def master_updated?
+      master && (
+        master.new_record? ||
+        master.changed? ||
+        (
+          master.default_price &&
+          (
+            master.default_price.new_record? ||
+            master.default_price.changed?
+          )
+        )
+      )
+    end
+
     # there's a weird quirk with the delegate stuff that does not automatically save the delegate object
     # when saving so we force a save using a hook
     # Fix for issue #5306
     def save_master
-      if master && (master.changed? || master.new_record? || (master.default_price && (master.default_price.changed? || master.default_price.new_record?)))
+      if master_updated?
         master.save!
         @nested_changes = true
       end
@@ -322,13 +327,19 @@ module Spree
       run_callbacks(:touch)
     end
 
+    def taxon_and_ancestors
+      taxons.map(&:self_and_ancestors).flatten.uniq
+    end
+
+    # Get the taxonomy ids of all taxons assigned to this product and their ancestors.
+    def taxonomy_ids
+      taxon_and_ancestors.map(&:taxonomy_id).flatten.uniq
+    end
+
     # Iterate through this products taxons and taxonomies and touch their timestamps in a batch
     def touch_taxons
-      taxons_to_touch = taxons.map(&:self_and_ancestors).flatten.uniq
-      Spree::Taxon.where(id: taxons_to_touch.map(&:id)).update_all(updated_at: Time.current)
-
-      taxonomy_ids_to_touch = taxons_to_touch.map(&:taxonomy_id).flatten.uniq
-      Spree::Taxonomy.where(id: taxonomy_ids_to_touch).update_all(updated_at: Time.current)
+      Spree::Taxon.where(id: taxon_and_ancestors.map(&:id)).update_all(updated_at: Time.current)
+      Spree::Taxonomy.where(id: taxonomy_ids).update_all(updated_at: Time.current)
     end
 
   end