solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/payment_method/check.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Spree
+  class PaymentMethod::Check < PaymentMethod
+    def actions
+      %w{capture void credit}
+    end
+
+    # Indicates whether its possible to capture the payment
+    def can_capture?(payment)
+      ['checkout', 'pending'].include?(payment.state)
+    end
+
+    # Indicates whether its possible to void the payment.
+    def can_void?(payment)
+      payment.state != 'void'
+    end
+
+    def capture(*)
+      simulated_successful_billing_response
+    end
+
+    def void(*)
+      simulated_successful_billing_response
+    end
+    alias_method :try_void, :void
+
+    def credit(*)
+      simulated_successful_billing_response
+    end
+
+    def source_required?
+      false
+    end
+
+    def simulated_successful_billing_response
+      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+    end
+  end
+end

data/app/models/spree/payment_method/credit_card.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Spree
+  # An implementation of a `Spree::PaymentMethod` for credit card payments.
+  #
+  # It's a good candidate as base class for other credit card based payment methods.
+  #
+  # See https://github.com/solidusio/solidus_gateway/ for
+  # officially supported payment method implementations.
+  #
+  class PaymentMethod::CreditCard < PaymentMethod
+    def payment_source_class
+      Spree::CreditCard
+    end
+
+    def partial_name
+      deprecated_method_type_override || 'gateway'
+    end
+
+    def supports?(source)
+      return true unless gateway_class.respond_to? :supports?
+      return true if source.brand && gateway_class.supports?(source.brand)
+      source.has_payment_profile?
+    end
+
+    def reusable_sources_by_order(order)
+      source_ids = order.payments.where(payment_method_id: id).pluck(:source_id).uniq
+      payment_source_class.where(id: source_ids).select(&:reusable?)
+    end
+    alias_method :sources_by_order, :reusable_sources_by_order
+    deprecate sources_by_order: :reusable_sources_by_order, deprecator: Spree::Deprecation
+
+    def reusable_sources(order)
+      if order.completed?
+        reusable_sources_by_order(order)
+      elsif order.user_id
+        order.user.wallet.wallet_payment_sources.map(&:payment_source).select(&:reusable?)
+      else
+        []
+      end
+    end
+  end
+end

data/app/models/spree/payment_method/simple_bogus_credit_card.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Spree
+  # Bogus Gateway that doesn't support payment profiles.
+  class PaymentMethod::SimpleBogusCreditCard < PaymentMethod::BogusCreditCard
+    def payment_profiles_supported?
+      false
+    end
+
+    def authorize(_money, credit_card, _options = {})
+      if VALID_CCS.include? credit_card.number
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
+      end
+    end
+
+    def purchase(_money, credit_card, _options = {})
+      if VALID_CCS.include? credit_card.number
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
+      else
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
+      end
+    end
+  end
+end

