solidus_core 2.2.2 → 2.3.0.beta1

data/app/models/spree/order.rb

@@ -1,5 +1,6 @@
 require 'spree/core/validators/email'
 require 'spree/order/checkout'
+require 'spree/order/number_generator'
 
 module Spree
   # The customers cart until completed, then acts as permanent record of the transaction.
@@ -298,25 +299,15 @@ module Spree
       assign_attributes(attrs_to_set)
     end
 
-    def generate_order_number(options = {})
-      options[:length]  ||= ORDER_NUMBER_LENGTH
-      options[:letters] ||= ORDER_NUMBER_LETTERS
-      options[:prefix]  ||= ORDER_NUMBER_PREFIX
-
-      possible = (0..9).to_a
-      possible += ('A'..'Z').to_a if options[:letters]
-
-      self.number ||= loop do
-        # Make a random number.
-        random = "#{options[:prefix]}#{(0...options[:length]).map { possible.sample }.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.
-          options[:length] += 1 if self.class.count > (10**options[:length] / 2)
-        else
-          break random
-        end
+    def generate_order_number(options = nil)
+      if options
+        Spree::Deprecation.warn \
+          "Passing options to Order#generate_order_number is deprecated. " \
+          "Please add your own instance of the order number generator " \
+          "with your options (#{options.inspect}) and store it as " \
+          "Spree::Config.order_number_generator in your stores config."
       end
+      self.number ||= Spree::Config.order_number_generator.generate
     end
 
     def shipped_shipments
@@ -364,15 +355,18 @@ module Spree
     end
     deprecate create_tax_charge!: :update!, deprecator: Spree::Deprecation
 
+    def reimbursement_total
+      reimbursements.sum(:total)
+    end
+
     def outstanding_balance
       # If reimbursement has happened add it back to total to prevent balance_due payment state
       # See: https://github.com/spree/spree/issues/6229
-      adjusted_payment_total = payment_total + refund_total
 
       if state == 'canceled'
-        -1 * adjusted_payment_total
+        -1 * payment_total
       else
-        total - adjusted_payment_total
+        total - reimbursement_total - payment_total
       end
     end
 
@@ -475,6 +469,7 @@ module Spree
       line_items.destroy_all
       adjustments.destroy_all
       shipments.destroy_all
+      order_promotions.destroy_all
 
       update!
     end
@@ -497,6 +492,7 @@ module Spree
         end
       end
     end
+    deprecate :state_changed, deprecator: Spree::Deprecation
 
     def coupon_code=(code)
       @coupon_code = begin
@@ -696,16 +692,26 @@ module Spree
       self.ship_address = Spree::Address.immutable_merge(ship_address, attributes)
     end
 
-    def assign_default_addresses!
+    # Assigns a default bill_address and ship_address to the order based on the
+    # associated user's bill_address and ship_address.
+    # @note This doesn't persist the change bill_address or ship_address
+    def assign_default_user_addresses
       if user
+        bill_address = (user.bill_address || user.default_address)
+        ship_address = (user.ship_address || user.default_address)
         # this is one of 2 places still using User#bill_address
-        self.bill_address ||= user.bill_address if user.bill_address.try!(:valid?)
+        self.bill_address ||= bill_address if 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 if user.ship_address.try!(:valid?) && checkout_steps.include?("delivery")
+        self.ship_address ||= ship_address if ship_address.try!(:valid?) && checkout_steps.include?("delivery")
       end
     end
 
+    alias_method :assign_default_user_addresses!, :assign_default_user_addresses
+    deprecate assign_default_user_addresses!: :assign_default_user_addresses, deprecator: Spree::Deprecation
+    alias_method :assign_default_addresses!, :assign_default_user_addresses
+    deprecate assign_default_addresses!: :assign_default_user_addresses, deprecator: Spree::Deprecation
+
     def persist_user_address!
       if !temporary_address && user && user.respond_to?(:persist_order_address) && bill_address_id
         user.persist_order_address(self)
