solidus_core 1.0.0.pre

data/app/models/spree/store.rb

@@ -0,0 +1,38 @@
+module Spree
+  class Store < Spree::Base
+    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}%") }
+
+    def self.current(domain = nil)
+      current_store = domain ? Store.by_url(domain).first : nil
+      current_store || Store.default
+    end
+
+    def self.default
+      where(default: true).first || new
+    end
+
+    private
+
+    def ensure_default_exists_and_is_unique
+      if default
+        Store.where.not(id: id).update_all(default: false)
+      elsif 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,267 @@
+class Spree::StoreCredit < ActiveRecord::Base
+  acts_as_paranoid
+
+  VOID_ACTION       = 'void'
+  CREDIT_ACTION     = 'credit'
+  CAPTURE_ACTION    = 'capture'
+  ELIGIBLE_ACTION   = 'eligible'
+  AUTHORIZE_ACTION  = 'authorize'
+  ALLOCATION_ACTION = 'allocation'
+
+  DEFAULT_CREATED_BY_EMAIL = "spree@example.com"
+
+  belongs_to :user, class_name: Spree.user_class.to_s
+  belongs_to :created_by, class_name: Spree.user_class.to_s
+  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') }
+
+  before_validation :associate_credit_type
+  after_save :store_event
+  before_destroy :validate_no_amount_used
+
+  attr_accessor :action, :action_amount, :action_originator, :action_authorization_code
+
+  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: self.amount_authorized + amount,
+      })
+      authorization_code
+    else
+      errors.add(:base, Spree.t('store_credit.insufficient_authorized_amount'))
+      false
+    end
+  end
+
+  def validate_authorization(amount, order_currency)
+    if amount_remaining.to_d < amount.to_d
+      errors.add(:base, Spree.t('store_credit.insufficient_funds'))
+    elsif currency != order_currency
+      errors.add(:base, Spree.t('store_credit.currency_mismatch'))
+    end
+    return 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, Spree.t('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: self.amount_used + amount,
+          amount_authorized: self.amount_authorized - auth_event.amount,
+        })
+        authorization_code
+      end
+    else
+      errors.add(:base, Spree.t('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)
+      self.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, Spree.t('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, Spree.t('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, Spree.t('store_credit.unable_to_credit', auth_code: authorization_code))
+      false
+    end
+  end
+
+  def actions
+    [CAPTURE_ACTION, VOID_ACTION, CREDIT_ACTION]
+  end
+
+  def can_capture?(payment)
+    payment.pending? || payment.checkout?
+  end
+
+  def can_void?(payment)
+    payment.pending?
+  end
+
+  def can_credit?(payment)
+    payment.completed? && payment.credit_allowed > 0
+  end
+
+  def generate_authorization_code
+    "#{self.id}-SC-#{Time.now.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 invalidate
+    if invalidateable?
+      touch(:invalidated_at)
+    else
+      errors.add(:invalidated_at, Spree.t("store_credit.errors.cannot_invalidate_uncaptured_authorization"))
+      return 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: self.user_id,
+      category_id: self.category_id,
+      created_by_id: self.created_by_id,
+      currency: self.currency,
+      type_id: self.type_id,
+      memo: credit_allocation_memo,
+    }
+  end
+
+  def credit_allocation_memo
+    Spree.t("store_credit.credit_allocation_memo", id: self.id)
+  end
+
+  def store_event
+    return unless amount_changed? || amount_used_changed? || amount_authorized_changed? || action == ELIGIBLE_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,
+      user_total_amount: user.total_available_store_credit,
+      originator: action_originator,
+    })
+  end
+
+  def amount_used_less_than_or_equal_to_amount
+    return true if amount_used.nil?
+
+    if amount_used > amount
+      errors.add(:amount_used, Spree.t('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, Spree.t('admin.store_credits.errors.amount_authorized_exceeds_total_credit'))
+    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 self.type_id
+      credit_type_name = category.try(:non_expiring?) ? Spree.t("store_credit.non_expiring") : Spree.t("store_credit.expiring")
+      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,17 @@
+class Spree::StoreCreditCategory < ActiveRecord::Base
+  class_attribute :non_expiring_credit_types
+  self.non_expiring_credit_types = [Spree.t("store_credit.non_expiring")]
+
+  class_attribute :reimbursement_category_name
+  self.reimbursement_category_name = Spree.t("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,52 @@
+module Spree
+  class StoreCreditEvent < ActiveRecord::Base
+    acts_as_paranoid
+
+    belongs_to :store_credit
+    belongs_to :originator, polymorphic: true
+
+    scope :exposed_events, -> { exposable_actions.not_invalidated }
+    scope :exposable_actions, -> { where.not(action: [Spree::StoreCredit::ELIGIBLE_ACTION, Spree::StoreCredit::AUTHORIZE_ACTION]) }
+    scope :not_invalidated, -> { joins(:store_credit).where(spree_store_credits: { invalidated_at: nil }) }
+    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 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_event_date
+      I18n.l(created_at.to_date, format: :long)
+    end
+
+    def display_action
+      case action
+      when Spree::StoreCredit::CAPTURE_ACTION
+        Spree.t('store_credit.captured')
+      when Spree::StoreCredit::AUTHORIZE_ACTION
+        Spree.t('store_credit.authorized')
+      when Spree::StoreCredit::ALLOCATION_ACTION
+        Spree.t('store_credit.allocated')
+      when Spree::StoreCredit::VOID_ACTION, Spree::StoreCredit::CREDIT_ACTION
+        Spree.t('store_credit.credit')
+      end
+    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,6 @@
+module Spree
+  class StoreCreditType < ActiveRecord::Base
+    DEFAULT_TYPE_NAME = Spree.t("store_credit.expiring")
+    has_many :store_credits, class_name: 'Spree::StoreCredit', foreign_key: 'type_id'
+  end
+end

data/app/models/spree/tax_category.rb

@@ -0,0 +1,19 @@
+module Spree
+  class TaxCategory < Spree::Base
+    acts_as_paranoid
+    validates :name, presence: true, uniqueness: { scope: :deleted_at, allow_blank: true }
+
+    has_many :tax_rates, dependent: :destroy, inverse_of: :tax_category
+    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: self.id).update_all(is_default: false, updated_at: Time.now)
+      end
+    end
+  end
+end

data/app/models/spree/tax_rate.rb

@@ -0,0 +1,199 @@
+module Spree
+  class DefaultTaxZoneValidator < ActiveModel::Validator
+    def validate(record)
+      if record.included_in_price
+        record.errors.add(:included_in_price, Spree.t(:included_price_validation)) unless Zone.default_tax
+      end
+    end
+  end
+end
+
+module Spree
+  class TaxRate < Spree::Base
+    acts_as_paranoid
+
+    # Need to deal with adjustments before calculator is destroyed.
+    before_destroy :deals_with_adjustments_for_deleted_source
+
+    include Spree::CalculatedAdjustments
+    include Spree::AdjustmentSource
+
+    belongs_to :zone, class_name: "Spree::Zone", inverse_of: :tax_rates
+    belongs_to :tax_category, class_name: "Spree::TaxCategory", inverse_of: :tax_rates
+
+    has_many :adjustments, as: :source
+
+    validates :amount, presence: true, numericality: true
+    validates :tax_category_id, presence: true
+    validates_with DefaultTaxZoneValidator
+
+    scope :by_zone, ->(zone) { where(zone_id: zone) }
+
+    # Gets the array of TaxRates appropriate for the specified order
+    def self.match(order_tax_zone)
+      return [] unless order_tax_zone
+      rates = includes(zone: { zone_members: :zoneable }).load.select do |rate|
+        # Why "potentially"?
+        # Go see the documentation for that method.
+        rate.potentially_applicable?(order_tax_zone)
+      end
+
+      # Imagine with me this scenario:
+      # You are living in Spain and you have a store which ships to France.
+      # Spain is therefore your default tax rate.
+      # When you ship to Spain, you want the Spanish rate to apply.
+      # When you ship to France, you want the French rate to apply.
+      #
+      # Normally, Spree would notice that you have two potentially applicable
+      # tax rates for one particular item.
+      # When you ship to Spain, only the Spanish one will apply.
+      # When you ship to France, you'll see a Spanish refund AND a French tax.
+      # This little bit of code at the end stops the Spanish refund from appearing.
+      #
+      # For further discussion, see #4397 and #4327.
+      rates.delete_if do |rate|
+        rate.included_in_price? &&
+        (rates - [rate]).map(&:tax_category).include?(rate.tax_category)
+      end
+    end
+
+    # Pre-tax amounts must be stored so that we can calculate
+    # correct rate amounts in the future. For example:
+    # https://github.com/spree/spree/issues/4318#issuecomment-34723428
+    def self.store_pre_tax_amount(item, rates)
+      pre_tax_amount = case item
+        when Spree::LineItem then item.discounted_amount
+        when Spree::Shipment then item.discounted_cost
+        end
+
+      included_rates = rates.select(&:included_in_price)
+      if included_rates.any?
+        pre_tax_amount /= (1 + included_rates.map(&:amount).sum)
+      end
+
+      item.update_column(:pre_tax_amount, pre_tax_amount.round(2))
+    end
+
+    # This method is best described by the documentation on #potentially_applicable?
+    def self.adjust(order_tax_zone, items)
+      rates = self.match(order_tax_zone)
+      tax_categories = rates.map(&:tax_category)
+      relevant_items, non_relevant_items = items.partition { |item| tax_categories.include?(item.tax_category) }
+      unless relevant_items.empty?
+        Spree::Adjustment.where(adjustable: relevant_items).tax.destroy_all # using destroy_all to ensure adjustment destroy callback fires.
+      end
+      relevant_items.each do |item|
+        relevant_rates = rates.select { |rate| rate.tax_category == item.tax_category }
+        store_pre_tax_amount(item, relevant_rates)
+        relevant_rates.each do |rate|
+          rate.adjust(order_tax_zone, item)
+        end
+      end
+      non_relevant_items.each do |item|
+        if item.adjustments.tax.present?
+          item.adjustments.tax.destroy_all # using destroy_all to ensure adjustment destroy callback fires.
+          item.update_columns pre_tax_amount: 0
+        end
+      end
+    end
+
+    # Tax rates can *potentially* be applicable to an order.
+    # We do not know if they are/aren't 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 (default tax zone)
+    #   - 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.
+    def potentially_applicable?(order_tax_zone)
+      # If the rate's zone matches the order's tax zone, then it's applicable.
+      self.zone == order_tax_zone ||
+      # If the rate's zone *contains* the order's tax zone, then it's applicable.
+      self.zone.contains?(order_tax_zone) ||
+      # 1) The rate's zone is the default zone, then it's always applicable.
+      (self.included_in_price? && self.zone.default_tax)
+    end
+
+    # Creates necessary tax adjustments for the order.
+    def adjust(order_tax_zone, item)
+      amount = compute_amount(item)
+      return if amount == 0
+
+      included = included_in_price && default_zone_or_zone_match?(order_tax_zone)
+
+      if amount < 0
+        label = Spree.t(:refund) + ' ' + create_label
+      end
+
+      self.adjustments.create!({
+        :adjustable => item,
+        :amount => amount,
+        :order_id => item.order_id,
+        :label => label || create_label,
+        :included => included
+      })
+    end
+
+    # This method is used by Adjustment#update to recalculate the cost.
+    def compute_amount(item)
+      if included_in_price
+        if default_zone_or_zone_match?(item.order.tax_zone)
+          calculator.compute(item)
+        else
+          # In this case, it's a refund.
+          calculator.compute(item) * - 1
+        end
+      else
+        calculator.compute(item)
+      end
+    end
+
+    def default_zone_or_zone_match?(order_tax_zone)
+      default_tax = Zone.default_tax
+      (default_tax && default_tax.contains?(order_tax_zone)) || order_tax_zone == self.zone
+    end
+
+    private
+
+      def create_label
+        label = ""
+        label << (name.present? ? name : tax_category.name) + " "
+        label << (show_rate_in_label? ? "#{amount * 100}%" : "")
+        label << " (#{Spree.t(:included_in_price)})" if included_in_price?
+        label
+      end
+
+  end
+end