spree_core 4.8.3 → 4.10.0

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

@@ -0,0 +1,15 @@
+module Spree
+  class Payment < Spree::Base
+    module Webhooks
+      extend ActiveSupport::Concern
+
+      def send_payment_voided_webhook
+        # Implement your logic here
+      end
+
+      def send_payment_completed_webhook
+        # Implement your logic here
+      end
+    end
+  end
+end

data/app/models/spree/payment.rb

@@ -6,14 +6,12 @@ module Spree
     include Spree::NumberIdentifier
     include Spree::NumberAsParam
     include Spree::Metadata
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
     if defined?(Spree::Security::Payments)
       include Spree::Security::Payments
     end
 
     include Spree::Payment::Processing
+    include Spree::Payment::Webhooks
 
     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
@@ -67,6 +65,8 @@ module Spree
     scope :processing, -> { with_state('processing') }
     scope :failed, -> { with_state('failed') }
 
+    scope :incomplete, -> { where.not(state: 'completed') }
+
     scope :risky, -> { where("avs_response IN (?) OR (cvv_response_code IS NOT NULL and cvv_response_code != 'M') OR state = 'failed'", RISKY_AVS_CODES) }
     scope :valid, -> { where.not(state: INVALID_STATES) }
 
@@ -105,11 +105,11 @@ module Spree
       event :complete do
         transition from: [:processing, :pending, :checkout], to: :completed
       end
-      after_transition to: :completed, do: :after_completed
+      after_transition to: :completed, do: [:after_completed, :send_payment_completed_webhook]
       event :void do
         transition from: [:pending, :processing, :completed, :checkout], to: :void
       end
-      after_transition to: :void, do: :after_void
+      after_transition to: :void, do: [:after_void, :send_payment_voided_webhook]
       # when the card brand isn't supported
       event :invalidate do
         transition from: [:checkout], to: :invalid
@@ -209,11 +209,11 @@ module Spree
     private
 
     def after_void
-      # this method is prepended in api/ to queue Webhooks requests
+      # Implement your logic here
     end
 
     def after_completed
-      # this method is prepended in api/ to queue Webhooks requests
+      # Implement your logic here
     end
 
     def has_invalid_state?

data/app/models/spree/price.rb

@@ -12,17 +12,29 @@ module Spree
     belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', inverse_of: :prices, touch: true
 
     before_validation :ensure_currency
+    before_save :remove_compare_at_amount_if_equals_amount
 
+    # legacy behavior
     validates :amount, allow_nil: true, numericality: {
       greater_than_or_equal_to: 0,
       less_than_or_equal_to: MAXIMUM_AMOUNT
-    }
+    }, if: -> { Spree::RuntimeConfig.allow_empty_price_amount }
+
+    # new behavior
+    validates :amount, allow_nil: false, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: MAXIMUM_AMOUNT
+    }, unless: -> { Spree::RuntimeConfig.allow_empty_price_amount }
 
     validates :compare_at_amount, allow_nil: true, numericality: {
       greater_than_or_equal_to: 0,
       less_than_or_equal_to: MAXIMUM_AMOUNT
     }
 
+    scope :with_currency, ->(currency) { where(currency: currency) }
+    scope :non_zero, -> { where.not(amount: [nil, 0]) }
+    scope :discounted, -> { where('compare_at_amount > amount') }
+
     extend DisplayMoney
     money_methods :amount, :price, :compare_at_amount
     alias display_compare_at_price display_compare_at_amount
@@ -68,10 +80,50 @@ module Spree
       Spree::Money.new(compare_at_price_including_vat_for(price_options), currency: currency)
     end
 
+    # returns the name of the price in a format of variant name and currency
+    #
+    # @return [String]
+    def name
+      "#{variant.name} - #{currency.upcase}"
+    end
+
+    # returns true if the price is discounted
+    #
+    # @return [Boolean]
+    def discounted?
+      compare_at_amount.to_i.positive? && compare_at_amount > amount
+    end
+
+    # returns true if the price was discounted
+    #
+    # @return [Boolean]
+    def was_discounted?
+      compare_at_amount_was.to_i.positive? && compare_at_amount_was > amount_was
+    end
+
+    # returns true if the price is zero
+    #
+    # @return [Boolean]
+    def zero?
+      amount.nil? || amount.zero?
+    end
+
+    # returns true if the price is not zero
+    #
+    # @return [Boolean]
+    def non_zero?
+      !zero?
+    end
+
     private
 
     def ensure_currency
       self.currency ||= Spree::Store.default.default_currency
     end
