activemerchant 1.38.0 → 1.79.2

data/lib/active_merchant/billing/gateways/samurai.rb

@@ -1,118 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    class SamuraiGateway < Gateway
-
-      self.homepage_url = 'https://samurai.feefighters.com'
-      self.display_name = 'Samurai'
-      self.supported_countries = ['US']
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover, :jcb, :diners_club]
-      self.default_currency = 'USD'
-      self.money_format = :dollars
-
-      def initialize(options = {})
-        begin
-          require 'samurai'
-        rescue LoadError
-          raise "Could not load the samurai gem (>= 0.2.25).  Use `gem install samurai` to install it."
-        end
-
-        requires!(options, :login, :password, :processor_token)
-        Samurai.options = {
-          :merchant_key       => options[:login],
-          :merchant_password  => options[:password],
-          :processor_token    => options[:processor_token]
-        }
-
-        super
-      end
-
-      def authorize(money, credit_card_or_vault_id, options = {})
-        token = payment_method_token(credit_card_or_vault_id, options)
-        return token if token.is_a?(Response)
-
-        authorize = Samurai::Processor.authorize(token, amount(money), processor_options(options))
-        handle_result(authorize)
-      end
-
-      def purchase(money, credit_card_or_vault_id, options = {})
-        token = payment_method_token(credit_card_or_vault_id, options)
-        return token if token.is_a?(Response)
-
-        purchase = Samurai::Processor.purchase(token, amount(money), processor_options(options))
-        handle_result(purchase)
-      end
-
-      def capture(money, authorization_id, options = {})
-        transaction = Samurai::Transaction.find(authorization_id)
-        handle_result(transaction.capture(amount(money)))
-      end
-
-      def refund(money, transaction_id, options = {})
-        transaction = Samurai::Transaction.find(transaction_id)
-        handle_result(transaction.credit(amount(money)))
-      end
-
-      def void(transaction_id, options = {})
-        transaction = Samurai::Transaction.find(transaction_id)
-        handle_result(transaction.void)
-      end
-
-      def store(creditcard, options = {})
-        address = options[:billing_address] || options[:address] || {}
-
-        result = Samurai::PaymentMethod.create({
-          :card_number  => creditcard.number,
-          :expiry_month => creditcard.month.to_s.rjust(2, "0"),
-          :expiry_year  => creditcard.year.to_s,
-          :cvv          => creditcard.verification_value,
-          :first_name   => creditcard.first_name,
-          :last_name    => creditcard.last_name,
-          :address_1    => address[:address1],
-          :address_2    => address[:address2],
-          :city         => address[:city],
-          :zip          => address[:zip],
-          :sandbox      => test?
-        })
-        result.retain if options[:retain] && result.is_sensitive_data_valid && result.payment_method_token
-
-        Response.new(result.is_sensitive_data_valid,
-                     message_from_result(result),
-                     { :payment_method_token => result.is_sensitive_data_valid && result.payment_method_token })
-      end
-
-      private
-
-      def payment_method_token(credit_card_or_vault_id, options)
-        return credit_card_or_vault_id if credit_card_or_vault_id.is_a?(String)
-        store_result = store(credit_card_or_vault_id, options)
-        store_result.success? ? store_result.params["payment_method_token"] : store_result
-      end
-
-      def handle_result(result)
-        response_params, response_options = {}, {}
-        if result.success?
-          response_options[:test] = test?
-          response_options[:authorization] = result.reference_id
-          response_params[:reference_id] = result.reference_id
-          response_params[:transaction_token] = result.transaction_token
-          response_params[:payment_method_token] = result.payment_method.payment_method_token
-        end
-
-        response_options[:avs_result] = { :code => result.processor_response && result.processor_response.avs_result_code }
-        response_options[:cvv_result] = result.processor_response && result.processor_response.cvv_result_code
-
-        message = message_from_result(result)
-        Response.new(result.success?, message, response_params, response_options)
-      end
-
-      def message_from_result(result)
-        return "OK" if result.success?
-        result.errors.map {|_, messages| messages }.join(" ")
-      end
-
-      def processor_options(options)
-        options.slice(:billing_reference, :customer_reference, :custom, :descriptor)
-      end
-    end
-  end
-end

data/lib/active_merchant/billing/gateways/vindicia.rb