@@ -736,20 +742,9 @@ module Spree
     alias_method :assign_default_credit_card, :add_default_payment_from_wallet
     deprecate assign_default_credit_card: :add_default_payment_from_wallet, deprecator: Spree::Deprecation
 
-    def payments_attributes=(attributes)
-      validate_payments_attributes(attributes)
-      super(attributes)
-    end
-
-    def validate_payments_attributes(attributes)
-      attributes = Array.wrap(attributes)
-      # Ensure the payment methods specified are allowed for this user
-      payment_methods = Spree::PaymentMethod.where(id: available_payment_methods)
-      attributes.each do |payment_attributes|
-        payment_method_id = payment_attributes[:payment_method_id]
-
-        # raise RecordNotFound unless it is an allowed payment method
-        payment_methods.find(payment_method_id) if payment_method_id
+    def record_ip_address(ip_address)
+      if last_ip_address != ip_address
+        update_attributes!(last_ip_address: ip_address)
       end
     end
 

data/app/models/spree/order_contents.rb

@@ -112,7 +112,7 @@ module Spree
       line_item.quantity -= quantity
       line_item.target_shipment = options[:shipment]
 
-      if line_item.quantity == 0
+      if line_item.quantity <= 0
         order.line_items.destroy(line_item)
       else
         line_item.save!

data/app/models/spree/order_taxation.rb

@@ -0,0 +1,79 @@
+module Spree
+  # Relatively simple class used to apply a {Spree::Tax::OrderTax} to a
+  # {Spree::Order}.
+  #
+  # This class will create or update adjustments on the taxed items and remove
+  # any now inapplicable tax adjustments from the order.
+  class OrderTaxation
+    # Create a new order taxation.
+    #
+    # @param [Spree::Order] order the order to apply taxes to
+    # @return [Spree::OrderTaxation] a {Spree::OrderTaxation} object
+    def initialize(order)
+      @order = order
+    end
+
+    # Apply taxes to the order.
+    #
+    # This method will create or update adjustments on all line items and
+    # shipments in the order to reflect the appropriate taxes passed in. It
+    # will also remove any now inapplicable tax adjustments.
+    #
+    # @param [Spree::Tax::OrderTax] taxes the taxes to apply to the order
+    # @return [void]
+    def apply(taxes)
+      @order.line_items.each do |item|
+        taxed_items = taxes.line_item_taxes.select { |i| i.item_id == item.id }
+        update_adjustments(item, taxed_items)
+      end
+
+      @order.shipments.each do |item|
+        taxed_items = taxes.shipment_taxes.select { |i| i.item_id == item.id }
+        update_adjustments(item, taxed_items)
+      end
+    end
+
+    private
+
+    # Walk through the taxes for an item and update adjustments for it. Once
+    # all of the taxes have been added as adjustments, remove any old tax
+    # adjustments that weren't touched.
+    #
+    # @private
+    # @param [#adjustments] item a {Spree::LineItem} or {Spree::Shipment}
+    # @param [Array<Spree::Tax::ItemTax>] taxed_items a list of calculated taxes for an item
+    # @return [void]
+    def update_adjustments(item, taxed_items)
+      tax_adjustments = item.adjustments.select(&:tax?)
+
+      active_adjustments = taxed_items.map do |tax_item|
+        update_adjustment(item, tax_item)
+      end
+
+      # Remove any tax adjustments tied to rates which no longer match.
+      unmatched_adjustments = tax_adjustments - active_adjustments
+      item.adjustments.destroy(unmatched_adjustments)
+    end
+
+    # Update or create a new tax adjustment on an item.
+    #
+    # @private
+    # @param [#adjustments] item a {Spree::LineItem} or {Spree::Shipment}
+    # @param [Spree::Tax::ItemTax] tax_item calculated taxes for an item
+    # @return [Spree::Adjustment] the created or updated tax adjustment
+    def update_adjustment(item, tax_item)
+      tax_adjustment = item.adjustments.detect do |adjustment|
+        adjustment.source == tax_item.tax_rate
+      end
+
+      tax_adjustment ||= item.adjustments.new(
+        source: tax_item.tax_rate,
+        order_id: item.order_id,
+        label: tax_item.label,
+        included: tax_item.included_in_price
+      )
+      tax_adjustment.update_attributes!(amount: tax_item.amount)
+      tax_adjustment
+    end
+  end
+end