+
+    # removes the compare at amount if it is the same as the amount
+    def remove_compare_at_amount_if_equals_amount
+      self.compare_at_amount = nil if compare_at_amount == amount
+    end
   end
 end

data/app/models/spree/product/webhooks.rb

@@ -0,0 +1,17 @@
+module Spree
+  class Product < Spree::Base
+    module Webhooks
+      def send_product_activated_webhook
+        # Implement your logic here
+      end
+
+      def send_product_archived_webhook
+        # Implement your logic here
+      end
+
+      def send_product_drafted_webhook
+        # Implement your logic here
+      end
+    end
+  end
+end

data/app/models/spree/product.rb

@@ -27,9 +27,7 @@ module Spree
     include Spree::TranslatableResourceSlug
     include Spree::MemoizedData
     include Spree::Metadata
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
+    include Spree::Product::Webhooks
     if defined?(Spree::VendorConcern)
       include Spree::VendorConcern
     end
@@ -181,17 +179,17 @@ module Spree
       event :activate do
         transition to: :active
       end
-      after_transition to: :active, do: :after_activate
+      after_transition to: :active, do: [:after_activate, :send_product_activated_webhook]
 
       event :archive do
         transition to: :archived
       end
-      after_transition to: :archived, do: :after_archive
+      after_transition to: :archived, do: [:after_archive, :send_product_archived_webhook]
 
       event :draft do
         transition to: :draft
       end
-      after_transition to: :draft, do: :after_draft
+      after_transition to: :draft, do: [:after_draft, :send_product_drafted_webhook]
     end
 
     # Can't use short form block syntax due to https://github.com/Netflix/fast_jsonapi/issues/259
@@ -584,15 +582,15 @@ module Spree
     end
 
     def after_activate
-      # this method is prepended in api/ to queue Webhooks requests
+      # Implement your logic here
     end
 
     def after_archive
-      # this method is prepended in api/ to queue Webhooks requests
+      # Implement your logic here
     end
 
     def after_draft
-      # this method is prepended in api/ to queue Webhooks requests
+      # Implement your logic here
     end
   end
 end

data/app/models/spree/promotion/actions/free_shipping.rb

@@ -13,6 +13,19 @@ module Spree
         def compute_amount(shipment)
           shipment.cost * -1
         end
+
+        # we need to persist 0 amount adjustment
+        def create_adjustment(order, adjustable, included = false)
+          amount = compute_amount(adjustable)
+
+          adjustments.new(
+            adjustable: adjustable,
+            amount: amount,
+            included: included,
+            label: label,
+            order: order
+          ).save
+        end
       end
     end
   end

data/app/models/spree/promotion/rules/first_order.rb

@@ -10,7 +10,12 @@ module Spree
 
         def eligible?(order, options = {})
           @user = order.try(:user) || options[:user]
-          @email = order.email
+          @email = if options[:email].present?
+                     order.email = options[:email]
+                     order.email
+                   elsif order.email.present?
+                     order.email
+                   end
           @store = order.store
 
           if user || email

data/app/models/spree/promotion.rb

@@ -128,10 +128,10 @@ module Spree
     end
 
     # called anytime order.update_with_updater! happens
-    def eligible?(promotable)
+    def eligible?(promotable, options = {})
       return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable)
 
-      !!eligible_rules(promotable, {})
+      !!eligible_rules(promotable, options)
     end
 
     # eligible_rules returns an array of promotion rules where eligible? is true for the promotable

data/app/models/spree/promotion_handler/coupon.rb

@@ -1,12 +1,13 @@
 module Spree
   module PromotionHandler
     class Coupon
-      attr_reader :order, :store
+      attr_reader :order, :store, :options
       attr_accessor :error, :success, :status_code
 
-      def initialize(order)
+      def initialize(order, options = {})
         @order = order
         @store = order.store
+        @options = options
       end
 
       def apply

data/app/models/spree/refund.rb

@@ -13,6 +13,7 @@ module Spree
       belongs_to :reimbursement, optional: true
     end
     belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
+    belongs_to :refunder, class_name: "::#{Spree.admin_user_class}", optional: true
 
     has_many :log_entries, as: :source
 
@@ -31,8 +32,10 @@ module Spree
 
     attr_reader :response
 
+    delegate :order, :currency, to: :payment
+
     def money
-      Spree::Money.new(amount, currency: payment.currency)
+      Spree::Money.new(amount, currency: currency)
     end
     alias display_amount money
 
