solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/tax/order_adjuster.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Spree
+  module Tax
+    # Add tax adjustments to all line items and shipments in an order
+    class OrderAdjuster
+      attr_reader :order
+
+      # @param [Spree::Order] order to be adjusted
+      def initialize(order)
+        @order = order
+      end
+
+      # Creates tax adjustments for all taxable items (shipments and line items)
+      # in the given order.
+      def adjust!
+        taxes = Spree::Config.tax_calculator_class.new(order).calculate
+        Spree::OrderTaxation.new(order).apply(taxes)
+      end
+    end
+  end
+end

data/app/models/spree/tax/order_tax.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Spree
+  module Tax
+    # Simple object to pass back tax data from a calculator.
+    #
+    # Will be used by {Spree::OrderTaxation} to create or update tax
+    # adjustments on an order.
+    #
+    # @attr_reader [Integer] order_id the {Spree::Order} these taxes apply to
+    # @attr_reader [Array<Spree::Tax::ItemTax>] line_item_taxes an array of
+    #   tax data for order's line items
+    # @attr_reader [Array<Spree::Tax::ItemTax>] shipment_taxes an array of
+    #   tax data for the order's shipments
+    class OrderTax
+      include ActiveModel::Model
+      attr_accessor :order_id, :line_item_taxes, :shipment_taxes
+    end
+  end
+end

data/app/models/spree/tax/shipping_rate_taxer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Spree
+  module Tax
+    # Used to build shipping rate taxes
+    class ShippingRateTaxer
+      # Build shipping rate taxes for a shipping rate
+      # Modifies the passed-in shipping rate with associated shipping rate taxes.
+      # @param [Spree::ShippingRate] shipping_rate The shipping rate to add taxes to.
+      #   This parameter will be modified.
+      # @return [Spree::ShippingRate] The shipping rate with associated tax objects
+      def tax(shipping_rate)
+        taxes = Spree::Config.shipping_rate_tax_calculator_class.new(shipping_rate.order).calculate(shipping_rate)
+        taxes.each do |tax|
+          shipping_rate.taxes.build(
+            amount: tax.amount,
+            tax_rate: tax.tax_rate
+          )
+        end
+        shipping_rate
+      end
+    end
+  end
+end

data/app/models/spree/tax/tax_helpers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Spree
+  module Tax
+    module TaxHelpers
+      private
+
+      def rates_for_item(item)
+        @rates_for_order ||= Spree::TaxRate.for_address(item.order.tax_address)
+
+        @rates_for_order.select do |rate|
+          rate.tax_categories.map(&:id).include?(item.tax_category_id)
+        end
+      end
+    end
+  end
+end

data/app/models/spree/tax/tax_location.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Spree
+  module Tax
+    # A class exclusively used as a drop-in replacement for a default tax address.
+    # It responds to `:country_id` and `:state_id`.
+    #
+    # @attr_reader [Integer] country_id the ID of a Spree::Country object
+    # @attr_reader [Integer] state_id the ID of a Spree::State object
+    class TaxLocation
+      attr_reader :country_id, :state_id
+
+      # Create a new TaxLocation object
+      #
+      # @see Spree::Zone.for_address
+      #
+      # @param [Spree::Country] country a Spree::Country object, default: nil
+      # @param [Spree::State] state a Spree::State object, default: nil
+      #
+      # @return [Spree::Tax::TaxLocation] a Spree::Tax::TaxLocation object
+      def initialize(country: nil, state: nil)
+        @country_id = country && country.id
+        @state_id = state && state.id
+      end
+
+      def ==(other)
+        state_id == other.state_id && country_id == other.country_id
+      end
+
+      def country
+        Spree::Country.find_by(id: country_id)
+      end
+
+      def empty?
+        country_id.nil? && state_id.nil?
+      end
+    end
+  end
+end

