goca-spree-core 3.1.14.rails.5.0

data/app/models/spree/adjustment.rb

@@ -0,0 +1,104 @@
+# Adjustments represent a change to the +item_total+ of an Order. Each adjustment
+# has an +amount+ that can be either positive or negative.
+#
+# Adjustments can be "opened" or "closed".
+# Once an adjustment is closed, it will not be automatically updated.
+#
+# Boolean attributes:
+#
+# +mandatory+
+#
+# If this flag is set to true then it means the the charge is required and will not
+# be removed from the order, even if the amount is zero. In other words a record
+# will be created even if the amount is zero. This is useful for representing things
+# such as shipping and tax charges where you may want to make it explicitly clear
+# that no charge was made for such things.
+#
+# +eligible?+
+#
+# This boolean attributes stores whether this adjustment is currently eligible
+# for its order. Only eligible adjustments count towards the order's adjustment
+# total. This allows an adjustment to be preserved if it becomes ineligible so
+# it might be reinstated.
+module Spree
+  class Adjustment < Spree::Base
+    with_options polymorphic: true do
+      belongs_to :adjustable, touch: true
+      belongs_to :source
+    end
+    belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments
+
+    validates :adjustable, :order, :label, presence: true
+    validates :amount, numericality: true
+
+    state_machine :state, initial: :open do
+      event :close do
+        transition from: :open, to: :closed
+      end
+
+      event :open do
+        transition from: :closed, to: :open
+      end
+    end
+
+    after_create :update_adjustable_adjustment_total
+    after_destroy :update_adjustable_adjustment_total
+
+    class_attribute :competing_promos_source_types
+
+    self.competing_promos_source_types = ['Spree::PromotionAction']
+
+    scope :open, -> { where(state: 'open') }
+    scope :closed, -> { where(state: 'closed') }
+    scope :tax, -> { where(source_type: 'Spree::TaxRate') }
+    scope :non_tax, -> do
+      source_type = arel_table[:source_type]
+      where(source_type.not_eq('Spree::TaxRate').or source_type.eq(nil))
+    end
+    scope :price, -> { where(adjustable_type: 'Spree::LineItem') }
+    scope :shipping, -> { where(adjustable_type: 'Spree::Shipment') }
+    scope :optional, -> { where(mandatory: false) }
+    scope :eligible, -> { where(eligible: true) }
+    scope :charge, -> { where("#{quoted_table_name}.amount >= 0") }
+    scope :credit, -> { where("#{quoted_table_name}.amount < 0") }
+    scope :nonzero, -> { where("#{quoted_table_name}.amount != 0") }
+    scope :promotion, -> { where(source_type: 'Spree::PromotionAction') }
+    scope :return_authorization, -> { where(source_type: "Spree::ReturnAuthorization") }
+    scope :is_included, -> { where(included: true) }
+    scope :additional, -> { where(included: false) }
+    scope :competing_promos, -> { where(source_type: competing_promos_source_types) }
+    scope :for_complete_order, -> { joins(:order).merge(Spree::Order.complete) }
+    scope :for_incomplete_order, -> { joins(:order).merge(Spree::Order.incomplete) }
+
+    extend DisplayMoney
+    money_methods :amount
+
+    def currency
+      adjustable ? adjustable.currency : Spree::Config[:currency]
+    end
+
+    def promotion?
+      source_type == 'Spree::PromotionAction'
+    end
+
+    # Passing a target here would always be recommended as it would avoid
+    # hitting the database again and would ensure you're compute values over
+    # the specific object amount passed here.
+    def update!(target = adjustable)
+      return amount if closed? || source.blank?
+      amount = source.compute_amount(target)
+      attributes = { amount: amount, updated_at: Time.current }
+      attributes[:eligible] = source.promotion.eligible?(target) if promotion?
+      update_columns(attributes)
+      amount
+    end
+
+    private
+
+    def update_adjustable_adjustment_total
+      # Cause adjustable's total to be recalculated
+      Adjustable::AdjustmentsUpdater.update(adjustable)
+    end
+
+  end
+end