@@ -46,6 +49,15 @@ module Spree
       payment.payment_method.name
     end
 
+    # return items for the refund
+    #
+    # @return [Array<Spree::ReturnItem>]
+    def return_items
+      return [] unless reimbursement.present?
+
+      reimbursement.customer_return&.return_items || reimbursement.return_items
+    end
+
     private
 
     # attempts to perform the refund.
@@ -53,7 +65,7 @@ module Spree
     def perform!
       return true if transaction_id.present?
 
-      credit_cents = Spree::Money.new(amount.to_f, currency: payment.currency).amount_in_cents
+      credit_cents = Spree::Money.new(amount.to_f, currency: currency).amount_in_cents
 
       @response = process!(credit_cents)
 

data/app/models/spree/reimbursement/emails.rb

@@ -0,0 +1,11 @@
+module Spree
+  class Reimbursement < Spree::Base
+    module Emails
+      def send_reimbursement_email
+        # you can overwrite this method in your application / extension to send out the confirmation email
+        # or use `spree_emails` gem
+        # YourEmailVendor.deliver_reimbursement_email(id) # `id` = ID of the Reimbursement being sent, you can also pass the entire object using `self`
+      end
+    end
+  end
+end

data/app/models/spree/reimbursement.rb

@@ -5,6 +5,7 @@ module Spree
     if defined?(Spree::Webhooks::HasWebhooks)
       include Spree::Webhooks::HasWebhooks
     end
+    include Spree::Reimbursement::Emails
 
     class IncompleteReimbursementError < StandardError; end
 
@@ -141,12 +142,6 @@ module Spree
       end
     end
 
-    def send_reimbursement_email
-      # you can overwrite this method in your application / extension to send out the confirmation email
-      # or use `spree_emails` gem
-      # YourEmailVendor.deliver_reimbursement_email(id) # `id` = ID of the Reimbursement being sent, you can also pass the entire object using `self`
-    end
-
     # If there are multiple different reimbursement types for a single
     # reimbursement we open ourselves to a one-cent rounding error for every
     # type over the first one. This is due to how we round #unpaid_amount and

data/app/models/spree/role_user.rb

@@ -1,6 +1,6 @@
 module Spree
   class RoleUser < Spree::Base
     belongs_to :role, class_name: 'Spree::Role'
-    belongs_to :user, class_name: "::#{Spree.user_class}"
+    belongs_to :user, class_name: Spree.admin_user_class.to_s
   end
 end

data/app/models/spree/shipment/emails.rb

@@ -0,0 +1,11 @@
+module Spree
+  class Shipment < Spree::Base
+    module Emails
+      def send_shipped_email
+        # you can overwrite this method in your application / extension to send out the confirmation email
+        # or use `spree_emails` gem
+        # YourEmailVendor.deliver_shipment_notification_email(@shipment.id)
+      end
+    end
+  end
+end

data/app/models/spree/shipment/webhooks.rb

@@ -0,0 +1,11 @@
+module Spree
+  class Shipment < Spree::Base
+    module Webhooks
+      extend ActiveSupport::Concern
+
+      def send_shipment_shipped_webhook
+        # Implement your logic here
+      end
+    end
+  end
+end

data/app/models/spree/shipment.rb

@@ -6,18 +6,20 @@ module Spree
     include Spree::NumberIdentifier
     include Spree::NumberAsParam
     include Spree::Metadata
-    if defined?(Spree::Webhooks::HasWebhooks)
-      include Spree::Webhooks::HasWebhooks
-    end
     if defined?(Spree::Security::Shipments)
       include Spree::Security::Shipments
     end
+    if defined?(Spree::VendorConcern)
+      include Spree::VendorConcern
+    end
+    include Spree::Shipment::Emails
+    include Spree::Shipment::Webhooks
 
     with_options inverse_of: :shipments do
       belongs_to :address, class_name: 'Spree::Address'
       belongs_to :order, class_name: 'Spree::Order', touch: true
     end
-    belongs_to :stock_location, class_name: 'Spree::StockLocation'
+    belongs_to :stock_location, -> { with_deleted }, class_name: 'Spree::StockLocation'
 
     with_options dependent: :delete_all do
       has_many :adjustments, as: :adjustable
@@ -26,6 +28,7 @@ module Spree
       has_many :state_changes, as: :stateful
     end
     has_many :shipping_methods, through: :shipping_rates