data/app/models/spree/payment_method/store_credit.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Spree
+  class PaymentMethod::StoreCredit < PaymentMethod
+    def payment_source_class
+      ::Spree::StoreCredit
+    end
+
+    def authorize(amount_in_cents, provided_store_credit, gateway_options = {})
+      if provided_store_credit.nil?
+        ActiveMerchant::Billing::Response.new(false, I18n.t('spree.store_credit.unable_to_find'), {}, {})
+      else
+        action = ->(store_credit) {
+          store_credit.authorize(
+            amount_in_cents / 100.0.to_d,
+            gateway_options[:currency],
+            action_originator: gateway_options[:originator]
+          )
+        }
+        handle_action_call(provided_store_credit, action, :authorize)
+      end
+    end
+
+    def capture(amount_in_cents, auth_code, gateway_options = {})
+      action = ->(store_credit) {
+        store_credit.capture(
+          amount_in_cents / 100.0.to_d,
+          auth_code,
+          gateway_options[:currency],
+          action_originator: gateway_options[:originator]
+        )
+      }
+
+      handle_action(action, :capture, auth_code)
+    end
+
+    def purchase(amount_in_cents, store_credit, gateway_options = {})
+      eligible_events = store_credit.store_credit_events.where(amount: amount_in_cents / 100.0.to_d, action: Spree::StoreCredit::ELIGIBLE_ACTION)
+      event = eligible_events.find do |eligible_event|
+        store_credit.store_credit_events.where(authorization_code: eligible_event.authorization_code)
+                                        .where.not(action: Spree::StoreCredit::ELIGIBLE_ACTION).empty?
+      end
+
+      if event.blank?
+        ActiveMerchant::Billing::Response.new(false, I18n.t('spree.store_credit.unable_to_find'), {}, {})
+      else
+        capture(amount_in_cents, event.authorization_code, gateway_options)
+      end
+    end
+
+    def void(auth_code, gateway_options = {})
+      action = ->(store_credit) {
+        store_credit.void(auth_code, action_originator: gateway_options[:originator])
+      }
+      handle_action(action, :void, auth_code)
+    end
+
+    def credit(amount_in_cents, auth_code, gateway_options = {})
+      action = ->(store_credit) do
+        currency = gateway_options[:currency] || store_credit.currency
+        originator = gateway_options[:originator]
+
+        store_credit.credit(amount_in_cents / 100.0.to_d, auth_code, currency, action_originator: originator)
+      end
+
+      handle_action(action, :credit, auth_code)
+    end
+
+    # @see Spree::PaymentMethod#try_void
+    def try_void(payment)
+      auth_code = payment.response_code
+      store_credit_event = auth_or_capture_event(auth_code)
+      store_credit = store_credit_event.try(:store_credit)
+
+      if store_credit_event.nil? || store_credit.nil?
+        ActiveMerchant::Billing::Response.new(false, '', {}, {})
+      elsif store_credit_event.capture_action?
+        false # payment#cancel! handles the refund
+      elsif store_credit_event.authorization_action?
+        void(auth_code)
+      else
+        ActiveMerchant::Billing::Response.new(false, '', {}, {})
+      end
+    end
+
+    def source_required?
+      true
+    end
+
+    private
+
+    def handle_action_call(store_credit, action, action_name, auth_code = nil)
+      store_credit.with_lock do
+        if response = action.call(store_credit)
+          # note that we only need to return the auth code on an 'auth', but it's innocuous to always return
+          ActiveMerchant::Billing::Response.new(true,
+                                                I18n.t('spree.store_credit.successful_action', action: action_name),
+                                                {}, { authorization: auth_code || response })
+        else
+          ActiveMerchant::Billing::Response.new(false, store_credit.errors.full_messages.join, {}, {})
+        end
+      end
+    end
+
+    def handle_action(action, action_name, auth_code)
+      # Find first event with provided auth_code
+      store_credit = Spree::StoreCreditEvent.find_by(authorization_code: auth_code).try(:store_credit)
+
+      if store_credit.nil?
+        ActiveMerchant::Billing::Response.new(false, I18n.t('spree.store_credit.unable_to_find_for_action', auth_code: auth_code, action: action_name), {}, {})
+      else
+        handle_action_call(store_credit, action, action_name, auth_code)
+      end
+    end
+
+    def auth_or_capture_event(auth_code)
+      capture_event = Spree::StoreCreditEvent.find_by(authorization_code: auth_code, action: Spree::StoreCredit::CAPTURE_ACTION)
+      auth_event = Spree::StoreCreditEvent.find_by(authorization_code: auth_code, action: Spree::StoreCredit::AUTHORIZE_ACTION)
+      capture_event || auth_event
+    end
+  end
+end