data/app/models/spree/app_configuration.rb

@@ -0,0 +1,74 @@
+# This is the primary location for defining spree preferences
+#
+# The expectation is that this is created once and stored in
+# the spree environment
+#
+# setters:
+# a.color = :blue
+# a[:color] = :blue
+# a.set :color = :blue
+# a.preferred_color = :blue
+#
+# getters:
+# a.color
+# a[:color]
+# a.get :color
+# a.preferred_color
+#
+require "spree/core/search/base"
+
+module Spree
+  class AppConfiguration < Preferences::Configuration
+    # Alphabetized to more easily lookup particular preferences
+    preference :address_requires_state, :boolean, default: true # should state/state_name be required
+    preference :admin_interface_logo, :string, default: 'logo/spree_50.png'
+    preference :admin_path, :string, default: '/admin'
+    preference :admin_products_per_page, :integer, default: 10
+    preference :allow_checkout_on_gateway_error, :boolean, default: false
+    preference :allow_guest_checkout, :boolean, default: true
+    preference :alternative_shipping_phone, :boolean, default: false # Request extra phone for ship addr
+    preference :always_include_confirm_step, :boolean, default: false # Ensures confirmation step is always in checkout_progress bar, but does not force a confirm step if your payment methods do not support it.
+    preference :always_put_site_name_in_title, :boolean, default: true
+    preference :auto_capture, :boolean, default: false # automatically capture the credit card (as opposed to just authorize and capture later)
+    preference :auto_capture_on_dispatch, :boolean, default: false # Captures payment for each shipment in Shipment#after_ship callback, and makes Shipment.ready when payment authorized.
+    preference :binary_inventory_cache, :boolean, default: false # only invalidate product cache when a stock item changes whether it is in_stock
+    preference :checkout_zone, :string, default: nil # replace with the name of a zone if you would like to limit the countries
+    preference :company, :boolean, default: false # Request company field for billing and shipping addr
+    preference :currency, :string, default: "USD"
+    preference :default_country_id, :integer
+    preference :expedited_exchanges, :boolean, default: false # NOTE this requires payment profiles to be supported on your gateway of choice as well as a delayed job handler to be configured with activejob. kicks off an exchange shipment upon return authorization save. charge customer if they do not return items within timely manner.
+    preference :expedited_exchanges_days_window, :integer, default: 14 # the amount of days the customer has to return their item after the expedited exchange is shipped in order to avoid being charged
+    preference :layout, :string, default: 'spree/layouts/spree_application'
+    preference :logo, :string, default: 'logo/spree_50.png'
+    preference :max_level_in_taxons_menu, :integer, default: 1 # maximum nesting level in taxons menu
+    preference :orders_per_page, :integer, default: 15
+    preference :properties_per_page, :integer, default: 15
+    preference :products_per_page, :integer, default: 12
+    preference :promotions_per_page, :integer, default: 15
+    preference :customer_returns_per_page, :integer, default: 15
+    preference :require_master_price, :boolean, default: true
+    preference :restock_inventory, :boolean, default: true # Determines if a return item is restocked automatically once it has been received
+    preference :return_eligibility_number_of_days, :integer, default: 365
+    preference :send_core_emails, :boolean, default: true # Default mail headers settings
+    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
+    preference :show_products_without_price, :boolean, default: false
+    preference :show_raw_product_description, :boolean, default: false
+    preference :tax_using_ship_address, :boolean, default: true
+    preference :track_inventory_levels, :boolean, default: true # Determines whether to track on_hand values for variants / products.
+
+    # Store credits configurations
+    preference :non_expiring_credit_types, :array, default: []
+    preference :credit_to_new_allocation, :boolean, default: false
+
+    # searcher_class allows spree extension writers to provide their own Search class
+    def searcher_class
+      @searcher_class ||= Spree::Core::Search::Base
+    end
+
+    def searcher_class=(sclass)
+      @searcher_class = sclass
+    end
+  end
+end