@@ -1,361 +0,0 @@
-begin
-  require "vindicia-api"
-rescue LoadError
-  raise "Could not load the vindicia-api gem.  Use `gem install vindicia-api` to install it."
-end
-
-require 'i18n/core_ext/string/interpolate'
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-
-    # For more information on the Vindicia Gateway please visit their {website}[http://vindicia.com/]
-    #
-    # The login and password are not the username and password you use to
-    # login to the Vindicia Merchant Portal.
-    #
-    # ==== Recurring Billing
-    #
-    # AutoBills are an feature of Vindicia's API that allows for creating and managing subscriptions.
-    #
-    # For more information about Vindicia's API and various other services visit their {Resource Center}[http://www.vindicia.com/resources/index.html]
-    class VindiciaGateway < Gateway
-      self.supported_countries = %w{US CA GB AU MX BR DE KR CN HK}
-      self.supported_cardtypes = [:visa, :master, :american_express, :discover]
-      self.homepage_url = 'http://www.vindicia.com/'
-      self.display_name = 'Vindicia'
-
-      class_attribute :test_url, :live_url
-
-      self.test_url = "https://soap.prodtest.sj.vindicia.com/soap.pl"
-      self.live_url = "http://soap.vindicia.com/soap.pl"
-
-      # Creates a new VindiciaGateway
-      #
-      # The gateway requires that a valid login and password be passed
-      # in the +options+ hash.
-      #
-      # ==== Options
-      #
-      # * <tt>:login</tt> -- Vindicia SOAP login (REQUIRED)
-      # * <tt>:password</tt> -- Vindicia SOAP password (REQUIRED)
-      # * <tt>:api_version</tt> -- Vindicia API Version - defaults to 3.6 (OPTIONAL)
-      # * <tt>:account_id</tt> -- Account Id which all transactions will be run against. (REQUIRED)
-      # * <tt>:transaction_prefix</tt> -- Prefix to order id for one-time transactions - defaults to 'X' (OPTIONAL
-      # * <tt>:min_chargeback_probability</tt> -- Minimum score for chargebacks - defaults to 65 (OPTIONAL)
-      # * <tt>:cvn_success</tt> -- Array of valid CVN Check return values - defaults to [M, P] (OPTIONAL)
-      # * <tt>:avs_success</tt> -- Array of valid AVS Check return values - defaults to [X, Y, A, W, Z] (OPTIONAL)
-      def initialize(options = {})
-        requires!(options, :login, :password)
-        super
-
-        config = lambda do |config|
-          config.login = options[:login]
-          config.password = options[:password]
-          config.api_version = options[:api_version] || "3.6"
-          config.endpoint = test? ? self.test_url : self.live_url
-          config.namespace = "http://soap.vindicia.com"
-        end
-
-        if Vindicia.config.is_configured?
-          config.call(Vindicia.config)
-        else
-          Vindicia.configure(&config)
-        end
-
-        requires!(options, :account_id)
-        @account_id = options[:account_id]
-
-        @transaction_prefix = options[:transaction_prefix] || "X"
-
-        @min_chargeback_probability = options[:min_chargeback_probability] || 65
-        @cvn_success = options[:cvn_success] || %w{M P}
-        @avs_success = options[:avs_success] || %w{X Y A W Z}
-
-        @allowed_authorization_statuses = %w{Authorized}
-      end
-
-      # Perform a purchase, which is essentially an authorization and capture in a single operation.
-      #
-      # ==== Parameters
-      #
-      # * <tt>money</tt> -- The amount to be purchased as an Integer value in cents.
-      # * <tt>creditcard</tt> -- The CreditCard details for the transaction.
-      # * <tt>options</tt> -- A hash of optional parameters.
-      def purchase(money, creditcard, options = {})
-        response = authorize(money, creditcard, options)
-        return response if !response.success? || response.fraud_review?
-
-        capture(money, response.authorization, options)
-      end
-
-      # Performs an authorization, which reserves the funds on the customer's credit card, but does not
-      # charge the card.
-      #
-      # ==== Parameters
-      #
-      # * <tt>money</tt> -- The amount to be authorized as an Integer value in cents.
-      # * <tt>creditcard</tt> -- The CreditCard details for the transaction.
-      # * <tt>options</tt> -- A hash of optional parameters.
-      def authorize(money, creditcard, options = {})
-        vindicia_transaction = authorize_transaction(money, creditcard, options)
-        response = check_transaction(vindicia_transaction)
-
-        # if this response is under fraud review because of our AVS/CVV checks void the transaction
-        if !response.success? && response.fraud_review? && !response.authorization.blank?
-          void_response = void([vindicia_transaction[:transaction][:merchantTransactionId]], options)
-          if void_response.success?
-            return response
-          else
-            return void_response
-          end
-        end
-
-        response
-      end
-
-      # Captures the funds from an authorized transaction.
-      #
-      # ==== Parameters
-      #
-      # * <tt>money</tt> -- The amount to be captured as an Integer value in cents.
-      # * <tt>identification</tt> -- The authorization returned from the previous authorize request.
-      def capture(money, identification, options = {})
-        response = post(Vindicia::Transaction.capture({
-          :transactions => [{ :merchantTransactionId => identification }]
-        }))
-
-        if response[:return][:returnCode] != '200' || response[:qtyFail].to_i > 0
-          return fail(response)
-        end
-
-        success(response, identification)
-      end
-
-      # Void a previous transaction
-      #
-      # ==== Parameters
-      #
-      # * <tt>identification</tt> - The authorization returned from the previous authorize request.
-      # * <tt>options</tt> - Extra options (currently only :ip used)
-      def void(identification, options = {})
-        response = post(Vindicia::Transaction.cancel({
-          :transactions => [{
-            :account => { :merchantAccountId => @account_id },
-            :merchantTransactionId => identification,
-            :sourceIp => options[:ip]
-          }]
-        }))
-
-        if response[:return][:returnCode] == '200' && response[:qtyFail].to_i == 0
-          success(response, identification)
-        else
-          fail(response)
-        end
-      end
-
-      # Perform a recurring billing, which is essentially a purchase and autobill setup in a single operation.
-      #
-      # ==== Parameters
-      #
-      # * <tt>money</tt> -- The amount to be purchased as an Integer value in cents.
-      # * <tt>creditcard</tt> -- The CreditCard details for the transaction.
-      # * <tt>options</tt> -- A hash of parameters.
-      #
-      # ==== Options
-      #
-      # * <tt>:product_sku</tt> -- The subscription product's sku
-      # * <tt>:autobill_prefix</tt> -- Prefix to order id for subscriptions - defaults to 'A' (OPTIONAL)
-      def recurring(money, creditcard, options={})
-        options[:recurring] = true
-        @autobill_prefix = options[:autobill_prefix] || "A"
-
-        response = authorize(money, creditcard, options)
-        return response if !response.success? || response.fraud_review?
-
-        capture_resp = capture(money, response.authorization, options)
-        return capture_resp if !response.success?
-
-        # Setting up a recurring AutoBill requires an associated product
-        requires!(options, :product_sku)
-        autobill_response = check_subscription(authorize_subscription(options.merge(:product_sku => options[:product_sku])))
-
-        if autobill_response.success?
-          autobill_response
-        else
-          # If the AutoBill fails to set-up, void the transaction and return it as the response
-          void_response = void(capture_resp.authorization, options)
-          if void_response.success?
-            return autobill_response
-          else
-            return void_response
-          end
-        end
-      end
-
-      protected
-
-      def post(body)
-        parse(ssl_post(Vindicia.config.endpoint, body, "Content-Type" => "text/xml"))
-      end
-
-      def parse(response)
-        # Vindicia always returns in the form of request_type_response => { actual_response }
-        Hash.from_xml(response)["Envelope"]["Body"].values.first.with_indifferent_access
-      end
-
-      def check_transaction(vindicia_transaction)
-        if vindicia_transaction[:return][:returnCode] == '200'
-          status_log = vindicia_transaction[:transaction][:statusLog].first
-          if status_log[:creditCardStatus]
-            avs = status_log[:creditCardStatus][:avsCode]
-            cvn = status_log[:creditCardStatus][:cvnCode]
-          end
-
-          if @allowed_authorization_statuses.include?(status_log[:status]) &&
-            check_cvn(cvn) && check_avs(avs)
-
-            success(vindicia_transaction,
-                    vindicia_transaction[:transaction][:merchantTransactionId],
-                    avs, cvn)
-          else
-            # If the transaction is authorized, but it didn't pass our AVS/CVV checks send the authorization along so
-            # that is gets voided. Otherwise, send no authorization.
-            fail(vindicia_transaction, avs, cvn, false,
-                 @allowed_authorization_statuses.include?(status_log[:status]) ? vindicia_transaction[:transaction][:merchantTransactionId] : "")
-          end
-        else
-          # 406 = Chargeback risk score is higher than minChargebackProbability, transaction not authorized.
-          fail(vindicia_transaction, nil, nil, vindicia_transaction[:return][:return_code] == '406')
-        end
-      end
-
-      def authorize_transaction(money, creditcard, options)
-        parameters = {
-          :amount => amount(money),
-          :currency => options[:currency] || currency(money)
-        }
-
-        add_account_data(parameters, options)
-        add_customer_data(parameters, options)
-        add_payment_source(parameters, creditcard, options)
-
-        post(Vindicia::Transaction.auth({
-          :transaction => parameters,
-          :minChargebackProbability => @min_chargeback_probability
-        }))
-      end
-
-      def add_account_data(parameters, options)
-        parameters[:account] = { :merchantAccountId => @account_id }
-        parameters[:sourceIp] = options[:ip] if options[:ip]
-      end
-
-      def add_customer_data(parameters, options)
-        parameters[:merchantTransactionId] = transaction_id(options[:order_id])
-        parameters[:shippingAddress] = convert_am_address_to_vindicia(options[:shipping_address])
-
-        # Transaction items must be provided for tax purposes
-        requires!(options, :line_items)
-        parameters[:transactionItems] = options[:line_items]
-
-        if options[:recurring]
-          parameters[:nameValues] = [{:name => 'merchantAutoBillIdentifier', :value => autobill_id(options[:order_id])}]
-        end
-      end
-
-      def add_payment_source(parameters, creditcard, options)
-        parameters[:sourcePaymentMethod] = {
-          :type => 'CreditCard',
-          :creditCard => { :account => creditcard.number, :expirationDate => "%4d%02d" % [creditcard.year, creditcard.month] },
-          :accountHolderName => creditcard.name,
-          :nameValues => [{ :name => 'CVN', :value => creditcard.verification_value }],
-          :billingAddress => convert_am_address_to_vindicia(options[:billing_address] || options[:address]),
-          :customerSpecifiedType => creditcard.brand.capitalize,
-          :active => !!options[:recurring]
-        }
-      end
-
-      def authorize_subscription(options)
-        parameters = {}
-
-        add_account_data(parameters, options)
-        add_subscription_information(parameters, options)
-
-        post(Vindicia::AutoBill.update({
-          :autobill => parameters,
-          :validatePaymentMethod => false,
-          :minChargebackProbability => 100
-        }))
-      end
-
-      def check_subscription(vindicia_transaction)
-        if vindicia_transaction[:return][:returnCode] == '200'
-          if vindicia_transaction[:autobill] && vindicia_transaction[:autobill][:status] == "Active"
-            success(vindicia_transaction,
-                    vindicia_transaction[:autobill][:merchantAutoBillId])
-          else
-            fail(vindicia_transaction)
-          end
-        else
-          fail(vindicia_transaction)
-        end
-      end
-
-      def add_subscription_information(parameters, options)
-        requires!(options, :product_sku)
-
-        if options[:shipping_address]
-          parameters[:account][:shipping_address] = options[:shipping_address]
-        end
-
-        parameters[:merchantAutoBillId] = autobill_id(options[:order_id])
-        parameters[:product] = { :merchantProductId => options[:product_sku] }
-      end
-
-      def check_avs(avs)
-        avs.blank? || @avs_success.include?(avs)
-      end
-
-      def check_cvn(cvn)
-        cvn.blank? || @cvn_success.include?(cvn)
-      end
-
-      def success(response, authorization, avs_code = nil, cvn_code = nil)
-        ActiveMerchant::Billing::Response.new(true, response[:return][:returnString], response,
-                                              { :fraud_review => false, :authorization => authorization, :test => test?,
-                                                :avs_result => { :code => avs_code }, :cvv_result => cvn_code })
-      end
-
-      def fail(response, avs_code = nil, cvn_code = nil, fraud_review = false, authorization = "")
-        ActiveMerchant::Billing::Response.new(false, response[:return][:returnString], response,
-                                              { :fraud_review => fraud_review || !authorization.blank?,
-                                                :authorization => authorization, :test => test?,
-                                                :avs_result => { :code => avs_code }, :cvv_result => cvn_code })
-
-      end
-
-      def autobill_id(order_id)
-        "#{@autobill_prefix}#{order_id}"
-      end
-
-      def transaction_id(order_id)
-        "#{@transaction_prefix}#{order_id}"
-      end
-
-      # Converts valid ActiveMerchant address hash to proper Vindicia format
-      def convert_am_address_to_vindicia(address)
-        return if address.nil?
-
-        convs = { :address1 => :addr1, :address2 => :addr2,
-          :state => :district, :zip => :postalCode }
-
-        vindicia_address = {}
-        address.each do |key, val|
-          vindicia_address[convs[key] || key] = val
-        end
-        vindicia_address
-      end
-    end
-  end
-end

