solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  # A calculator for promotions that calculates a percent-off discount
+  # for all matching products in an order. This should not be used as a
+  # shipping calculator since it would be the same thing as a flat percent
+  # off the entire order.
+  #
+  #
+  # TODO Should be deprecated now that we have adjustments at the line item level in spree core
+
+  class Calculator::PercentPerItem < Calculator
+    preference :percent, :decimal, default: 0
+
+    def compute(object = nil)
+      return 0 if object.nil?
+      object.line_items.map { |line_item|
+        value_for_line_item(line_item)
+      }.sum
+    end
+
+    private
+
+    # Returns all products that match this calculator, but only if the calculator
+    # is attached to a promotion. If attached to a ShippingMethod, nil is returned.
+    # Copied from per_item.rb
+    def matching_products
+      if compute_on_promotion?
+        calculable.promotion.rules.map do |rule|
+          rule.respond_to?(:products) ? rule.products : []
+        end.flatten
+      end
+    end
+
+    def value_for_line_item(line_item)
+      if compute_on_promotion?
+        return 0 unless matching_products.blank? || matching_products.include?(line_item.product)
+      end
+      ((line_item.price * line_item.quantity) * preferred_percent) / 100
+    end
+
+    # Determines wether or not the calculable object is a promotion
+    def compute_on_promotion?
+      @compute_on_promotion ||= calculable.respond_to?(:promotion)
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::PriceSack < Calculator
+    preference :minimal_amount, :decimal, default: 0
+    preference :normal_amount, :decimal, default: 0
+    preference :discount_amount, :decimal, default: 0
+    preference :currency, :string, default: ->{ Spree::Config[:currency] }
+
+    # as object we always get line items, as calculable we have Coupon, ShippingMethod
+    def compute(object)
+      if object.is_a?(Array)
+        base = object.map { |o| o.respond_to?(:amount) ? o.amount : BigDecimal(o.to_s) }.sum
+      else
+        base = object.respond_to?(:amount) ? object.amount : BigDecimal(object.to_s)
+      end
+
+      if base < preferred_minimal_amount
+        preferred_normal_amount
+      else
+        preferred_discount_amount
+      end
+    end
+  end
+end

data/app/models/spree/calculator/returns/default_refund_amount.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+require_dependency 'spree/returns_calculator'
+
+module Spree
+  module Calculator::Returns
+    class DefaultRefundAmount < ReturnsCalculator
+      def compute(return_item)
+        return 0.0.to_d if return_item.part_of_exchange?
+        weighted_order_adjustment_amount(return_item.inventory_unit) + weighted_line_item_amount(return_item.inventory_unit)
+      end
+
+      private
+
+      def weighted_order_adjustment_amount(inventory_unit)
+        inventory_unit.order.adjustments.eligible.non_tax.sum(:amount) * percentage_of_order_total(inventory_unit)
+      end
+
+      def weighted_line_item_amount(inventory_unit)
+        inventory_unit.line_item.total_before_tax / quantity_of_line_item(inventory_unit)
+      end
+
+      def percentage_of_order_total(inventory_unit)
+        return 0.0 if inventory_unit.order.item_total_before_tax.zero?
+        weighted_line_item_amount(inventory_unit) / inventory_unit.order.item_total_before_tax
+      end
+
+      def quantity_of_line_item(inventory_unit)
+        BigDecimal(inventory_unit.line_item.quantity)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+require_dependency 'spree/shipping_calculator'
+
+module Spree
+  module Calculator::Shipping
+    class FlatPercentItemTotal < ShippingCalculator
+      preference :flat_percent, :decimal, default: 0
+
+      def compute_package(package)
+        compute_from_price(total(package.contents))
+      end
+
+      def compute_from_price(price)
+        value = price * BigDecimal(preferred_flat_percent.to_s) / 100.0
+        value.round(2)
+      end
+    end
+  end
+end