data/app/models/spree/asset.rb

@@ -0,0 +1,6 @@
+module Spree
+  class Asset < Spree::Base
+    belongs_to :viewable, polymorphic: true, touch: true
+    acts_as_list scope: [:viewable_id, :viewable_type]
+  end
+end

data/app/models/spree/base.rb

@@ -0,0 +1,24 @@
+class Spree::Base < ActiveRecord::Base
+  include Spree::Preferences::Preferable
+  serialize :preferences, Hash
+
+  include Spree::RansackableAttributes
+
+  after_initialize do
+    if has_attribute?(:preferences) && !preferences.nil?
+      self.preferences = default_preferences.merge(preferences)
+    end
+  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
+
+  def self.spree_base_scopes
+    where(nil)
+  end
+end

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

@@ -0,0 +1,59 @@
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::DefaultTax < Calculator
+    include VatPriceCalculation
+    def self.description
+      Spree.t(:default_tax)
+    end
+
+    # Default tax calculator still needs to support orders for legacy reasons
+    # Orders created before Spree 2.1 had tax adjustments applied to the order, as a whole.
+    # Orders created with Spree 2.2 and after, have them applied to the line items individually.
+    def compute_order(order)
+
+      matched_line_items = order.line_items.select do |line_item|
+        line_item.tax_category == rate.tax_category
+      end
+
+      line_items_total = matched_line_items.sum(&:total)
+      if rate.included_in_price
+        round_to_two_places(line_items_total - ( line_items_total / (1 + rate.amount) ) )
+      else
+        round_to_two_places(line_items_total * rate.amount)
+      end
+    end
+
+    # When it comes to computing shipments or line items: same same.
+    def compute_shipment_or_line_item(item)
+      if rate.included_in_price
+        deduced_total_by_rate(item.pre_tax_amount, rate)
+      else
+        round_to_two_places(item.discounted_amount * rate.amount)
+      end
+    end
+
+    alias_method :compute_shipment, :compute_shipment_or_line_item
+    alias_method :compute_line_item, :compute_shipment_or_line_item
+
+    def compute_shipping_rate(shipping_rate)
+      if rate.included_in_price
+        pre_tax_amount = shipping_rate.cost / (1 + rate.amount)
+        deduced_total_by_rate(pre_tax_amount, rate)
+      else
+        with_tax_amount = shipping_rate.cost * rate.amount
+        round_to_two_places(with_tax_amount)
+      end
+    end
+
+    private
+
+    def rate
+      self.calculable
+    end
+
+    def deduced_total_by_rate(pre_tax_amount, rate)
+      round_to_two_places(pre_tax_amount * rate.amount)
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::FlatPercentItemTotal < Calculator
+    preference :flat_percent, :decimal, default: 0
+
+    def self.description
+      Spree.t(:flat_percent)
+    end
+
+    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/flat_rate.rb