+    has_many :variants, through: :inventory_units
     has_one :selected_shipping_rate, -> { where(selected: true).order(:cost) }, class_name: Spree::ShippingRate.to_s
 
     after_save :update_adjustments
@@ -47,8 +50,18 @@ module Spree
     # sort by most recent shipped_at, falling back to created_at. add "id desc" to make specs that involve this scope more deterministic.
     scope :reverse_chronological, -> { order(Arel.sql('coalesce(spree_shipments.shipped_at, spree_shipments.created_at) desc'), id: :desc) }
     scope :valid, -> { where.not(state: :canceled) }
+    scope :canceled, -> { with_state('canceled') }
+    scope :not_canceled, -> { where.not(state: 'canceled') }
+    scope :shipped_but_canceled, -> { canceled.where.not(shipped_at: nil) }
+    # This scope will select the shipping_method_id from the shipments' selected shipping rate
+    scope :with_selected_shipping_method, lambda {
+                                                 joins(:selected_shipping_rate).
+                                                   where(Spree::ShippingRate.arel_table[:shipping_method_id].not_eq(nil)).
+                                                   select(Spree::ShippingRate.arel_table[:shipping_method_id])
+                                               }
 
     delegate :store, :currency, to: :order
+    delegate :amount_in_cents, to: :display_cost
 
     # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
     state_machine initial: :pending, use_transactions: false do
@@ -66,7 +79,7 @@ module Spree
       event :ship do
         transition from: %i(ready canceled), to: :shipped
       end
-      after_transition to: :shipped, do: :after_ship
+      after_transition to: :shipped, do: [:after_ship, :send_shipment_shipped_webhook]
 
       event :cancel do
         transition to: :canceled, from: %i(pending ready)
@@ -93,9 +106,22 @@ module Spree
     self.whitelisted_ransackable_attributes = ['number']
 
     extend DisplayMoney
-    money_methods :cost, :discounted_cost, :final_price, :item_cost
+    money_methods :cost, :discounted_cost, :final_price, :item_cost, :additional_tax_total, :included_tax_total, :tax_total
     alias display_amount display_cost
 
+    auto_strip_attributes :tracking
+
+    # Returns the shipment number and shipping method name
+    #
+    # @return [String]
+    def name
+      [number, shipping_method&.name].compact.join(' ').strip
+    end
+
+    def amount
+      cost
+    end
+
     def add_shipping_method(shipping_method, selected = false)
       shipping_rates.create(shipping_method: shipping_method, selected: selected, cost: cost)
     end
@@ -108,17 +134,44 @@ module Spree
       manifest.each { |item| manifest_unstock(item) }
     end
 
+    # Returns true if the shipment has any backordered inventory units
+    #
+    # @return [Boolean]
     def backordered?
       inventory_units.any?(&:backordered?)
     end
 
+    # Returns true if the shipment is tracked
+    #
+    # @return [Boolean]
+    def tracked?
+      tracking.present? || tracking_url.present?
+    end
+
+    # Returns true if the shipment is shippable
+    #
+    # @return [Boolean]
+    def shippable?
+      can_ship? && tracked?
+    end
+
+    # Returns true if not all of the shipment's line items are fully shipped
+    #
+    # @return [Boolean]
+    def partial?
+      manifest.any? do |manifest_item|
+        line_item = manifest_item.line_item
+        line_item.quantity > manifest_item.quantity
+      end
+    end
+
     # Determines the appropriate +state+ according to the following logic:
     #
     # pending    unless order is complete and +order.payment_state+ is +paid+
     # shipped    if already shipped (ie. does not change the state)
     # ready      all other cases
     def determine_state(order)
-      return 'canceled' if order.canceled?
+      return 'canceled' if canceled? || order.canceled?
       return 'pending' unless order.can_ship?
       return 'pending' if inventory_units.any? &:backordered?
       return 'shipped' if shipped?

data/app/models/spree/shipment_handler.rb

@@ -1,5 +1,7 @@
 module Spree
   class ShipmentHandler
+    include Spree::Shipment::Emails
+
     class << self
       def factory(shipment)
         # Do we have a specialized shipping-method-specific handler? e.g:
@@ -27,12 +29,6 @@ module Spree
 
     protected
 
-    def send_shipped_email
-      # you can overwrite this method in your application / extension to send out the confirmation email
-      # or use `spree_emails` gem
-      # YourEmailVendor.deliver_shipment_notification_email(@shipment.id)
-    end
-
     def update_order_shipment_state
       order = @shipment.order
 

data/app/models/spree/shipping_method.rb