data/app/models/spree/order_update_attributes.rb

@@ -14,8 +14,6 @@ module Spree
     # Assign the attributes to the order and save the order
     # @return true if saved, otherwise false and errors will be set on the order
     def apply
-      order.validate_payments_attributes(@payments_attributes)
-
       assign_order_attributes
       assign_payments_attributes
 

data/app/models/spree/order_updater.rb

@@ -44,26 +44,10 @@ module Spree
     #
     # The +shipment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
     def update_shipment_state
-      if order.backordered?
-        order.shipment_state = 'backorder'
-      else
-        # get all the shipment states for this order
-        shipment_states = shipments.states
-        if shipment_states.size > 1
-          # multiple shiment states means it's most likely partially shipped
-          order.shipment_state = 'partial'
-        else
-          # will return nil if no shipments are found
-          order.shipment_state = shipment_states.first
-          # TODO: inventory unit states?
-          # if order.shipment_state && order.inventory_units.where(:shipment_id => nil).exists?
-          #   shipments exist but there are unassigned inventory units
-          #   order.shipment_state = 'partial'
-          # end
-        end
+      log_state_change('shipment') do
+        order.shipment_state = determine_shipment_state
       end
 
-      order.state_changed('shipment')
       order.shipment_state
     end
 
@@ -76,22 +60,46 @@ module Spree
     #
     # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
     def update_payment_state
-      last_state = order.payment_state
-      if payments.present? && payments.valid.size == 0 && order.outstanding_balance != 0
-        order.payment_state = 'failed'
-      elsif order.state == 'canceled' && order.payment_total == 0
-        order.payment_state = 'void'
-      else
-        order.payment_state = 'balance_due' if order.outstanding_balance > 0
-        order.payment_state = 'credit_owed' if order.outstanding_balance < 0
-        order.payment_state = 'paid' if !order.outstanding_balance?
+      log_state_change('payment') do
+        order.payment_state = determine_payment_state
       end
-      order.state_changed('payment') if last_state != order.payment_state
+
       order.payment_state
     end
 
     private
 
+    def determine_payment_state
+      if payments.present? && payments.valid.empty? && order.outstanding_balance != 0
+        'failed'
+      elsif order.state == 'canceled' && order.payment_total.zero?
+        'void'
+      elsif order.outstanding_balance > 0
+        'balance_due'
+      elsif order.outstanding_balance < 0
+        'credit_owed'
+      else
+        # outstanding_balance == 0
+        'paid'
+      end
+    end
+
+    def determine_shipment_state
+      if order.backordered?
+        'backorder'
+      else
+        # get all the shipment states for this order
+        shipment_states = shipments.states
+        if shipment_states.size > 1
+          # multiple shiment states means it's most likely partially shipped
+          'partial'
+        else
+          # will return nil if no shipments are found
+          shipment_states.first
+        end
+      end
+    end
+
     # This will update and select the best promotion adjustment, update tax
     # adjustments, update cancellation adjustments, and then update the total
     # fields (promo_total, included_tax_total, additional_tax_total, and
@@ -177,6 +185,21 @@ module Spree
       order.save!(validate: false)
     end
 
+    def log_state_change(name)
+      state = "#{name}_state"
+      old_state = order.public_send(state)
+      yield
+      new_state = order.public_send(state)
+      if old_state != new_state
+        order.state_changes.new(
+          previous_state: old_state,
+          next_state:     new_state,
+          name:           name,
+          user_id:        order.user_id
+        )
+      end
+    end
+
     def round_money(n)
       (n * 100).round / 100.0
     end
@@ -229,11 +252,10 @@ module Spree
       [*line_items, *shipments].each do |item|
         # The cancellation_total isn't persisted anywhere but is included in
         # the adjustment_total