@@ -0,0 +1,20 @@
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::FlatRate < Calculator
+    preference :amount, :decimal, default: 0
+    preference :currency, :string, default: ->{ Spree::Config[:currency] }
+
+    def self.description
+      Spree.t(:flat_rate_per_order)
+    end
+
+    def compute(object=nil)
+      if object && preferred_currency.upcase == object.currency.upcase
+        preferred_amount
+      else
+        0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::FlexiRate < Calculator
+    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 self.description
+      Spree.t(:flexible_rate)
+    end
+
+    def self.available?(object)
+      true
+    end
+
+    def compute(object)
+      sum = 0
+      max = self.preferred_max_items.to_i
+      items_count = object.quantity
+      items_count.times do |i|
+        if i == 0
+          sum += self.preferred_first_item.to_f
+        elsif ((max > 0) && (i <= (max - 1))) || (max == 0)
+          sum += self.preferred_additional_item.to_f
+        end
+      end
+
+      sum
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# TODO: Deprecate this class.
+# This calculator will be removed in future versions of Spree.
+# The only case where it was used was for Free Shipping Promotions.
+# There is now a Promotion Action which deals with these types of promotions instead.
+module Spree
+  class Calculator::FreeShipping < Calculator
+    def self.description
+      Spree.t(:free_shipping)
+    end
+
+    def compute(object)
+      if object.is_a?(Array)
+        return if object.empty?
+        order = object.first.order
+      else
+        order = object
+      end
+
+      order.ship_total
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Spree
+  class Calculator
+    class PercentOnLineItem < Calculator
+      preference :percent, :decimal, default: 0
+
+      def self.description
+        Spree.t(:percent_per_item)
+      end
+
+      def compute(object)
+        (object.amount * preferred_percent) / 100
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+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 self.description
+      Spree.t(:percent_per_item)
+    end
+
+    def compute(object=nil)
+      return 0 if object.nil?
+      object.line_items.reduce(0) do |sum, line_item|
+        sum += value_for_line_item(line_item)
+      end
+    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?
+        self.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? or 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 ||= self.calculable.respond_to?(:promotion)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+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] }
+
+    def self.description
+      Spree.t(:price_sack)
+    end
+
+    # 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 < self.preferred_minimal_amount
+        self.preferred_normal_amount
+      else
+        self.preferred_discount_amount
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require_dependency 'spree/returns_calculator'
+
+module Spree
+  module Calculator::Returns
+    class DefaultRefundAmount < ReturnsCalculator
+
+      def self.description
+        Spree.t(:default_refund_amount)
+      end
+
+      def compute(return_item)
+        return 0.0.to_d if return_item.exchange_requested?
+        weighted_order_adjustment_amount(return_item.inventory_unit) + weighted_line_item_pre_tax_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_pre_tax_amount(inventory_unit)
+        inventory_unit.line_item.pre_tax_amount * percentage_of_line_item(inventory_unit)
+      end
+
+      def percentage_of_order_total(inventory_unit)
+       return 0.0 if inventory_unit.order.pre_tax_item_amount.zero?
+       weighted_line_item_pre_tax_amount(inventory_unit) / inventory_unit.order.pre_tax_item_amount
+     end
+
+     def percentage_of_line_item(inventory_unit)
+       1 / BigDecimal.new(inventory_unit.line_item.quantity)
+     end
+   end
+ end
+end

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

@@ -0,0 +1,22 @@
+require_dependency 'spree/shipping_calculator'
+
+module Spree
+  module Calculator::Shipping
+    class FlatPercentItemTotal < ShippingCalculator
+      preference :flat_percent, :decimal, default: 0
+
+      def self.description
+        Spree.t(:flat_percent)
+      end
+
+      def compute_package(package)
+        compute_from_price(total(package.contents))
+      end
+
+      def compute_from_price(price)
+        value = price * BigDecimal(self.preferred_flat_percent.to_s) / 100.0
+        (value * 100).round.to_f / 100
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+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 self.description
+        Spree.t(:shipping_flat_rate_per_order)
+      end
+
+      def compute_package(package)
+        self.preferred_amount
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+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 self.description
+        Spree.t(:shipping_flexible_rate)
+      end
+
+      def compute_package(package)
+        compute_from_quantity(package.contents.sum(&:quantity))
+      end
+
+      def compute_from_quantity(quantity)
+        sum = 0
+        max = self.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 += self.preferred_first_item.to_f
+          else
+            sum += self.preferred_additional_item.to_f
+          end
+        end
+
+        sum
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+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 self.description
+        Spree.t(:shipping_flat_rate_per_item)
+      end
+
+      def compute_package(package)
+        compute_from_quantity(package.contents.sum(&:quantity))
+      end
+
+      def compute_from_quantity(quantity)
+        self.preferred_amount * quantity
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+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 self.description
+        Spree.t(:shipping_price_sack)
+      end
+
+      def compute_package(package)
+        compute_from_price(total(package.contents))
+      end
+
+      def compute_from_price(price)
+        if price < self.preferred_minimal_amount
+          self.preferred_normal_amount
+        else
+          self.preferred_discount_amount
+        end
+      end
+    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