data/app/models/spree/calculator/shipping/flat_rate.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+require_dependency 'spree/shipping_calculator'
+
+module Spree
+  module Calculator::Shipping
+    class FlatRate < ShippingCalculator
+      preference :amount, :decimal, default: 0
+      preference :currency, :string, default: ->{ Spree::Config[:currency] }
+
+      def compute_package(_package)
+        preferred_amount
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+require_dependency 'spree/shipping_calculator'
+
+module Spree
+  module Calculator::Shipping
+    class FlexiRate < ShippingCalculator
+      preference :first_item,      :decimal, default: 0.0
+      preference :additional_item, :decimal, default: 0.0
+      preference :max_items,       :integer, default: 0
+      preference :currency,        :string,  default: ->{ Spree::Config[:currency] }
+
+      def compute_package(package)
+        compute_from_quantity(package.contents.sum(&:quantity))
+      end
+
+      def compute_from_quantity(quantity)
+        sum = 0
+        max = preferred_max_items.to_i
+        quantity.times do |i|
+          # check max value to avoid divide by 0 errors
+          if (max == 0 && i == 0) || (max > 0) && (i % max == 0)
+            sum += preferred_first_item.to_f
+          else
+            sum += preferred_additional_item.to_f
+          end
+        end
+
+        sum
+      end
+    end
+  end
+end

data/app/models/spree/calculator/shipping/per_item.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+require_dependency 'spree/shipping_calculator'
+
+module Spree
+  module Calculator::Shipping
+    class PerItem < ShippingCalculator
+      preference :amount, :decimal, default: 0
+      preference :currency, :string, default: ->{ Spree::Config[:currency] }
+
+      def compute_package(package)
+        compute_from_quantity(package.contents.sum(&:quantity))
+      end
+
+      def compute_from_quantity(quantity)
+        preferred_amount * quantity
+      end
+    end
+  end
+end

data/app/models/spree/calculator/shipping/price_sack.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+require_dependency 'spree/shipping_calculator'
+
+module Spree
+  module Calculator::Shipping
+    class PriceSack < ShippingCalculator
+      preference :minimal_amount, :decimal, default: 0
+      preference :normal_amount, :decimal, default: 0
+      preference :discount_amount, :decimal, default: 0
+      preference :currency, :string, default: ->{ Spree::Config[:currency] }
+
+      def compute_package(package)
+        compute_from_price(total(package.contents))
+      end
+
+      def compute_from_price(price)
+        if price < preferred_minimal_amount
+          preferred_normal_amount
+        else
+          preferred_discount_amount
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::TieredFlatRate < Calculator
+    preference :base_amount, :decimal, default: 0
+    preference :tiers, :hash, default: {}
+    preference :currency, :string, default: -> { Spree::Config[:currency] }
+
+    before_validation do
+      # Convert tier values to decimals. Strings don't do us much good.
+      if preferred_tiers.is_a?(Hash)
+        self.preferred_tiers = preferred_tiers.map do |k, v|
+          [cast_to_d(k.to_s), cast_to_d(v.to_s)]
+        end.to_h
+      end
+    end
+
+    validate :preferred_tiers_content
+
+    def compute(object)
+      _base, amount = preferred_tiers.sort.reverse.detect do |b, _|
+        object.amount >= b
+      end
+
+      if preferred_currency.casecmp(object.currency).zero?
+        amount || preferred_base_amount
+      else
+        0
+      end
+    end
+
+    private
+
+    def cast_to_d(value)
+      value.to_s.to_d
+    rescue ArgumentError
+      BigDecimal(0)
+    end
+
+    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,61 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::TieredPercent < Calculator
+    preference :base_percent, :decimal, default: 0
+    preference :tiers, :hash, default: {}
+    preference :currency, :string, default: -> { Spree::Config[:currency] }
+
+    before_validation do
+      # Convert tier values to decimals. Strings don't do us much good.
+      if preferred_tiers.is_a?(Hash)
+        self.preferred_tiers = preferred_tiers.map do |k, v|
+          [cast_to_d(k.to_s), cast_to_d(v.to_s)]
+        end.to_h
+      end
+    end
+
+    validates :preferred_base_percent, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: 100
+    }
+    validate :preferred_tiers_content
+
+    def compute(object)
+      order = object.is_a?(Order) ? object : object.order
+
+      _base, percent = preferred_tiers.sort.reverse.detect do |b, _|
+        order.item_total >= b
+      end
+
+      if preferred_currency.casecmp(order.currency).zero?
+        (object.amount * (percent || preferred_base_percent) / 100).round(2)
+      else
+        0
+      end
+    end
+
+    private
+
+    def cast_to_d(value)
+      value.to_s.to_d
+    rescue ArgumentError
+      BigDecimal(0)
+    end
+
+    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/calculator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Spree
+  class Calculator < Spree::Base
+    belongs_to :calculable, polymorphic: true
+
+    # This method calls a compute_<computable> method. must be overriden in concrete calculator.
+    #
+    # It should return amount computed based on #calculable and the computable parameter
+    def compute(computable)
+      # Spree::LineItem -> :compute_line_item
+      computable_name = computable.class.name.demodulize.underscore
+      method = "compute_#{computable_name}".to_sym
+      calculator_class = self.class
+      if respond_to?(method)
+        send(method, computable)
+      else
+        raise NotImplementedError, "Please implement '#{method}(#{computable_name})' in your calculator: #{calculator_class.name}"
+      end
+    end
+
+    # A description for this calculator in few words
+    # @return [String] A description for the calculator
+    def self.description
+      model_name.human
+    end
+
+    ###################################################################
+
+    # Returns all calculators applicable for kind of work
+    def self.calculators
+      Spree::Deprecation.warn("Calling .calculators is deprecated. Please access through Rails.application.config.spree.calculators")
+
+      Spree::Config.environment.calculators
+    end
+
+    def to_s
+      self.class.name.titleize.gsub("Calculator\/", "")
+    end
+
+    def description
+      self.class.description
+    end
+
+    def available?(_object)
+      true
+    end
+  end
+end