-        item_cancellation_total = item.adjustments.select(&:cancellation?).sum(&:amount)
-
-        item.adjustment_total = item.promo_total +
-                                item.additional_tax_total +
-                                item_cancellation_total
+        item.adjustment_total = item.adjustments.
+          select(&:eligible?).
+          reject(&:included?).
+          sum(&:amount)
 
         if item.changed?
           item.update_columns(

data/app/models/spree/payment.rb

@@ -40,7 +40,6 @@ module Spree
 
     validates :amount, numericality: true
     validates :source, presence: true, if: :source_required?
-    validates :payment_method, presence: true
 
     default_scope -> { order(:created_at) }
 

data/app/models/spree/payment_method/bogus_credit_card.rb

@@ -0,0 +1,87 @@
+module Spree
+  class PaymentMethod::BogusCreditCard < PaymentMethod::CreditCard
+    TEST_VISA = ['4111111111111111', '4012888888881881', '4222222222222']
+    TEST_MC   = ['5500000000000004', '5555555555554444', '5105105105105100']
+    TEST_AMEX = ['378282246310005', '371449635398431', '378734493671000', '340000000000009']
+    TEST_DISC = ['6011000000000004', '6011111111111117', '6011000990139424']
+
+    VALID_CCS = ['1', TEST_VISA, TEST_MC, TEST_AMEX, TEST_DISC].flatten
+
+    attr_accessor :test
+
+    def gateway_class
+      self.class
+    end
+
+    def create_profile(payment)
+      return if payment.source.has_payment_profile?
+      # simulate the storage of credit card profile using remote service
+      if success = VALID_CCS.include?(payment.source.number)
+        payment.source.update_attributes(gateway_customer_profile_id: generate_profile_id(success))
+      end
+    end
+
+    def authorize(_money, credit_card, _options = {})
+      profile_id = credit_card.gateway_customer_profile_id
+      if VALID_CCS.include?(credit_card.number) || (profile_id && profile_id.starts_with?('BGS-'))
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'D' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
+      end
+    end
+
+    def purchase(_money, credit_card, _options = {})
+      profile_id = credit_card.gateway_customer_profile_id
+      if VALID_CCS.include?(credit_card.number) || (profile_id && profile_id.starts_with?('BGS-'))
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'M' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
+      end
+    end
+
+    def credit(_money, _credit_card, _response_code, _options = {})
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
+    end
+
+    def capture(_money, authorization, _gateway_options)
+      if authorization == '12345'
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true)
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', error: 'Bogus Gateway: Forced failure', test: true)
+      end
+    end
+
+    def void(_response_code, _credit_card, _options = {})
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
+    end
+
+    def cancel(_response_code)
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
+    end
+
+    def test?
+      # Test mode is not really relevant with bogus gateway (no such thing as live server)
+      true
+    end
+
+    def payment_profiles_supported?
+      true
+    end
+
+    def actions
+      %w(capture void credit)
+    end
+
+    private
+
+    def generate_profile_id(success)
+      record = true
+      prefix = success ? 'BGS' : 'FAIL'
+      while record
+        random = "#{prefix}-#{Array.new(6){ rand(6) }.join}"
+        record = Spree::CreditCard.where(gateway_customer_profile_id: random).first
+      end
+      random
+    end
+  end
+end

data/app/models/spree/payment_method/check.rb

@@ -1,7 +1,7 @@
 module Spree
   class PaymentMethod::Check < PaymentMethod
     def actions
-      %w{capture void}
+      %w{capture void credit}
     end
 
     # Indicates whether its possible to capture the payment
@@ -14,18 +14,26 @@ module Spree
       payment.state != 'void'
     end
 
-    def capture(*_args)
-      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+    def capture(*)
+      simulated_successful_billing_response
     end
 
-    def cancel(response); end
+    def cancel(*); end
 
-    def void(*_args)
-      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+    def void(*)
+      simulated_successful_billing_response
+    end
+
+    def credit(*)
+      simulated_successful_billing_response
     end
 
     def source_required?
       false
     end
+
+    def simulated_successful_billing_response
+      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+    end
   end
 end

data/app/models/spree/payment_method/credit_card.rb