data/app/models/spree/payment_method.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require 'discard'
+require 'spree/preferences/statically_configurable'
+
+module Spree
+  # A base class which is used for implementing payment methods.
+  #
+  # Uses STI (single table inheritance) to store all implemented payment methods
+  # in one table (+spree_payment_methods+).
+  #
+  # This class is not meant to be instantiated. Please create instances of concrete payment methods.
+  #
+  class PaymentMethod < Spree::Base
+    preference :server, :string, default: 'test'
+    preference :test_mode, :boolean, default: true
+
+    acts_as_paranoid
+    include Spree::ParanoiaDeprecations
+
+    include Discard::Model
+    self.discard_column = :deleted_at
+
+    acts_as_list
+
+    # @private
+    def self.const_missing(name)
+      if name == :DISPLAY
+        const_set(:DISPLAY, [:both, :front_end, :back_end])
+      else
+        super
+      end
+    end
+
+    validates :name, :type, presence: true
+
+    has_many :payments, class_name: "Spree::Payment", inverse_of: :payment_method
+    has_many :credit_cards, class_name: "Spree::CreditCard"
+    has_many :store_payment_methods, inverse_of: :payment_method
+    has_many :stores, through: :store_payment_methods
+
+    scope :ordered_by_position, -> { order(:position) }
+    scope :active, -> { where(active: true) }
+    scope :available_to_users, -> { where(available_to_users: true) }
+    scope :available_to_admin, -> { where(available_to_admin: true) }
+    scope :available_to_store, ->(store) do
+      raise ArgumentError, "You must provide a store" if store.nil?
+      store.payment_methods.empty? ? all : where(id: store.payment_method_ids)
+    end
+
+    delegate :authorize, :purchase, :capture, :void, :credit, to: :gateway
+
+    include Spree::Preferences::StaticallyConfigurable
+
+    # Custom ModelName#human implementation to ensure we don't refer to
+    # subclasses as just "PaymentMethod"
+    class ModelName < ActiveModel::Name
+      # Similar to ActiveModel::Name#human, but skips lookup_ancestors
+      def human(options = {})
+        defaults = [
+          i18n_key,
+          options[:default],
+          @human
+        ].compact
+        options = { scope: [:activerecord, :models], count: 1, default: defaults }.merge!(options.except(:default))
+        I18n.translate(defaults.shift, options)
+      end
+    end
+
+    class << self
+      # @deprecated Use Spree::Config.environment.payment_methods instead
+      def providers
+        Spree::Deprecation.warn 'Spree::PaymentMethod.providers is deprecated and will be deleted in Solidus 3.0. ' \
+          'Please use Rails.application.config.spree.payment_methods instead'
+        Spree::Config.environment.payment_methods
+      end
+
+      # @deprecated Use {.active}, {.available_to_users}, and {.available_to_admin} scopes instead.
+      def available(display_on = nil, store: nil)
+        Spree::Deprecation.warn "Spree::PaymentMethod.available is deprecated."\
+          "Please use .active, .available_to_users, and .available_to_admin scopes instead."\
+          "For payment methods associated with a specific store, use Spree::PaymentMethod.available_to_store(your_store)"\
+          " as the base applying any further filtering"
+
+        display_on = display_on.to_s
+
+        available_payment_methods =
+          case display_on
+          when 'front_end'
+            active.available_to_users
+          when 'back_end'
+            active.available_to_admin
+          else
+            active.available_to_users.available_to_admin
+          end
+        available_payment_methods.select do |p|
+          store.nil? || store.payment_methods.empty? || store.payment_methods.include?(p)
+        end
+      end
+
+      def model_name
+        ModelName.new(self, Spree)
+      end
+
+      # @deprecated Use .active.any? instead
+      def active?
+        Spree::Deprecation.warn "#{self}.active? is deprecated. Use #{self}.active.any? instead"
+        where(type: to_s, active: true).count > 0
+      end
+
+      # @deprecated Use .with_deleted.find instead
+      def find_with_destroyed(*args)
+        Spree::Deprecation.warn "#{self}.find_with_destroyed is deprecated. Use #{self}.with_deleted.find instead"
+        unscoped { find(*args) }
+      end
+    end
+
+    # Represents the gateway of this payment method
+    #
+    # The gateway is responsible for communicating with the providers API.
+    #
+    # It implements methods for:
+    #
+    #     - authorize
+    #     - purchase
+    #     - capture
+    #     - void
+    #     - credit
+    #
+    def gateway
+      gateway_options = options
+      gateway_options.delete :login if gateway_options.key?(:login) && gateway_options[:login].nil?
+      if gateway_options[:server]
+        ActiveMerchant::Billing::Base.mode = gateway_options[:server].to_sym
+      end
+      @gateway ||= gateway_class.new(gateway_options)
+    end
+    alias_method :provider, :gateway
+    deprecate provider: :gateway, deprecator: Spree::Deprecation
+
+    # Represents all preferences as a Hash
+    #
+    # Each preference is a key holding the value(s) and gets passed to the gateway via +gateway_options+
+    #
+    # @return Hash
+    def options
+      preferences.to_hash
+    end
+
+    # The class that will store payment sources (re)usable with this payment method
+    #
+    # Used by Spree::Payment as source (e.g. Spree::CreditCard in the case of a credit card payment method).
+    #
+    # Returning nil means the payment method doesn't support storing sources (e.g. Spree::PaymentMethod::Check)
+    def payment_source_class
+      raise ::NotImplementedError, "You must implement payment_source_class method for #{self.class}."
+    end
+
+    # @deprecated Use {Spree::PaymentMethod#available_to_users=} and {Spree::PaymentMethod#available_to_admin=} instead
+    def display_on=(value)
+      Spree::Deprecation.warn "Spree::PaymentMethod#display_on= is deprecated."\
+        "Please use #available_to_users= and #available_to_admin= instead."
+      self.available_to_users = value.blank? || value == 'front_end'
+      self.available_to_admin = value.blank? || value == 'back_end'
+    end
+
+    # @deprecated Use {Spree::PaymentMethod#available_to_users} and {Spree::PaymentMethod#available_to_admin} instead
+    def display_on
+      Spree::Deprecation.warn "Spree::PaymentMethod#display_on is deprecated."\
+        "Please use #available_to_users and #available_to_admin instead."
+      if available_to_users? && available_to_admin?
+        ''
+      elsif available_to_users?
+        'front_end'
+      elsif available_to_admin?
+        'back_end'
+      else
+        'none'
+      end
+    end
+
+    # Used as partial name for your payment method
+    #
+    # Currently your payment method needs to provide these partials:
+    #
+    #     1. app/views/spree/checkout/payment/_{partial_name}.html.erb
+    #     The form your customer enters the payment information in during checkout
+    #
+    #     2. app/views/spree/checkout/existing_payment/_{partial_name}.html.erb
+    #     The payment information of your customers reusable sources during checkout
+    #
+    #     3. app/views/spree/admin/payments/source_forms/_{partial_name}.html.erb
+    #     The form an admin enters payment information in when creating orders in the backend
+    #
+    #     4. app/views/spree/admin/payments/source_views/_{partial_name}.html.erb
+    #     The view that represents your payment method on orders in the backend
+    #
+    def partial_name
+      deprecated_method_type_override || type.demodulize.downcase
+    end
+
+    # :nodoc:
+    # If method_type has been overridden, call it and return the value, otherwise return nil
+    def deprecated_method_type_override
+      if method(:method_type).owner != Spree::PaymentMethod
+        Spree::Deprecation.warn "#{method(:method_type).owner} is overriding PaymentMethod#method_type. This is deprecated and will be removed from Solidus 3.0 (override partial_name instead).", caller[1..-1]
+        method_type
+      end
+    end
+
+    def method_type
+      Spree::Deprecation.warn "method_type is deprecated and will be removed from Solidus 3.0 (use partial_name instead)", caller
+      partial_name
+    end
+
+    def payment_profiles_supported?
+      false
+    end
+
+    def source_required?
+      true
+    end
+
+    # Custom gateways can redefine this method to return reusable sources for an order.
+    # See {Spree::PaymentMethod::CreditCard#reusable_sources} as an example
+    def reusable_sources(_order)
+      []
+    end
+
+    def auto_capture?
+      auto_capture.nil? ? Spree::Config[:auto_capture] : auto_capture
+    end
+
+    # Check if given source is supported by this payment method
+    #
+    # Please implement validation logic in your payment method implementation
+    #
+    # @see Spree::PaymentMethod::CreditCard#supports?
+    def supports?(_source)
+      true
+    end
+
+    # Used by Spree::Payment#cancel!
+    #
+    # Implement `try_void` on your payment method implementation to handle void attempts.
+    # In that method return a ActiveMerchant::Billing::Response object if the void succeeds.
+    # Return +false+ or +nil+ if the void is not possible anymore - because it was already processed by the bank.
+    # Solidus will refund the amount of the payment in this case.
+    #
+    # @return [ActiveMerchant::Billing::Response] with +true+ if the void succeeded
+    # @return [ActiveMerchant::Billing::Response] with +false+ if the void failed
+    # @return [false] if it can't be voided at this time
+    #
+    def try_void(_payment)
+      raise ::NotImplementedError,
+        "You need to implement `try_void` for #{self.class.name}. In that " \
+        'return a ActiveMerchant::Billing::Response object if the void succeeds '\
+        'or `false|nil` if the void is not possible anymore. ' \
+        'Solidus will refund the amount of the payment then.'
+    end
+
+    def store_credit?
+      is_a? Spree::PaymentMethod::StoreCredit
+    end
+
+    protected
+
+    # Represents the gateway class of this payment method
+    #
+    def gateway_class
+      if respond_to? :provider_class
+        Spree::Deprecation.warn \
+          "provider_class is deprecated and will be removed from Solidus 3.0 " \
+          "(use gateway_class instead)"
+        public_send :provider_class
+      else
+        raise ::NotImplementedError, "You must implement gateway_class method for #{self.class}."
+      end
+    end
+  end
+end

