solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/stock_quantities.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Spree
+  # A value object to hold a map of variants to their quantities
+  class StockQuantities
+    attr_reader :quantities
+    include Enumerable
+
+    # @param quantities [Hash<Spree::Variant=>Numeric>]
+    def initialize(quantities = {})
+      raise ArgumentError unless quantities.keys.all?{ |v| v.is_a?(Spree::Variant) }
+      raise ArgumentError unless quantities.values.all?{ |v| v.is_a?(Numeric) }
+
+      @quantities = quantities
+    end
+
+    # @yield [variant, quantity]
+    def each(&block)
+      @quantities.each(&block)
+    end
+
+    # @param variant [Spree::Variant]
+    # @return [Integer] the quantity of variant
+    def [](variant)
+      @quantities[variant]
+    end
+
+    # @return [Array<Spree::Variant>] the variants being tracked
+    def variants
+      @quantities.keys.uniq
+    end
+
+    # Adds two StockQuantities together
+    # @return [Spree::StockQuantities]
+    def +(other)
+      combine_with(other) do |_variant, a, b|
+        (a || 0) + (b || 0)
+      end
+    end
+
+    # Subtracts another StockQuantities from this one
+    # @return [Spree::StockQuantities]
+    def -(other)
+      combine_with(other) do |_variant, a, b|
+        (a || 0) - (b || 0)
+      end
+    end
+
+    # Finds the intersection or common subset of two StockQuantities: the
+    # stock which exists in both StockQuantities.
+    # @return [Spree::StockQuantities]
+    def &(other)
+      combine_with(other) do |_variant, a, b|
+        next unless a && b
+        [a, b].min
+      end
+    end
+
+    # A StockQuantities is empty if all variants have zero quantity
+    # @return [true,false]
+    def empty?
+      @quantities.values.all?(&:zero?)
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        quantities == other.quantities
+    end
+
+    protected
+
+    def combine_with(other)
+      self.class.new(
+        (variants | other.variants).map do |variant|
+          a = self[variant]
+          b = other[variant]
+          value = yield variant, a, b
+          [variant, value]
+        end.to_h.compact
+      )
+    end
+  end
+end

data/app/models/spree/store.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Spree
+  # Records store specific configuration such as store name and URL.
+  #
+  # `Spree::Store` provides the foundational ActiveRecord model for recording information
+  # specific to your store such as its name, URL, and tax location. This model will
+  # provide the foundation upon which [support for multiple stores](https://github.com/solidusio/solidus/issues/112)
+  # hosted by a single Solidus implementation can be built.
+  #
+  class Store < Spree::Base
+    has_many :store_payment_methods, inverse_of: :store
+    has_many :payment_methods, through: :store_payment_methods
+
+    has_many :store_shipping_methods, inverse_of: :store
+    has_many :shipping_methods, through: :store_shipping_methods
+
+    has_many :orders, class_name: "Spree::Order"
+
+    validates :code, presence: true, uniqueness: { allow_blank: true }
+    validates :name, presence: true
+    validates :url, presence: true
+    validates :mail_from_address, presence: true
+
+    before_save :ensure_default_exists_and_is_unique
+    before_destroy :validate_not_default
+
+    scope :by_url, lambda { |url| where("url like ?", "%#{url}%") }
+
+    class << self
+      deprecate :by_url, "Spree::Store.by_url is DEPRECATED", deprecator: Spree::Deprecation
+    end
+
+    def available_locales
+      locales = super()
+      if locales
+        super().split(",").map(&:to_sym)
+      else
+        Spree.i18n_available_locales
+      end
+    end
+
+    def available_locales=(locales)
+      locales = locales.reject(&:blank?)
+      if locales.empty?
+        super(nil)
+      else
+        super(locales.map(&:to_s).join(","))
+      end
+    end
+
+    def self.current(store_key)
+      Spree::Deprecation.warn "Spree::Store.current is DEPRECATED"
+      current_store = Store.find_by(code: store_key) || Store.by_url(store_key).first if store_key
+      current_store || Store.default
+    end
+
+    def self.default
+      where(default: true).first || new
+    end
+
+    def default_cart_tax_location
+      @default_cart_tax_location ||=
+        Spree::Tax::TaxLocation.new(country: Spree::Country.find_by(iso: cart_tax_country_iso))
+    end
+
+    private
+
+    def ensure_default_exists_and_is_unique
+      if default
+        Spree::Store.where.not(id: id).update_all(default: false)
+      elsif Spree::Store.where(default: true).count == 0
+        self.default = true
+      end
+    end
+
+    def validate_not_default
+      if default
+        errors.add(:base, :cannot_destroy_default_store)
+      end
+    end
+  end
+end