@@ -0,0 +1,41 @@
+module Spree
+  # An implementation of a `Spree::PaymentMethod` for credit card payments.
+  #
+  # It's a good candidate as base class for other credit card based payment methods.
+  #
+  # See https://github.com/solidusio/solidus_gateway/ for
+  # officially supported payment method implementations.
+  #
+  class PaymentMethod::CreditCard < PaymentMethod
+    def payment_source_class
+      CreditCard
+    end
+
+    def partial_name
+      'gateway'
+    end
+
+    def supports?(source)
+      return true unless gateway_class.respond_to? :supports?
+      return true if source.brand && gateway_class.supports?(source.brand)
+      source.has_payment_profile?
+    end
+
+    def reusable_sources_by_order(order)
+      source_ids = order.payments.where(payment_method_id: id).pluck(:source_id).uniq
+      payment_source_class.where(id: source_ids).select(&:reusable?)
+    end
+    alias_method :sources_by_order, :reusable_sources_by_order
+    deprecate sources_by_order: :reusable_sources_by_order, deprecator: Spree::Deprecation
+
+    def reusable_sources(order)
+      if order.completed?
+        reusable_sources_by_order(order)
+      elsif order.user_id
+        order.user.wallet.wallet_payment_sources.map(&:payment_source).select(&:reusable?)
+      else
+        []
+      end
+    end
+  end
+end

data/app/models/spree/payment_method/simple_bogus_credit_card.rb

@@ -0,0 +1,24 @@
+module Spree
+  # Bogus Gateway that doesn't support payment profiles.
+  class PaymentMethod::SimpleBogusCreditCard < PaymentMethod::BogusCreditCard
+    def payment_profiles_supported?
+      false
+    end
+
+    def authorize(_money, credit_card, _options = {})
+      if VALID_CCS.include? credit_card.number
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
+      end
+    end
+
+    def purchase(_money, credit_card, _options = {})
+      if VALID_CCS.include? credit_card.number
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
+      end
+    end
+  end
+end

data/app/models/spree/payment_method/store_credit.rb

@@ -4,19 +4,11 @@ module Spree
       ::Spree::StoreCredit
     end
 
-    def can_capture?(payment)
-      ['checkout', 'pending'].include?(payment.state)
-    end
-
-    def can_void?(payment)
-      payment.pending?
-    end
-
     def authorize(amount_in_cents, provided_store_credit, gateway_options = {})
       if provided_store_credit.nil?
         ActiveMerchant::Billing::Response.new(false, Spree.t('store_credit.unable_to_find'), {}, {})
       else
-        action = -> (store_credit) {
+        action = ->(store_credit) {
           store_credit.authorize(
             amount_in_cents / 100.0.to_d,
             gateway_options[:currency],
@@ -28,7 +20,7 @@ module Spree
     end
 
     def capture(amount_in_cents, auth_code, gateway_options = {})
-      action = -> (store_credit) {
+      action = ->(store_credit) {
         store_credit.capture(
           amount_in_cents / 100.0.to_d,
           auth_code,
@@ -55,14 +47,14 @@ module Spree
     end
 
     def void(auth_code, gateway_options = {})
-      action = -> (store_credit) {
+      action = ->(store_credit) {
         store_credit.void(auth_code, action_originator: gateway_options[:originator])
       }
       handle_action(action, :void, auth_code)
     end
 
     def credit(amount_in_cents, auth_code, gateway_options = {})
-      action = -> (store_credit) do
+      action = ->(store_credit) do
         currency = gateway_options[:currency] || store_credit.currency
         originator = gateway_options[:originator]
 
@@ -109,7 +101,7 @@ module Spree
 
     def handle_action(action, action_name, auth_code)
       # Find first event with provided auth_code
-      store_credit = Spree::StoreCreditEvent.find_by_authorization_code(auth_code).try(:store_credit)
+      store_credit = Spree::StoreCreditEvent.find_by(authorization_code: auth_code).try(:store_credit)
 
       if store_credit.nil?
         ActiveMerchant::Billing::Response.new(false, Spree.t('store_credit.unable_to_find_for_action', auth_code: auth_code, action: action_name), {}, {})