@@ -18,6 +18,8 @@ module Spree
 
     default_scope { where(deleted_at: nil) }
 
+    scope :with_calculator, ->(calculator) { joins(:calculator).where(calculator: { type: calculator.to_s }) }
+
     has_many :shipping_method_categories, dependent: :destroy
     has_many :shipping_categories, through: :shipping_method_categories
     has_many :shipping_rates, inverse_of: :shipping_method
@@ -33,6 +35,10 @@ module Spree
 
     validate :at_least_one_shipping_category
 
+    scope :available,              -> { where(display_on: [:both]) }
+    scope :available_on_front_end, -> { where(display_on: [:front_end, :both]) }
+    scope :available_on_back_end,  -> { where(display_on: [:back_end, :both]) }
+
     def include?(address)
       return false unless address
 
@@ -42,9 +48,25 @@ module Spree
     end
 
     def build_tracking_url(tracking)
-      return if tracking.blank? || tracking_url.blank?
+      return if tracking.blank?
+
+      tracking = tracking.upcase
+
+      # build tracking url automatically
+      if tracking_url.blank?
+        # use tracking number gem to build tracking url
+        # we need to upcase the tracking number
+        # https://github.com/jkeen/tracking_number/pull/85
+        tracking_number_service(tracking).tracking_url if tracking_number_service(tracking).valid?
+      else
+        # build tracking url manually
+        tracking_url.gsub(/:tracking/, ERB::Util.url_encode(tracking)) # :url_encode exists in 1.8.7 through 2.1.0
+      end
+    end
 
-      tracking_url.gsub(/:tracking/, ERB::Util.url_encode(tracking)) # :url_encode exists in 1.8.7 through 2.1.0
+    # your shipping method subclasses can override this method to provide a custom tracking number service
+    def tracking_number_service(tracking)
+      @tracking_number_service ||= Spree::Dependencies.tracking_number_service.constantize.new(tracking)
     end
 
     def self.calculators

data/app/models/spree/shipping_method_zone.rb

@@ -1,6 +1,8 @@
 module Spree
   class ShippingMethodZone < Spree::Base
-    belongs_to :shipping_method
-    belongs_to :zone
+    belongs_to :shipping_method, -> { with_deleted }, inverse_of: :shipping_method_zones, class_name: 'Spree::ShippingMethod'
+    belongs_to :zone, inverse_of: :shipping_method_zones, class_name: 'Spree::Zone'
+
+    validates :shipping_method, uniqueness: { scope: :zone }
   end
 end

data/app/models/spree/shipping_rate.rb

@@ -14,7 +14,7 @@ module Spree
     def display_price
       price = display_base_price.to_s
 
-      return price if tax_rate.nil? || tax_amount.zero?
+      return price if tax_rate.nil? || tax_amount.zero? || !tax_rate.show_rate_in_label
 
       Spree.t(
         tax_rate.included_in_price? ? :including_tax : :excluding_tax,

data/app/models/spree/stock/package.rb

@@ -34,6 +34,10 @@ module Spree
         contents.detect { |item| !!item.try(:inventory_unit).try(:order) }.try(:inventory_unit).try(:order)
       end
 
+      def item_total
+        contents.sum(&:amount)
+      end
+
       def weight
         contents.sum(&:weight)
       end

data/app/models/spree/stock/quantifier.rb

@@ -10,7 +10,11 @@ module Spree
 
       def total_on_hand
         @total_on_hand ||= if variant.should_track_inventory?
-                             stock_items.sum(:count_on_hand)
+                             if association_loaded?
+                               stock_items.sum(&:count_on_hand)
+                             else
+                               stock_items.sum(:count_on_hand)
+                             end
                            else
                              BigDecimal::INFINITY
                            end
@@ -30,10 +34,24 @@ module Spree
 
       private
 
-      def scope_to_location(collection)
-        return collection.with_active_stock_location if stock_location.blank?
+      def association_loaded?
+        variant.association(:stock_items).loaded? && variant.association(:stock_locations).loaded?
+      end
 
-        collection.where(stock_location: stock_location)
+      def scope_to_location(collection)
+        if stock_location.blank?
+          if association_loaded?
+            return collection.select { |si| si.stock_location&.active? }
+          else
+            return collection.with_active_stock_location
+          end
+        end
+
+        if association_loaded?
+          collection.select { |si| si.stock_location_id == stock_location.id }
+        else
+          collection.where(stock_location: stock_location)
+        end
       end
     end
   end