spree_gateway 2.1.1 → 2.2.0

data/app/models/spree/gateway/fatzebra.rb

@@ -1,15 +0,0 @@
-module Spree
-  class Gateway::Fatzebra < Gateway
-    preference :username, :string, default: "TEST"
-    preference :token, :string, default: "TEST" 
-
-    def provider_class
-      ActiveMerchant::Billing::FatZebraGateway
-    end
-
-    # Currently no auth/capture, but coming soon...
-    def auto_capture?
-      true
-    end
-  end
-end

data/app/models/spree/gateway/linkpoint.rb

@@ -1,28 +0,0 @@
-module Spree
-  class Gateway::Linkpoint < Gateway
-    preference :login, :string
-    preference :pem, :text
-
-    def provider_class
-      ActiveMerchant::Billing::LinkpointGateway
-    end
-
-    [:authorize, :purchase, :capture, :void, :credit].each do |method|
-      define_method(method) do |*args|
-        options = add_discount_to_subtotal(args.extract_options!)
-        provider.public_send(method, *args << options)
-      end
-    end
-
-    private
-
-    # Linkpoint ignores the discount, but it will return an error if the
-    # chargetotal is different from the sum of the subtotal, tax and
-    # shipping totals.
-    def add_discount_to_subtotal(options)
-      subtotal = options.fetch(:subtotal)
-      discount = options.fetch(:discount)
-      options.merge(subtotal: subtotal + discount, discount: 0)
-    end
-  end
-end

data/app/models/spree/gateway/maxipago.rb

@@ -1,14 +0,0 @@
-module Spree
-  class Gateway::Maxipago < Gateway
-    preference :login, :string # ID
-    preference :password, :string # KEY
-
-    def provider_class
-      ActiveMerchant::Billing::MaxipagoGateway
-    end
-
-    def auto_capture?
-      true
-    end
-  end
-end

data/app/models/spree/gateway/moneris.rb

@@ -1,11 +0,0 @@
-module Spree
-  class Gateway::Moneris < Gateway
-    preference :login, :string
-    preference :password, :password
-
-    def provider_class
-      ActiveMerchant::Billing::MonerisGateway
-    end
-    
-  end
-end

data/app/models/spree/gateway/pay_junction.rb

@@ -1,16 +0,0 @@
-module Spree
-  class Gateway::PayJunction < Gateway
-    preference :login, :string
-    preference :password, :string
-
-    def provider_class
-      ActiveMerchant::Billing::PayJunctionGateway
-    end
-
-    def options_with_test_preference
-      options_without_test_preference.merge(:test => self.preferred_test_mode)
-    end
-
-    alias_method_chain :options, :test_preference
-  end
-end

data/app/models/spree/gateway/pay_pal_gateway.rb

@@ -1,12 +0,0 @@
-module Spree
-  class Gateway::PayPalGateway < Gateway
-    preference :login, :string
-    preference :password, :string
-    preference :signature, :string
-    preference :currency_code, :string
-
-    def provider_class
-      ActiveMerchant::Billing::PaypalGateway
-    end
-  end
-end

data/app/models/spree/gateway/payflow_pro.rb

@@ -1,17 +0,0 @@
-module Spree
-  class Gateway::PayflowPro < Gateway
-    preference :login, :string
-    preference :password, :password
-
-    def provider_class
-      ActiveMerchant::Billing::PayflowGateway
-    end
-
-    def options_with_test_preference
-      options_without_test_preference.merge(:test => self.preferred_test_mode)
-    end
-
-    alias_method_chain :options, :test_preference
-
-  end
-end

data/app/models/spree/gateway/paymill.rb

@@ -1,12 +0,0 @@
-module Spree
-  class Gateway::Paymill < Gateway
-
-    preference :public_key, :string
-    preference :private_key, :string
-    preference :currency, :string, :default => 'GBP'
-
-    def provider_class
-      ActiveMerchant::Billing::PaymillGateway
-    end
-  end
-end

data/app/models/spree/gateway/pin_gateway.rb

@@ -1,15 +0,0 @@
-module Spree
-  class Gateway::PinGateway < Gateway
-    preference :api_key, :string
-    preference :currency, :string, :default => 'AUD'
-
-    def provider_class
-      ActiveMerchant::Billing::PinGateway
-    end
-
-    # Pin does not appear to support authorizing transactions yet
-    def auto_capture?
-      true
-    end
-  end
-end

data/app/models/spree/gateway/sage_pay.rb