data/app/models/spree/payment_source.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Spree
+  class PaymentSource < Spree::Base
+    self.abstract_class = true
+
+    belongs_to :payment_method
+
+    has_many :payments, as: :source
+    has_many :wallet_payment_sources, class_name: 'Spree::WalletPaymentSource', as: :payment_source, inverse_of: :payment_source
+
+    attr_accessor :imported
+
+    # @return [Array<String>] the actions available on this payment source
+    def actions
+      %w(capture void credit)
+    end
+
+    # @param payment [Spree::Payment] the payment we want to know if can be captured
+    # @return [Boolean] true when the payment is in the pending or checkout states
+    def can_capture?(payment)
+      payment.pending? || payment.checkout?
+    end
+
+    # @param payment [Spree::Payment] the payment we want to know if can be voided
+    # @return [Boolean] true when the payment is not failed or voided
+    def can_void?(payment)
+      !payment.failed? && !payment.void?
+    end
+
+    # Indicates whether its possible to credit the payment.  Note that most
+    # gateways require that the payment be settled first which generally
+    # happens within 12-24 hours of the transaction.
+    #
+    # @param payment [Spree::Payment] the payment we want to know if can be credited
+    # @return [Boolean] true when the payment is completed and can be credited
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
+    end
+
+    # Indicates whether this payment source can be used more than once. E.g. a
+    # credit card with a 'payment profile'.
+    def reusable?
+      false
+    end
+  end
+end