data/app/models/spree/tax_calculator/default.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Spree
+  module TaxCalculator
+    # Default implementation for tax calculations. Will go through all line
+    # items and shipments and calculate their tax based on tax rates in the DB.
+    #
+    # The class used for tax calculation is configurable, so that the
+    # calculation can easily be pushed to third-party services. Users looking
+    # to provide their own calculator should adhere to the API of this class.
+    #
+    # @api experimental
+    # @note This API is currently in development and likely to change.
+    #   Specifically, the input format is not yet finalized.
+    class Default
+      include Spree::Tax::TaxHelpers
+
+      # Create a new tax calculator.
+      #
+      # @param [Spree::Order] order the order to calculator taxes on
+      # @return [Spree::TaxCalculator::Default] a Spree::TaxCalculator::Default object
+      def initialize(order)
+        @order = order
+      end
+
+      # Calculate taxes for an order.
+      #
+      # @return [Spree::Tax::OrderTax] the calculated taxes for the order
+      def calculate
+        Spree::Tax::OrderTax.new(
+          order_id: order.id,
+          line_item_taxes: line_item_rates,
+          shipment_taxes: shipment_rates
+        )
+      end
+
+      private
+
+      attr_reader :order
+
+      # Calculate the taxes for line items.
+      #
+      # @private
+      # @return [Array<Spree::Tax::ItemTax>] calculated taxes for the line items
+      def line_item_rates
+        order.line_items.flat_map do |line_item|
+          calculate_rates(line_item)
+        end
+      end
+
+      # Calculate the taxes for shipments.
+      #
+      # @private
+      # @return [Array<Spree::Tax::ItemTax>] calculated taxes for the shipments
+      def shipment_rates
+        order.shipments.flat_map do |shipment|
+          calculate_rates(shipment)
+        end
+      end
+
+      # Calculate the taxes for a single item.
+      #
+      # The item could be either a {Spree::LineItem} or a {Spree::Shipment}.
+      #
+      # Will go through all applicable rates for an item and create a new
+      # {Spree::Tax::ItemTax} containing the calculated taxes for the item.
+      #
+      # @private
+      # @return [Array<Spree::Tax::ItemTax>] calculated taxes for the item
+      def calculate_rates(item)
+        rates_for_item(item).map do |rate|
+          amount = rate.compute_amount(item)
+
+          Spree::Tax::ItemTax.new(
+            item_id: item.id,
+            label: rate.adjustment_label(amount),
+            tax_rate: rate,
+            amount: amount,
+            included_in_price: rate.included_in_price
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/spree/tax_calculator/shipping_rate.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Spree
+  module TaxCalculator
+    # Default implementation for tax calculations on shipping rates.
+    #
+    # The class used for shipping rate tax calculation is configurable, so that
+    # the calculation can easily be pushed to third-party services. Users
+    # looking to provide their own calculator should adhere to the API of this
+    # class.
+    #
+    # @see Spree::Tax::ShippingRateTaxer
+    # @api experimental
+    # @note This API is currently in development and likely to change.
+    #   Specifically, the input format is not yet finalized.
+    class ShippingRate
+      include Spree::Tax::TaxHelpers
+
+      attr_reader :shipping_rate
+
+      # Create a new tax calculator.
+      #
+      # @param [Spree::Order] order the order to calculate taxes on
+      # @return [Spree::TaxCalculator::ShippingRate]
+      def initialize(order)
+        if order.is_a?(::Spree::ShippingRate)
+          Spree::Deprecation.warn "passing a single shipping rate to Spree::TaxCalculator::ShippingRate is DEPRECATED. It now expects an order"
+          shipping_rate = order
+          @order = shipping_rate.order
+          @shipping_rate = shipping_rate
+        else
+          @order = order
+          @shipping_rate = nil
+        end
+      end
+
+      # Calculate taxes for a shipping rate.
+      #
+      # @param [Spree::ShippingRate] shipping_rate the shipping rate to
+      #   calculate taxes on
+      # @return [Array<Spree::Tax::ItemTax>] the calculated taxes for the
+      #   shipping rate
+      def calculate(shipping_rate)
+        shipping_rate ||= @shipping_rate
+        rates_for_item(shipping_rate).map do |rate|
+          amount = rate.compute_amount(shipping_rate)
+
+          Spree::Tax::ItemTax.new(
+            item_id: shipping_rate.id,
+            label: rate.adjustment_label(amount),
+            tax_rate: rate,
+            amount: amount
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/spree/tax_category.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Spree
+  class TaxCategory < Spree::Base
+    acts_as_paranoid
+    validates :name, presence: true
+    validates_uniqueness_of :name, unless: :deleted_at
+
+    has_many :tax_rate_tax_categories,
+      class_name: 'Spree::TaxRateTaxCategory',
+      dependent: :destroy,
+      inverse_of: :tax_category
+    has_many :tax_rates,
+      through: :tax_rate_tax_categories,
+      class_name: 'Spree::TaxRate',
+      inverse_of: :tax_categories
+
+    after_save :ensure_one_default
+
+    def self.default
+      find_by(is_default: true)
+    end
+
+    def ensure_one_default
+      if is_default
+        Spree::TaxCategory.where(is_default: true).where.not(id: id).update_all(is_default: false, updated_at: Time.current)
+      end
+    end
+  end
+end

data/app/models/spree/tax_rate.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'discard'
+
+module Spree
+  class TaxRate < Spree::Base
+    acts_as_paranoid
+    include Spree::ParanoiaDeprecations
+
+    include Discard::Model
+    self.discard_column = :deleted_at
+
+    # Need to deal with adjustments before calculator is destroyed.
+    before_destroy :remove_adjustments_from_incomplete_orders
+    before_discard :remove_adjustments_from_incomplete_orders
+
+    include Spree::CalculatedAdjustments
+    include Spree::AdjustmentSource
+
+    belongs_to :zone, class_name: "Spree::Zone", inverse_of: :tax_rates
+
+    has_many :tax_rate_tax_categories,
+      class_name: 'Spree::TaxRateTaxCategory',
+      dependent: :destroy,
+      inverse_of: :tax_rate
+    has_many :tax_categories,
+      through: :tax_rate_tax_categories,
+      class_name: 'Spree::TaxCategory',
+      inverse_of: :tax_rates
+
+    has_many :adjustments, as: :source
+    has_many :shipping_rate_taxes, class_name: "Spree::ShippingRateTax"
+
+    validates :amount, presence: true, numericality: true
+
+    # Finds all tax rates whose zones match a given address
+    scope :for_address, ->(address) { joins(:zone).merge(Spree::Zone.for_address(address)) }
+    scope :for_country,
+          ->(country) { for_address(Spree::Tax::TaxLocation.new(country: country)) }
+
+    # Finds geographically matching tax rates for a tax zone.
+    # We do not know if they are/aren't applicable until we attempt to apply these rates to
+    # the items contained within the Order itself.
+    # For instance, if a rate passes the criteria outlined in this method,
+    # but then has a tax category that doesn't match against any of the line items
+    # inside of the order, then that tax rate will not be applicable to anything.
+    # For instance:
+    #
+    # Zones:
+    #   - Spain
+    #   - France
+    #
+    # Tax rates: (note: amounts below do not actually reflect real VAT rates)
+    #   21% inclusive - "Clothing" - Spain
+    #   18% inclusive - "Clothing" - France
+    #   10% inclusive - "Food" - Spain
+    #   8% inclusive - "Food" - France
+    #   5% inclusive - "Hotels" - Spain
+    #   2% inclusive - "Hotels" - France
+    #
+    # Order has:
+    #   Line Item #1 - Tax Category: Clothing
+    #   Line Item #2 - Tax Category: Food
+    #
+    # Tax rates that should be selected:
+    #
+    #  21% inclusive - "Clothing" - Spain
+    #  10% inclusive - "Food" - Spain
+    #
+    # If the order's address changes to one in France, then the tax will be recalculated:
+    #
+    #  18% inclusive - "Clothing" - France
+    #  8% inclusive - "Food" - France
+    #
+    # Note here that the "Hotels" tax rates will not be used at all.
+    # This is because there are no items which have the tax category of "Hotels".
+    #
+    # Under no circumstances should negative adjustments be applied for the Spanish tax rates.
+    #
+    # Those rates should never come into play at all and only the French rates should apply.
+    scope :for_zone, ->(zone) do
+      if zone
+        where(zone_id: Spree::Zone.with_shared_members(zone).pluck(:id))
+      else
+        none
+      end
+    end
+    scope :included_in_price, -> { where(included_in_price: true) }
+
+    # Creates necessary tax adjustments for the order.
+    def adjust(_order_tax_zone, item)
+      amount = compute_amount(item)
+
+      item.adjustments.create!(
+        source: self,
+        amount: amount,
+        order_id: item.order_id,
+        label: adjustment_label(amount),
+        included: included_in_price
+      )
+    end
+
+    # This method is used by Adjustment#update to recalculate the cost.
+    def compute_amount(item)
+      calculator.compute(item)
+    end
+
+    def active?
+      (starts_at.nil? || starts_at < Time.current) &&
+        (expires_at.nil? || expires_at > Time.current)
+    end
+
+    def adjustment_label(amount)
+      I18n.t(
+        translation_key(amount),
+        scope: "spree.adjustment_labels.tax_rates",
+        name: name.presence || tax_categories.map(&:name).join(", "),
+        amount: amount_for_adjustment_label
+      )
+    end
+
+    def tax_category=(category)
+      self.tax_categories = [category]
+    end
+
+    def tax_category
+      tax_categories[0]
+    end
+
+    deprecate :tax_category => :tax_categories, :tax_category= => :tax_categories=, deprecator: Spree::Deprecation
+
+    private
+
+    def amount_for_adjustment_label
+      ActiveSupport::NumberHelper::NumberToPercentageConverter.convert(
+        amount * 100,
+        locale: I18n.locale
+      )
+    end
+
+    def translation_key(_amount)
+      key = included_in_price? ? "vat" : "sales_tax"
+      key += "_with_rate" if show_rate_in_label?
+      key.to_sym
+    end
+  end
+end

data/app/models/spree/tax_rate_tax_category.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class TaxRateTaxCategory < Spree::Base
+    belongs_to :tax_rate, class_name: 'Spree::TaxRate', inverse_of: :tax_rate_tax_categories
+    belongs_to :tax_category, class_name: 'Spree::TaxCategory', inverse_of: :tax_rate_tax_categories
+  end
+end

data/app/models/spree/taxon.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'spree/core/product_filters'
+
+module Spree
+  class Taxon < Spree::Base
+    acts_as_nested_set dependent: :destroy
+
+    belongs_to :taxonomy, class_name: 'Spree::Taxonomy', inverse_of: :taxons
+    has_many :classifications, -> { order(:position) }, dependent: :delete_all, inverse_of: :taxon
+    has_many :products, through: :classifications
+
+    has_many :promotion_rule_taxons
+    has_many :promotion_rules, through: :promotion_rule_taxons
+
+    before_create :set_permalink
+    before_update :set_permalink
+    after_update :update_child_permalinks, if: :saved_change_to_permalink?
+
+    validates :name, presence: true
+    validates :meta_keywords, length: { maximum: 255 }
+    validates :meta_description, length: { maximum: 255 }
+    validates :meta_title, length: { maximum: 255 }
+
+    after_save :touch_ancestors_and_taxonomy
+    after_touch :touch_ancestors_and_taxonomy
+
+    has_attached_file :icon,
+      styles: { mini: '32x32>', normal: '128x128>' },
+      default_style: :mini,
+      url: '/spree/taxons/:id/:style/:basename.:extension',
+      path: ':rails_root/public/spree/taxons/:id/:style/:basename.:extension',
+      default_url: '/assets/default_taxon.png'
+
+    validates_attachment :icon,
+      content_type: { content_type: ["image/jpg", "image/jpeg", "image/png", "image/gif"] }
+
+    # @note This method is meant to be overridden on a store by store basis.
+    # @return [Array] filters that should be used for a taxon
+    def applicable_filters
+      Spree::Deprecation.warn "Spree::Taxon#applicable_filters is deprecated, if you are using this functionality please move it into your own application."
+
+      fs = []
+      fs << Spree::Core::ProductFilters.price_filter if Spree::Core::ProductFilters.respond_to?(:price_filter)
+      fs << Spree::Core::ProductFilters.brand_filter if Spree::Core::ProductFilters.respond_to?(:brand_filter)
+      fs
+    end
+
+    # @return [String] meta_title if set otherwise a string containing the
+    #   root name and taxon name
+    def seo_title
+      if meta_title.present?
+        meta_title
+      else
+        root? ? name : "#{root.name} - #{name}"
+      end
+    end
+
+    # Sets this taxons permalink to a valid url encoded string based on its
+    # name and its parents permalink (if present.)
+    def set_permalink
+      permalink_tail = permalink.split('/').last if permalink.present?
+      permalink_tail ||= Spree::Config.taxon_url_parametizer_class.parameterize(name)
+      self.permalink_part = permalink_tail
+    end
+
+    # Update the permalink for this taxon and all children (if necessary)
+    def update_permalinks
+      set_permalink
+
+      # This will trigger update_child_permalinks if permalink has changed
+      save!
+    end
+
+    # Update the permalinks for all children
+    def update_child_permalinks
+      children.each(&:update_permalinks)
+    end
+
+    # @return [String] this taxon's permalink
+    def to_param
+      permalink
+    end
+
+    # @return [ActiveRecord::Relation<Spree::Product>] the active products the
+    #   belong to this taxon
+    def active_products
+      products.not_deleted.available
+    end
+
+    # @return [ActiveRecord::Relation<Spree::Product>] all self and descendant products
+    def all_products
+      scope = Product.joins(:taxons)
+      scope.where(
+        spree_taxons: { id: self_and_descendants.select(:id) }
+      )
+    end
+
+    # @return [ActiveRecord::Relation<Spree::Variant>] all self and descendant variants, including master variants.
+    def all_variants
+      Variant.where(product_id: all_products.select(:id))
+    end
+
+    # @return [String] this taxon's ancestors names followed by its own name,
+    #   separated by arrows
+    def pretty_name
+      ancestor_chain = ancestors.map(&:name)
+      ancestor_chain << name
+      ancestor_chain.join(" -> ")
+    end
+
+    # @see https://github.com/spree/spree/issues/3390
+    def child_index=(idx)
+      # awesome_nested_set sorts by :lft and :rgt. This call re-inserts the
+      # child node so that its resulting position matches the observable
+      # 0-indexed position.
+      #
+      # NOTE: no :position column needed - awesom_nested_set doesn't handle the
+      # reordering if you bring your own :order_column.
+      move_to_child_with_index(parent, idx.to_i) unless new_record?
+    end
+
+    def permalink_part
+      permalink.split('/').last
+    end
+
+    def permalink_part=(value)
+      if parent.present?
+        self.permalink = "#{parent.permalink}/#{value}"
+      else
+        self.permalink = value
+      end
+    end
+
+    private
+
+    def touch_ancestors_and_taxonomy
+      # Touches all ancestors at once to avoid recursive taxonomy touch, and reduce queries.
+      self.class.where(id: ancestors.pluck(:id)).update_all(updated_at: Time.current)
+      # Have taxonomy touch happen in #touch_ancestors_and_taxonomy rather than association option in order for imports to override.
+      taxonomy.try!(:touch)
+    end
+  end
+end

data/app/models/spree/taxonomy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Spree
+  class Taxonomy < Spree::Base
+    acts_as_list
+
+    validates :name, presence: true
+
+    has_many :taxons, inverse_of: :taxonomy
+    has_one :root, -> { where parent_id: nil }, class_name: "Spree::Taxon", dependent: :destroy
+
+    after_save :set_name
+
+    default_scope -> { order(position: :asc) }
+
+    private
+
+    def set_name
+      if root
+        root.update_columns(
+          name: name,
+          updated_at: Time.current
+        )
+      else
+        self.root = Spree::Taxon.create!(taxonomy_id: id, name: name)
+      end
+    end
+  end
+end

data/app/models/spree/unit_cancel.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# This represents an inventory unit that has been canceled from an order after it has already been completed
+# The reason specifies why it was canceled.
+# This class should encapsulate logic related to canceling inventory after order complete
+class Spree::UnitCancel < Spree::Base
+  SHORT_SHIP = 'Short Ship'
+  DEFAULT_REASON = 'Cancel'
+
+  belongs_to :inventory_unit
+  has_one :adjustment, as: :source, dependent: :destroy
+
+  validates :inventory_unit, presence: true
+
+  # Creates necessary cancel adjustments for the line item.
+  def adjust!
+    raise "Adjustment is already created" if adjustment
+
+    amount = compute_amount(inventory_unit.line_item)
+
+    self.adjustment = inventory_unit.line_item.adjustments.create!(
+      source: self,
+      amount: amount,
+      order: inventory_unit.order,
+      label: "#{I18n.t('spree.cancellation')} - #{reason}",
+      eligible: true,
+      finalized: true
+    )
+  end
+
+  # This method is used by Adjustment#update to recalculate the cost.
+  def compute_amount(line_item)
+    raise "Adjustable does not match line item" unless line_item == inventory_unit.line_item
+    -(line_item.total.to_d / line_item.inventory_units.not_canceled.reject(&:original_return_item ).size)
+  end
+end

data/app/models/spree/user_address.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Spree
+  class UserAddress < Spree::Base
+    belongs_to :user, class_name: UserClassHandle.new, foreign_key: "user_id"
+    belongs_to :address, class_name: "Spree::Address"
+
+    validates_uniqueness_of :address_id, scope: :user_id
+    validates_uniqueness_of :user_id, conditions: -> { active.default }, message: :default_address_exists, if: :default?
+
+    scope :with_address_values, ->(address_attributes) do
+      joins(:address).merge(
+        Spree::Address.with_values(address_attributes)
+      )
+    end
+
+    scope :all_historical, -> { unscope(where: :archived) }
+    scope :default, -> { where(default: true) }
+    scope :active, -> { where(archived: false) }
+
+    default_scope -> { order([default: :desc, updated_at: :desc]) }
+  end
+end