data/app/models/spree/store_credit.rb

@@ -0,0 +1,293 @@
+# frozen_string_literal: true
+
+require 'discard'
+
+class Spree::StoreCredit < Spree::PaymentSource
+  acts_as_paranoid
+  include Spree::ParanoiaDeprecations
+
+  include Discard::Model
+  self.discard_column = :deleted_at
+
+  VOID_ACTION       = 'void'
+  CREDIT_ACTION     = 'credit'
+  CAPTURE_ACTION    = 'capture'
+  ELIGIBLE_ACTION   = 'eligible'
+  AUTHORIZE_ACTION  = 'authorize'
+  ALLOCATION_ACTION = 'allocation'
+  ADJUSTMENT_ACTION = 'adjustment'
+  INVALIDATE_ACTION = 'invalidate'
+
+  DEFAULT_CREATED_BY_EMAIL = "spree@example.com"
+
+  belongs_to :user, class_name: Spree::UserClassHandle.new
+  belongs_to :created_by, class_name: Spree::UserClassHandle.new
+  belongs_to :category, class_name: "Spree::StoreCreditCategory"
+  belongs_to :credit_type, class_name: 'Spree::StoreCreditType', foreign_key: 'type_id'
+  has_many :store_credit_events
+
+  validates_presence_of :user_id, :category_id, :type_id, :created_by_id, :currency
+  validates_numericality_of :amount, { greater_than: 0 }
+  validates_numericality_of :amount_used, { greater_than_or_equal_to: 0 }
+  validate :amount_used_less_than_or_equal_to_amount
+  validate :amount_authorized_less_than_or_equal_to_amount
+
+  delegate :name, to: :category, prefix: true
+  delegate :email, to: :created_by, prefix: true
+
+  scope :order_by_priority, -> { includes(:credit_type).order('spree_store_credit_types.priority ASC') }
+
+  after_save :store_event
+  before_validation :associate_credit_type
+  before_validation :validate_category_unchanged, on: :update
+  before_destroy :validate_no_amount_used
+  validate :validate_no_amount_used, if: :discarded?
+
+  attr_accessor :action, :action_amount, :action_originator, :action_authorization_code, :update_reason
+
+  extend Spree::DisplayMoney
+  money_methods :amount, :amount_used, :amount_authorized
+
+  def amount_remaining
+    return 0.0.to_d if invalidated?
+    amount - amount_used - amount_authorized
+  end
+
+  def authorize(amount, order_currency, options = {})
+    authorization_code = options[:action_authorization_code]
+    if authorization_code
+      if store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+        # Don't authorize again on capture
+        return true
+      end
+    else
+      authorization_code = generate_authorization_code
+    end
+
+    if validate_authorization(amount, order_currency)
+      update_attributes!({
+        action: AUTHORIZE_ACTION,
+        action_amount: amount,
+        action_originator: options[:action_originator],
+        action_authorization_code: authorization_code,
+
+        amount_authorized: amount_authorized + amount
+      })
+      authorization_code
+    else
+      false
+    end
+  end
+
+  def validate_authorization(amount, order_currency)
+    if amount_remaining.to_d < amount.to_d
+      errors.add(:base, I18n.t('spree.store_credit.insufficient_funds'))
+    elsif currency != order_currency
+      errors.add(:base, I18n.t('spree.store_credit.currency_mismatch'))
+    end
+    errors.blank?
+  end
+
+  def capture(amount, authorization_code, order_currency, options = {})
+    return false unless authorize(amount, order_currency, action_authorization_code: authorization_code)
+    auth_event = store_credit_events.find_by!(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+
+    if amount <= auth_event.amount
+      if currency != order_currency
+        errors.add(:base, I18n.t('spree.store_credit.currency_mismatch'))
+        false
+      else
+        update_attributes!({
+          action: CAPTURE_ACTION,
+          action_amount: amount,
+          action_originator: options[:action_originator],
+          action_authorization_code: authorization_code,
+
+          amount_used: amount_used + amount,
+          amount_authorized: amount_authorized - auth_event.amount
+        })
+        authorization_code
+      end
+    else
+      errors.add(:base, I18n.t('spree.store_credit.insufficient_authorized_amount'))
+      false
+    end
+  end
+
+  def void(authorization_code, options = {})
+    if auth_event = store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
+      update_attributes!({
+        action: VOID_ACTION,
+        action_amount: auth_event.amount,
+        action_authorization_code: authorization_code,
+        action_originator: options[:action_originator],
+
+        amount_authorized: amount_authorized - auth_event.amount
+      })
+      true
+    else
+      errors.add(:base, I18n.t('spree.store_credit.unable_to_void', auth_code: authorization_code))
+      false
+    end
+  end
+
+  def credit(amount, authorization_code, order_currency, options = {})
+    # Find the amount related to this authorization_code in order to add the store credit back
+    capture_event = store_credit_events.find_by(action: CAPTURE_ACTION, authorization_code: authorization_code)
+
+    if currency != order_currency # sanity check to make sure the order currency hasn't changed since the auth
+      errors.add(:base, I18n.t('spree.store_credit.currency_mismatch'))
+      false
+    elsif capture_event && amount <= capture_event.amount
+      action_attributes = {
+        action: CREDIT_ACTION,
+        action_amount: amount,
+        action_originator: options[:action_originator],
+        action_authorization_code: authorization_code
+      }
+      create_credit_record(amount, action_attributes)
+      true
+    else
+      errors.add(:base, I18n.t('spree.store_credit.unable_to_credit', auth_code: authorization_code))
+      false
+    end
+  end
+
+  def can_void?(payment)
+    payment.pending?
+  end
+
+  def generate_authorization_code
+    "#{id}-SC-#{Time.current.utc.strftime('%Y%m%d%H%M%S%6N')}"
+  end
+
+  def editable?
+    !amount_remaining.zero?
+  end
+
+  def invalidateable?
+    !invalidated? && amount_authorized.zero?
+  end
+
+  def invalidated?
+    !!invalidated_at
+  end
+
+  def update_amount(amount, reason, user_performing_update)
+    previous_amount = self.amount
+    self.amount = amount
+    self.action_amount = self.amount - previous_amount
+    self.action = ADJUSTMENT_ACTION
+    self.update_reason = reason
+    self.action_originator = user_performing_update
+    save
+  end
+
+  def invalidate(reason, user_performing_invalidation)
+    if invalidateable?
+      self.action = INVALIDATE_ACTION
+      self.update_reason = reason
+      self.action_originator = user_performing_invalidation
+      self.invalidated_at = Time.current
+      save
+    else
+      errors.add(:invalidated_at, I18n.t('spree.store_credit.errors.cannot_invalidate_uncaptured_authorization'))
+      false
+    end
+  end
+
+  class << self
+    def default_created_by
+      Spree.user_class.find_by(email: DEFAULT_CREATED_BY_EMAIL)
+    end
+  end
+
+  private
+
+  def create_credit_record(amount, action_attributes = {})
+    # Setting credit_to_new_allocation to true will create a new allocation anytime #credit is called
+    # If it is not set, it will update the store credit's amount in place
+    credit = if Spree::Config[:credit_to_new_allocation]
+      Spree::StoreCredit.new(create_credit_record_params(amount))
+    else
+      self.amount_used = amount_used - amount
+      self
+    end
+
+    credit.assign_attributes(action_attributes)
+    credit.save!
+  end
+
+  def create_credit_record_params(amount)
+    {
+      amount: amount,
+      user_id: user_id,
+      category_id: category_id,
+      created_by_id: created_by_id,
+      currency: currency,
+      type_id: type_id,
+      memo: credit_allocation_memo
+    }
+  end
+
+  def credit_allocation_memo
+    I18n.t("spree.store_credit.credit_allocation_memo", id: id)
+  end
+
+  def store_event
+    return unless saved_change_to_amount? || saved_change_to_amount_used? || saved_change_to_amount_authorized? || [ELIGIBLE_ACTION, INVALIDATE_ACTION].include?(action)
+
+    event = if action
+      store_credit_events.build(action: action)
+    else
+      store_credit_events.where(action: ALLOCATION_ACTION).first_or_initialize
+    end
+
+    event.update_attributes!({
+      amount: action_amount || amount,
+      authorization_code: action_authorization_code || event.authorization_code || generate_authorization_code,
+      amount_remaining: amount_remaining,
+      user_total_amount: user.available_store_credit_total(currency: currency),
+      originator: action_originator,
+      update_reason: update_reason
+    })
+  end
+
+  def amount_used_less_than_or_equal_to_amount
+    return true if amount_used.nil?
+
+    if amount_used > amount
+      errors.add(:amount_used, I18n.t('spree.admin.store_credits.errors.amount_used_cannot_be_greater'))
+    end
+  end
+
+  def amount_authorized_less_than_or_equal_to_amount
+    if (amount_used + amount_authorized) > amount
+      errors.add(:amount_authorized, I18n.t('spree.admin.store_credits.errors.amount_authorized_exceeds_total_credit'))
+    end
+  end
+
+  def validate_category_unchanged
+    if category_id_changed?
+      errors.add(:category, I18n.t('spree.admin.store_credits.errors.cannot_be_modified'))
+    end
+  end
+
+  def validate_no_amount_used
+    if amount_used > 0
+      errors.add(:amount_used, 'is greater than zero. Can not delete store credit')
+    end
+  end
+
+  def associate_credit_type
+    unless type_id
+      credit_type_name =
+        if category.try(:non_expiring?)
+          Spree::StoreCreditType::NON_EXPIRING
+        else
+          Spree::StoreCreditType::EXPIRING
+        end
+      self.credit_type = Spree::StoreCreditType.find_by(name: credit_type_name)
+    end
+  end
+end

data/app/models/spree/store_credit_category.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Spree::StoreCreditCategory < Spree::Base
+  class_attribute :non_expiring_credit_types
+  self.non_expiring_credit_types = [Spree::StoreCreditType::NON_EXPIRING]
+
+  class_attribute :reimbursement_category_name
+  self.reimbursement_category_name = I18n.t('spree.store_credit_category.default')
+
+  def self.reimbursement_category(_reimbursement)
+    Spree::StoreCreditCategory.find_by(name: reimbursement_category_name) ||
+      Spree::StoreCreditCategory.first
+  end
+
+  def non_expiring?
+    self.class.non_expiring_credit_types.include? name
+  end
+end

data/app/models/spree/store_credit_event.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'discard'
+
+module Spree
+  class StoreCreditEvent < Spree::Base
+    acts_as_paranoid
+    include Spree::ParanoiaDeprecations
+
+    include Discard::Model
+    self.discard_column = :deleted_at
+
+    belongs_to :store_credit
+    belongs_to :originator, polymorphic: true
+    belongs_to :update_reason, class_name: "Spree::StoreCreditUpdateReason"
+
+    validates_presence_of :update_reason, if: :action_requires_reason?
+
+    NON_EXPOSED_ACTIONS = [Spree::StoreCredit::ELIGIBLE_ACTION, Spree::StoreCredit::AUTHORIZE_ACTION]
+
+    scope :exposed_events, -> { exposable_actions.not_invalidated }
+    scope :exposable_actions, -> { where.not(action: NON_EXPOSED_ACTIONS) }
+    scope :not_invalidated, -> { joins(:store_credit).where(spree_store_credits: { invalidated_at: nil }) }
+    scope :chronological, -> { order(:created_at) }
+    scope :reverse_chronological, -> { order(created_at: :desc) }
+
+    delegate :currency, to: :store_credit
+
+    def capture_action?
+      action == Spree::StoreCredit::CAPTURE_ACTION
+    end
+
+    def authorization_action?
+      action == Spree::StoreCredit::AUTHORIZE_ACTION
+    end
+
+    def action_requires_reason?
+      [Spree::StoreCredit::ADJUSTMENT_ACTION, Spree::StoreCredit::INVALIDATE_ACTION].include?(action)
+    end
+
+    def display_amount
+      Spree::Money.new(amount, { currency: currency })
+    end
+
+    def display_user_total_amount
+      Spree::Money.new(user_total_amount, { currency: currency })
+    end
+
+    def display_remaining_amount
+      Spree::Money.new(amount_remaining, { currency: currency })
+    end
+
+    def display_event_date
+      I18n.l(created_at.to_date, format: :long)
+    end
+
+    def display_action
+      return if NON_EXPOSED_ACTIONS.include?(action)
+      I18n.t("spree.store_credit.display_action.#{action}")
+    end
+
+    def order
+      Spree::Payment.find_by(response_code: authorization_code).try(:order)
+    end
+  end
+end

data/app/models/spree/store_credit_type.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Spree
+  class StoreCreditType < Spree::Base
+    EXPIRING = 'Expiring'
+    NON_EXPIRING = 'Non-expiring'
+    DEFAULT_TYPE_NAME = EXPIRING
+    has_many :store_credits, class_name: 'Spree::StoreCredit', foreign_key: 'type_id'
+  end
+end

data/app/models/spree/store_credit_update_reason.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class Spree::StoreCreditUpdateReason < Spree::Base
+end

data/app/models/spree/store_payment_method.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class StorePaymentMethod < Spree::Base
+    belongs_to :store, inverse_of: :store_payment_methods
+    belongs_to :payment_method, inverse_of: :store_payment_methods
+  end
+end

data/app/models/spree/store_selector/by_server_name.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Default implementation for finding the current store is given an HTTP request
+#
+# This is the new default behaviour, starting in Solidus 2.3.0. For the old
+# behaviour see Spree::StoreSelector::Legacy.
+#
+# This attempts to find a Spree::Store with a URL matching the domain name of
+# the request exactly. Failing that it will return the store marked as default.
+module Spree
+  module StoreSelector
+    class ByServerName
+      def initialize(request)
+        @request = request
+      end
+
+      # Chooses the current store based on a request.
+      # @return [Spree::Store]
+      def store
+        server_name = @request.env['SERVER_NAME']
+
+        # We select a store which either matches our server name, or is default.
+        # We sort by `default ASC` so that a store matching SERVER_NAME will come
+        # first, and we will find that instead of the default.
+        store = Spree::Store.where(url: server_name).or(Store.where(default: true)).order(default: :asc).first
+
+        # Provide a fallback, mostly for legacy/testing purposes
+        store || Spree::Store.new
+      end
+    end
+  end
+end

data/app/models/spree/store_selector/legacy.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+# This class provides the old behaviour for finding a matching Spree::Store
+# based on a request.
+#
+# To enable this, somewhere inside config/initializers/ add
+#
+#     Spree::Config.current_store_selector_class = Spree::StoreSelector::Legacy
+#
+# This classes behaviour is somewhat complicated and has issues, which is why
+# it has been replaced with Spree::StoreSelector::ByServerName by default.
+#
+# It will:
+# * Find a "store_key"
+#   * from the HTTP_SPREE_STORE header, if it exists
+#   * or the server's domain name if HTTP_SPREE_STORE isn't set
+# * Find a store, using the first match of:
+#   * having a code matching the store_key exactly
+#   * having a url which contains the store_key anywhere as a substring
+#   * has default set to true
+#
+module Spree
+  module StoreSelector
+    class Legacy
+      def initialize(request)
+        @request = request
+      end
+
+      # Chooses the current store based on a request.
+      # Checks request headers for HTTP_SPREE_STORE and falls back to
+      # looking up by the requesting server's name.
+      # @return [Spree::Store]
+      def store
+        current_store =
+          if store_key
+            Spree::Store.find_by(code: store_key) ||
+              Store.where("url like ?", "%#{store_key}%").first
+          end
+
+        current_store || Spree::Store.default
+      end
+
+      private
+
+      def store_key
+        @request.headers['HTTP_SPREE_STORE'] || @request.env['SERVER_NAME']
+      end
+    end
+  end
+end

data/app/models/spree/store_shipping_method.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class StoreShippingMethod < Spree::Base
+    belongs_to :store, inverse_of: :store_shipping_methods
+    belongs_to :shipping_method, inverse_of: :store_shipping_methods
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Spree
+  module Tax
+    # Simple object used to hold tax data for an item.
+    #
+    # This generic object will hold the amount of tax that should be applied to
+    # an item. (Either a {Spree::LineItem} or a {Spree::Shipment}.)
+    #
+    # @attr_reader [Integer] item_id the {Spree::LineItem} or {Spree::Shipment} ID
+    # @attr_reader [String] label information about the taxes
+    # @attr_reader [Spree::TaxRate] tax_rate will be used as the source for tax
+    #   adjustments
+    # @attr_reader [BigDecimal] amount the amount of tax applied to the item
+    # @attr_reader [Boolean] included_in_price whether the amount is included
+    #   in the items price, or additional tax.
+    class ItemTax
+      include ActiveModel::Model
+      attr_accessor :item_id, :label, :tax_rate, :amount, :included_in_price
+    end
+  end
+end