data/app/models/spree/preference.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Spree::Preference < Spree::Base
+  serialize :value
+
+  validates :key, presence: true, uniqueness: { allow_blank: true }
+end

data/app/models/spree/price.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'discard'
+
+module Spree
+  class Price < Spree::Base
+    acts_as_paranoid
+    include Spree::ParanoiaDeprecations
+
+    include Discard::Model
+    self.discard_column = :deleted_at
+
+    MAXIMUM_AMOUNT = BigDecimal('99_999_999.99')
+
+    belongs_to :variant, -> { with_deleted }, class_name: 'Spree::Variant', touch: true
+    belongs_to :country, class_name: "Spree::Country", foreign_key: "country_iso", primary_key: "iso"
+
+    delegate :product, to: :variant
+    delegate :tax_rates, to: :variant
+
+    validate :check_price
+    validates :amount, allow_nil: true, numericality: {
+      greater_than_or_equal_to: 0,
+      less_than_or_equal_to: MAXIMUM_AMOUNT
+    }
+    validates :currency, inclusion: { in: ::Money::Currency.all.map(&:iso_code), message: :invalid_code }
+    validates :country, presence: true, unless: -> { for_any_country? }
+
+    scope :currently_valid, -> { order(Arel.sql("country_iso IS NULL")).order(updated_at: :DESC, id: :DESC) }
+    scope :for_master, -> { joins(:variant).where(spree_variants: { is_master: true }) }
+    scope :for_variant, -> { joins(:variant).where(spree_variants: { is_master: false }) }
+    scope :for_any_country, -> { where(country: nil) }
+    scope :with_default_attributes, -> { where(Spree::Config.default_pricing_options.desired_attributes) }
+
+    extend DisplayMoney
+    money_methods :amount, :price
+    alias_method :money, :display_amount
+
+    self.whitelisted_ransackable_attributes = %w(amount variant_id currency country_iso)
+
+    # An alias for #amount
+    def price
+      amount
+    end
+
+    # Sets this price's amount to a new value, parsing it if the new value is
+    # a string.
+    #
+    # @param price [String, #to_d] a new amount
+    def price=(price)
+      self[:amount] = Spree::LocalizedNumber.parse(price)
+    end
+
+    def net_amount
+      amount / (1 + sum_of_vat_amounts)
+    end
+
+    def for_any_country?
+      country_iso.nil?
+    end
+
+    def display_country
+      if country_iso
+        "#{country_iso} (#{country.name})"
+      else
+        I18n.t(:any_country, scope: [:spree, :admin, :prices])
+      end
+    end
+
+    def country_iso=(country_iso)
+      self[:country_iso] = country_iso.presence
+    end
+
+    private
+
+    def sum_of_vat_amounts
+      return 0 unless variant.tax_category
+      tax_rates.included_in_price.for_country(country).sum(:amount)
+    end
+
+    def check_price
+      self.currency ||= Spree::Config[:currency]
+    end
+
+    def pricing_options
+      Spree::Config.pricing_options_class.from_price(self)
+    end
+  end
+end