@@ -1,11 +0,0 @@
-module Spree
-  class Gateway::SagePay < Gateway
-    preference :login, :string
-    preference :password, :string
-    preference :account, :string
-
-    def provider_class
-      ActiveMerchant::Billing::SagePayGateway
-    end
-  end
-end

data/app/models/spree/gateway/samurai.rb

@@ -1,63 +0,0 @@
-module Spree
-  class Gateway::Samurai < Gateway
-    preference :login, :string
-    preference :password, :string
-    preference :processor_token, :string
-
-    def provider_class
-      ActiveMerchant::Billing::SamuraiGateway
-    end
-
-    def payment_profiles_supported?
-      true
-    end
-
-    def purchase(money, creditcard, gateway_options)
-      gateway_options[:billing_reference] = gateway_options[:order_id]
-      gateway_options[:customer_reference] = gateway_options[:customer]
-      gateway_options[:description] = "Spree Order"
-      provider.purchase(money, creditcard.gateway_customer_profile_id, gateway_options)
-    end
-
-    def authorize(money, creditcard, gateway_options)
-      gateway_options[:billing_reference] = gateway_options[:order_id]
-      gateway_options[:customer_reference] = gateway_options[:customer]
-      gateway_options[:description] = "Spree Order"
-      provider.authorize(money, creditcard.gateway_customer_profile_id, gateway_options)
-    end
-
-    def capture(authorization, creditcard, gateway_options)
-      gateway_options[:billing_reference] = gateway_options[:order_id]
-      gateway_options[:customer_reference] = gateway_options[:customer]
-      gateway_options[:description] = "Spree Order"
-      provider.capture(nil, authorization.response_code, {})
-    end
-
-    def credit(money, creditcard, response_code, gateway_options)
-      provider.credit(money, response_code, {})
-    end
-
-    def void(response_code, gateway_options)
-      provider.void(response_code, {})
-    end
-
-    def create_profile(payment)
-      return unless payment.source.gateway_customer_profile_id.nil?
-
-      options = {}
-      options[:email] = payment.order.email
-      options[:address] = {}
-      options[:address][:address1] = payment.order.bill_address.address1
-      options[:address][:address2] = payment.order.bill_address.address2
-      options[:address][:city] = payment.order.bill_address.city
-      options[:address][:state] = payment.order.bill_address.state.abbr
-      options[:address][:zip] = payment.order.bill_address.zipcode
-      response = provider.store(payment.source, options)
-      if response.success?
-        payment.source.update_attributes!(:gateway_customer_profile_id => response.params['payment_method_token'])
-      else
-        payment.send(:gateway_error, response.message)
-      end
-    end
-  end
-end

data/app/models/spree/gateway/secure_pay_au.rb

@@ -1,10 +0,0 @@
-module Spree
-  class Gateway::SecurePayAU < Gateway
-    preference :login, :string
-    preference :password, :string
-
-    def provider_class
-      ActiveMerchant::Billing::SecurePayAU
-    end
-  end
-end

data/app/models/spree/gateway/stripe_gateway.rb