data/lib/active_merchant/billing/integrations/a1agregator/helper.rb

@@ -1,31 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module A1agregator
-        class Helper < ActiveMerchant::Billing::Integrations::Helper
-
-          # public key
-          mapping :account, 'key'
-
-          mapping :amount, 'cost'
-
-          mapping :order, 'order_id'
-
-          mapping :customer, :email => 'email',
-                             :phone => 'phone_number'
-
-           # payment description
-          mapping :credential2, 'name'
-
-          mapping :credential3, 'comment'
-
-          # on error
-          # 1 - raise error
-          # 0 - redirect
-          mapping :credential4, 'verbose'
-
-        end
-      end
-    end
-  end
-end

data/lib/active_merchant/billing/integrations/a1agregator/notification.rb

@@ -1,186 +0,0 @@
-require 'net/http'
-
-module ActiveMerchant #:nodoc:
-  module Billing #:nodoc:
-    module Integrations #:nodoc:
-      module A1agregator
-        class Notification < ActiveMerchant::Billing::Integrations::Notification
-
-          self.production_ips = [
-            '78.108.178.206',
-            '79.137.235.129',
-            '95.163.96.79',
-            '212.24.38.100'
-          ]
-
-          def initialize(*args)
-            super
-            guess_notification_type
-          end
-
-          # Simple notification request params:
-          # tid
-          # name
-          # comment
-          # partner_id
-          # service_id
-          # order_id
-          # type
-          # partner_income
-          # system_income
-
-          def complete?
-            true
-          end
-
-          def transaction_id
-            params['tid']
-          end
-
-          def title
-            params['name']
-          end
-
-          def comment
-            params['comment']
-          end
-
-          def partner_id
-            params['partner_id']
-          end
-
-          def service_id
-            params['service_id']
-          end
-
-          def item_id
-            params['order_id']
-          end
-
-          def type
-            params['type']
-          end
-
-          def partner_income
-            params['partner_income']
-          end
-
-          def system_income
-            params['system_income']
-          end
-
-          # Additional notification request params:
-          # tid
-          # name
-          # comment
-          # partner_id
-          # service_id
-          # order_id
-          # type
-          # cost
-          # income_total
-          # income
-          # partner_income
-          # system_income
-          # command
-          # phone_number
-          # email
-          # resultStr
-          # date_created
-          # version
-          # check
-
-          def inclome_total
-            params['income_total']
-          end
-
-          def income
-            params['income']
-          end
-
-          def partner_income
-            params['partner_income']
-          end
-
-          def system_income
-            params['system_income']
-          end
-
-          def command
-            params['command']
-          end
-
-          def phone_number
-            params['phone_number']
-          end
-
-          def payer_email
-            params['email']
-          end
-
-          def result_string
-            params['resultStr']
-          end
-
-          def received_at
-            params['date_created']
-          end
-
-          def version
-            params['version']
-          end
-
-          def security_key
-            params[A1agregator.signature_parameter_name].to_s.downcase
-          end
-
-          # the money amount we received in X.2 decimal.
-          alias_method :gross, :system_income
-
-          def currency
-            'RUB'
-          end
-
-          # Was this a test transaction?
-          def test?
-            params['test'] == '1'
-          end
-
-          def simple_notification?
-            @notification_type == :simple
-          end
-
-          def additional_notification?
-            @notification_type == :additional
-          end
-
-          def acknowledge
-            security_key == signature
-          end
-
-        private
-
-          def signature
-            data = "#{params['tid']}\
-#{params['name']}\
-#{params['comment']}\
-#{params['partner_id']}\
-#{params['service_id']}\
-#{params['order_id']}\
-#{params['type']}\
-#{params['partner_income']}\
-#{params['system_income']}\
-#{params['test']}\
-#{@options[:secret]}"
-            Digest::MD5.hexdigest(data)
-          end
-
-          def guess_notification_type
-            @notification_type = params['version'] ? :additional : :simple
-          end
-
-        end
-      end
-    end
-  end
-end