harpiya_core 4.3.0.alpha

data/app/models/harpiya/payment_capture_event.rb

@@ -0,0 +1,9 @@
+module Harpiya
+  class PaymentCaptureEvent < Harpiya::Base
+    belongs_to :payment, class_name: 'Harpiya::Payment'
+
+    def display_amount
+      Harpiya::Money.new(amount, currency: payment.currency)
+    end
+  end
+end

data/app/models/harpiya/payment_method.rb

@@ -0,0 +1,87 @@
+module Harpiya
+  class PaymentMethod < Harpiya::Base
+    acts_as_paranoid
+    acts_as_list
+
+    DISPLAY = [:both, :front_end, :back_end].freeze
+
+    scope :active,                 -> { where(active: true).order(position: :asc) }
+    scope :available,              -> { active.where(display_on: [:front_end, :back_end, :both]) }
+    scope :available_on_front_end, -> { active.where(display_on: [:front_end, :both]) }
+    scope :available_on_back_end,  -> { active.where(display_on: [:back_end, :both]) }
+
+    validates :name, presence: true
+
+    has_and_belongs_to_many :stores
+
+    with_options dependent: :restrict_with_error do
+      has_many :payments, class_name: 'Harpiya::Payment', inverse_of: :payment_method
+      has_many :credit_cards, class_name: 'Harpiya::CreditCard'
+    end
+
+    def self.providers
+      Rails.application.config.harpiya.payment_methods
+    end
+
+    def provider_class
+      raise ::NotImplementedError, 'You must implement provider_class method for this gateway.'
+    end
+
+    # The class that will process payments for this payment type, used for @payment.source
+    # e.g. CreditCard in the case of a the Gateway payment type
+    # nil means the payment method doesn't require a source e.g. check
+    def payment_source_class
+      raise ::NotImplementedError, 'You must implement payment_source_class method for this gateway.'
+    end
+
+    def method_type
+      type.demodulize.downcase
+    end
+
+    def self.find_with_destroyed(*args)
+      unscoped { find(*args) }
+    end
+
+    def payment_profiles_supported?
+      false
+    end
+
+    def source_required?
+      true
+    end
+
+    # Custom gateways should redefine this method. See Gateway implementation
+    # as an example
+    def reusable_sources(_order)
+      []
+    end
+
+    def auto_capture?
+      auto_capture.nil? ? Harpiya::Config[:auto_capture] : auto_capture
+    end
+
+    def supports?(_source)
+      true
+    end
+
+    def cancel(_response)
+      raise ::NotImplementedError, 'You must implement cancel method for this payment method.'
+    end
+
+    def store_credit?
+      self.class == Harpiya::PaymentMethod::StoreCredit
+    end
+
+    # Custom PaymentMethod/Gateway can redefine this method to check method
+    # availability for concrete order.
+    def available_for_order?(_order)
+      true
+    end
+
+    def available_for_store?(store)
+      return true if store.blank?
+
+      store_ids.include?(store.id)
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Harpiya
+  class PaymentMethod::Check < ::Harpiya::PaymentMethod
+    def actions
+      %w{capture void}
+    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 cancel(*)
+      simulated_successful_billing_response
+    end
+
+    def void(*)
+      simulated_successful_billing_response
+    end
+
+    def source_required?
+      false
+    end
+
+    def credit(*)
+      simulated_successful_billing_response
+    end
+
+    private
+
+    def simulated_successful_billing_response
+      ActiveMerchant::Billing::Response.new(true, '', {}, {})
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+module Harpiya
+  class PaymentMethod::StoreCredit < ::Harpiya::PaymentMethod
+    def payment_source_class
+      ::Harpiya::StoreCredit
+    end
+
+    def can_capture?(payment)
+      ['checkout', 'pending'].include?(payment.state)
+    end
+
+    def can_void?(payment)
+      payment.pending?
+    end
+
+    def authorize(amount_in_cents, store_credit, gateway_options = {})
+      if store_credit.nil?
+        ActiveMerchant::Billing::Response.new(false, Harpiya.t('store_credit_payment_method.unable_to_find'), {}, {})
+      else
+        action = lambda do |store_credit|
+          store_credit.authorize(
+            amount_in_cents / 100.0.to_d,
+            gateway_options[:currency],
+            action_originator: gateway_options[:originator]
+          )
+        end
+        handle_action_call(store_credit, action, :authorize)
+      end
+    end
+
+    def capture(amount_in_cents, auth_code, gateway_options = {})
+      action = lambda do |store_credit|
+        store_credit.capture(
+          amount_in_cents / 100.0.to_d,
+          auth_code,
+          gateway_options[:currency],
+          action_originator: gateway_options[:originator]
+        )
+      end
+      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: Harpiya::StoreCredit::ELIGIBLE_ACTION
+      )
+      event = eligible_events.detect do |eligible_event|
+        store_credit.store_credit_events.where(authorization_code: eligible_event.authorization_code).
+          where.not(action: Harpiya::StoreCredit::ELIGIBLE_ACTION).empty?
+      end
+
+      if event.blank?
+        ActiveMerchant::Billing::Response.new(false, Harpiya.t('store_credit_payment_method.unable_to_find'), {}, {})
+      else
+        capture(amount_in_cents, event.authorization_code, gateway_options)
+      end
+    end
+
+    def void(auth_code, gateway_options = {})
+      action = lambda do |store_credit|
+        store_credit.void(auth_code, action_originator: gateway_options[:originator])
+      end
+      handle_action(action, :void, auth_code)
+    end
+
+    def credit(amount_in_cents, auth_code, gateway_options)
+      action = lambda do |store_credit|
+        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
+
+    def cancel(auth_code)
+      store_credit_event = StoreCreditEvent.find_by(authorization_code: auth_code,
+                                                    action: Harpiya::StoreCredit::CAPTURE_ACTION)
+      store_credit = store_credit_event.try(:store_credit)
+
+      if !store_credit_event || !store_credit
+        handle_action(nil, :cancel, false)
+      else
+        action = lambda do |store_credit|
+          store_credit.credit(store_credit_event.amount, auth_code, store_credit.currency)
+        end
+        handle_action(action, :cancel, auth_code)
+      end
+    end
+
+    def source_required?
+      true
+    end
+
+    def available_for_order?(order)
+      order.could_use_store_credit?
+    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,
+            Harpiya.t('store_credit_payment_method.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 = StoreCreditEvent.find_by(authorization_code: auth_code).try(:store_credit)
+
+      if store_credit.nil?
+        ActiveMerchant::Billing::Response.new(
+          false,
+          Harpiya.t('store_credit_payment_method.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
+  end
+end

data/app/models/harpiya/preference.rb

@@ -0,0 +1,5 @@
+class Harpiya::Preference < Harpiya::Base
+  serialize :value
+
+  validates :key, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+end

data/app/models/harpiya/preferences/configuration.rb

@@ -0,0 +1,68 @@
+# This takes the preferrable methods and adds some
+# syntatic sugar to access the preferences
+#
+# class App < Configuration
+#   preference :color, :string
+# end
+#
+# a = App.new
+#
+# 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
+#
+#
+module Harpiya::Preferences
+  class Configuration
+    include Harpiya::Preferences::Preferable
+
+    def configure
+      yield(self) if block_given?
+    end
+
+    def preferences
+      ::Harpiya::Preferences::ScopedStore.new(self.class.name.underscore)
+    end
+
+    def reset
+      preferences.each do |name, _value|
+        set_preference name, preference_default(name)
+      end
+    end
+
+    alias [] get_preference
+    alias []= set_preference
+
+    alias get get_preference
+
+    def set(*args)
+      options = args.extract_options!
+      options.each do |name, value|
+        set_preference name, value
+      end
+
+      set_preference args[0], args[1] if args.size == 2
+    end
+
+    def method_missing(method, *args)
+      name = method.to_s.delete('=')
+      if has_preference? name
+        if method.to_s =~ /=$/
+          set_preference(name, args.first)
+        else
+          get_preference name
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/app/models/harpiya/preferences/preferable.rb

@@ -0,0 +1,133 @@
+# Preferable allows defining preference accessor methods.
+#
+# A class including Preferable must implement #preferences which should return
+# an object responding to .fetch(key), []=(key, val), and .delete(key).
+#
+# The generated writer method performs typecasting before assignment into the
+# preferences object.
+#
+# Examples:
+#
+#   # Harpiya::Base includes Preferable and defines preferences as a serialized
+#   # column.
+#   class Settings < Harpiya::Base
+#     preference :color,       :string,  default: 'red'
+#     preference :temperature, :integer, default: 21
+#   end
+#
+#   s = Settings.new
+#   s.preferred_color # => 'red'
+#   s.preferred_temperature # => 21
+#
+#   s.preferred_color = 'blue'
+#   s.preferred_color # => 'blue'
+#
+#   # Typecasting is performed on assignment
+#   s.preferred_temperature = '24'
+#   s.preferred_temperature # => 24
+#
+#   # Modifications have been made to the .preferences hash
+#   s.preferences #=> {color: 'blue', temperature: 24}
+#
+#   # Save the changes. All handled by activerecord
+#   s.save!
+module Harpiya::Preferences::Preferable
+  extend ActiveSupport::Concern
+
+  included do
+    extend Harpiya::Preferences::PreferableClassMethods
+  end
+
+  def get_preference(name)
+    has_preference! name
+    send self.class.preference_getter_method(name)
+  end
+
+  def set_preference(name, value)
+    has_preference! name
+    send self.class.preference_setter_method(name), value
+  end
+
+  def preference_type(name)
+    has_preference! name
+    send self.class.preference_type_getter_method(name)
+  end
+
+  def preference_default(name)
+    has_preference! name
+    send self.class.preference_default_getter_method(name)
+  end
+
+  def has_preference!(name)
+    raise NoMethodError, "#{name} preference not defined" unless has_preference? name
+  end
+
+  def has_preference?(name)
+    respond_to? self.class.preference_getter_method(name)
+  end
+
+  def defined_preferences
+    methods.grep(/\Apreferred_.*=\Z/).map do |pref_method|
+      pref_method.to_s.gsub(/\Apreferred_|=\Z/, '').to_sym
+    end
+  end
+
+  def default_preferences
+    Hash[
+      defined_preferences.map do |preference|
+        [preference, preference_default(preference)]
+      end
+    ]
+  end
+
+  def clear_preferences
+    preferences.keys.each { |pref| preferences.delete pref }
+  end
+
+  private
+
+  def convert_preference_value(value, type)
+    case type
+    when :string, :text
+      value.to_s
+    when :password
+      value.to_s
+    when :decimal
+      (value.presence || 0).to_s.to_d
+    when :integer
+      value.to_i
+    when :boolean
+      if value.is_a?(FalseClass) ||
+          value.nil? ||
+          value == 0 ||
+          value&.to_s =~ /^(f|false|0)$/i ||
+          (value.respond_to?(:empty?) && value.empty?)
+        false
+      else
+        true
+      end
+    when :array
+      value.is_a?(Array) ? value : Array.wrap(value)
+    when :hash
+      case value.class.to_s
+      when 'Hash'
+        value
+      when 'String'
+        # only works with hashes whose keys are strings
+        JSON.parse value.gsub('=>', ':')
+      when 'Array'
+        begin
+          value.try(:to_h)
+        rescue TypeError
+          Hash[*value]
+        rescue ArgumentError
+          raise 'An even count is required when passing an array to be converted to a hash'
+        end
+      else
+        value.class.ancestors.include?(Hash) ? value : {}
+      end
+    else
+      value
+    end
+  end
+end