@@ -1,103 +0,0 @@
-module Spree
-  class Gateway::StripeGateway < Gateway
-    preference :secret_key, :string
-    preference :publishable_key, :string
-
-    def method_type
-      'stripe'
-    end
-
-    def provider_class
-      ActiveMerchant::Billing::StripeGateway
-    end
-
-    def payment_profiles_supported?
-      true
-    end
-
-    def purchase(money, creditcard, gateway_options)
-      provider.purchase(*options_for_purchase_or_auth(money, creditcard, gateway_options))
-    end
-
-    def authorize(money, creditcard, gateway_options)
-      provider.authorize(*options_for_purchase_or_auth(money, creditcard, gateway_options))
-    end
-
-    def capture(payment, creditcard, gateway_options)
-      provider.capture((payment.amount * 100).round, payment.response_code, gateway_options)
-    end
-
-    def credit(money, creditcard, response_code, gateway_options)
-      provider.refund(money, response_code, {})
-    end
-
-    def void(response_code, creditcard, gateway_options)
-      provider.void(response_code, {})
-    end
-
-    def create_profile(payment)
-      return unless payment.source.gateway_customer_profile_id.nil?
-      options = {
-        email: payment.order.email,
-        login: preferred_secret_key,
-      }.merge! address_for(payment)
-
-      response = provider.store(payment.source, options)
-      if response.success?
-        payment.source.update_attributes!({
-          :gateway_customer_profile_id => response.params['id'],
-          :gateway_payment_profile_id => response.params['default_card']
-        })
-      else
-        payment.send(:gateway_error, response.message)
-      end
-    end
-
-    private
-
-    # In this gateway, what we call 'secret_key' is the 'login'
-    def options
-      options = super
-      options.merge(:login => preferred_secret_key)
-    end
-
-
-    def options_for_purchase_or_auth(money, creditcard, gateway_options)
-      options = {}
-      options[:description] = "Spree Order ID: #{gateway_options[:order_id]}"
-      options[:currency] = gateway_options[:currency]
-
-      if customer = creditcard.gateway_customer_profile_id
-        options[:customer] = customer
-      end
-      if token_or_card_id = creditcard.gateway_payment_profile_id
-        # The Stripe ActiveMerchant gateway supports passing the token directly as the creditcard parameter
-        # The Stripe ActiveMerchant gateway supports passing the customer_id and credit_card id
-        # https://github.com/Shopify/active_merchant/issues/770
-        creditcard = token_or_card_id
-      end
-      return money, creditcard, options
-    end
-
-    def address_for(payment)
-      {}.tap do |options|
-        if address = payment.order.bill_address
-          options.merge!(address: {
-            address1: address.address1,
-            address2: address.address2,
-            city: address.city,
-            zip: address.zipcode
-          })
-
-          if country = address.country
-            options[:address].merge!(country: country.name)
-          end
-
-          if state = address.state
-            options[:address].merge!(state: state.name)
-          end
-        end
-      end
-    end
-  end
-end

data/app/models/spree/gateway/usa_epay.rb

@@ -1,9 +0,0 @@
-module Spree
-  class Gateway::UsaEpay < Gateway
-    preference :login, :string
-    
-    def provider_class
-      ActiveMerchant::Billing::UsaEpayGateway
-    end
-  end
-end

data/app/models/spree/gateway/worldpay.rb

@@ -1,91 +0,0 @@
-module Spree
-  class Gateway::Worldpay < Gateway
-    preference :login, :string
-    preference :password, :string
-    preference :currency, :string, :default => 'GBP'
-    preference :installation_id, :string
-
-    preference :american_express_login, :string
-    preference :discover_login, :string
-    preference :jcb_login, :string
-    preference :mastercard_login, :string
-    preference :maestro_login, :string
-    preference :visa_login, :string
-
-    def provider_class
-      ActiveMerchant::Billing::WorldpayGateway
-    end
-
-    def purchase(money, credit_card, options = {})
-      provider = credit_card_provider(credit_card, options)
-      provider.purchase(money, credit_card, options)
-    end
-
-    def authorize(money, credit_card, options = {})
-      provider = credit_card_provider(credit_card, options)
-      provider.authorize(money, credit_card, options)
-    end
-
-    def capture(money, authorization, options = {})
-      provider = credit_card_provider(auth_credit_card(authorization), options)
-      provider.capture(money, authorization, options)
-    end
-
-    def refund(money, authorization, options = {})
-      provider = credit_card_provider(auth_credit_card(authorization), options)
-      provider.refund(money, authorization, options)
-    end
-
-    def credit(money, authorization, options = {})
-      refund(money, authorization, options)
-    end
-
-    def void(authorization, options = {})
-      provider = credit_card_provider(auth_credit_card(authorization), options)
-      provider.void(authorization, options)
-    end
-
-    private
-
-    def options_for_card(credit_card, options)
-      options[:login] = login_for_card(credit_card)
-      options = options().merge( options )
-    end
-
-    def auth_credit_card(authorization)
-      Spree::Payment.find_by_response_code(authorization).source
-    end
-
-    def credit_card_provider(credit_card, options = {})
-      gateway_options = options_for_card(credit_card, options)
-      gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
-      gateway_options[:currency] = self.preferred_currency
-      gateway_options[:inst_id] = self.preferred_installation_id
-      ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
-      @provider = provider_class.new(gateway_options)
-    end
-
-    def login_for_card(card)
-      case card.brand
-        when 'american_express'
-          choose_login preferred_american_express_login
-        when 'discover'
-          choose_login preferred_discover_login
-        when 'jcb'
-          choose_login preferred_jcb_login
-        when 'maestro'
-          choose_login preferred_maestro_login
-        when 'master'
-          choose_login preferred_mastercard_login
-        when 'visa'
-          choose_login preferred_visa_login
-        else
-          preferred_login
-      end
-    end
-
-    def choose_login(login)
-      return login ? login : preferred_login
-    end
-  end
-end