data/app/models/spree/carton.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class Spree::Carton < Spree::Base
+  belongs_to :address, class_name: 'Spree::Address'
+  belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :cartons
+  belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', inverse_of: :cartons
+
+  has_many :inventory_units, class_name: "Spree::InventoryUnit", inverse_of: :carton, dependent: :nullify
+  has_many :orders, -> { distinct }, through: :inventory_units
+  has_many :shipments, -> { distinct }, through: :inventory_units
+
+  validates :address, presence: true
+  validates :stock_location, presence: true
+  validates :shipping_method, presence: true
+  validates :inventory_units, presence: true
+  validates :shipped_at, presence: true
+
+  make_permalink field: :number, length: 11, prefix: 'C'
+
+  scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
+  # 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(shipped_at: :desc, id: :desc) }
+
+  def to_param
+    number
+  end
+
+  def tracking_url
+    @tracking_url ||= shipping_method.build_tracking_url(tracking)
+  end
+
+  def order_numbers
+    orders.map(&:number)
+  end
+
+  def order_emails
+    orders.map(&:email).uniq
+  end
+
+  def shipment_numbers
+    shipments.map(&:number)
+  end
+
+  def display_shipped_at
+    shipped_at.to_s(:rfc822)
+  end
+
+  def manifest
+    @manifest ||= Spree::ShippingManifest.new(inventory_units: inventory_units).items
+  end
+
+  def manifest_for_order(order)
+    Spree::ShippingManifest.new(inventory_units: inventory_units).for_order(order).items
+  end
+
+  def any_exchanges?
+    inventory_units.any?(&:original_return_item)
+  end
+end

data/app/models/spree/classification.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+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
+
+    # For https://github.com/spree/spree/issues/3494
+    validates_uniqueness_of :taxon_id, scope: :product_id, message: :already_linked
+  end
+end

data/app/models/spree/country.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Spree
+  class Country < Spree::Base
+    has_many :states, -> { order(:name) }, dependent: :destroy
+    has_many :addresses, dependent: :nullify
+    has_many :prices, class_name: "Spree::Price", foreign_key: "country_iso", primary_key: "iso"
+
+    validates :name, :iso_name, presence: true
+
+    def self.default
+      if Spree::Config.default_country_id
+        Spree::Deprecation.warn("Setting your default country via its ID is deprecated. Please set your default country via the `default_country_iso` setting.", caller)
+        find_by(id: Spree::Config.default_country_id) || find_by!(iso: Spree::Config.default_country_iso)
+      else
+        find_by!(iso: Spree::Config.default_country_iso)
+      end
+    end
+
+    def <=>(other)
+      name <=> other.name
+    end
+
+    def to_s
+      name
+    end
+  end
+end