swiss-activemerchant 1.0.1

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

@@ -0,0 +1,260 @@
+require 'json'
+require 'openssl'
+require 'digest'
+require 'base64'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class MitGateway < Gateway
+      self.live_url = 'https://wpy.mitec.com.mx/ModuloUtilWS/activeCDP.htm'
+
+      self.supported_countries = ['MX']
+      self.default_currency = 'MXN'
+      self.supported_cardtypes = %i[visa master]
+
+      self.homepage_url = 'http://www.centrodepagos.com.mx/'
+      self.display_name = 'MIT Centro de pagos'
+
+      self.money_format = :dollars
+
+      def initialize(options = {})
+        requires!(options, :commerce_id, :user, :api_key, :key_session)
+        super
+      end
+
+      def purchase(money, payment, options = {})
+        MultiResponse.run do |r|
+          r.process { authorize(money, payment, options) }
+          r.process { capture(money, r.authorization, options) }
+        end
+      end
+
+      def cipher_key
+        @options[:key_session]
+      end
+
+      def decrypt(val, keyinhex)
+        # Splits the first 16 bytes (the IV bytes) in array format
+        unpacked = val.unpack('m')
+        iv_base64 = unpacked[0].bytes.slice(0, 16)
+        # Splits the second bytes (the encrypted text bytes) these would be the
+        # original message
+        full_data = unpacked[0].bytes.slice(16, unpacked[0].bytes.length)
+        # Creates the engine
+        engine = OpenSSL::Cipher::AES128.new(:CBC)
+        # Set engine as decrypt mode
+        engine.decrypt
+        # Converts the key from hex to bytes
+        engine.key = [keyinhex].pack('H*')
+        # Converts the ivBase64 array into bytes
+        engine.iv = iv_base64.pack('c*')
+        # Decrypts the texts and returns the original string
+        engine.update(full_data.pack('c*')) + engine.final
+      end
+
+      def encrypt(val, keyinhex)
+        # Creates the engine motor
+        engine = OpenSSL::Cipher::AES128.new(:CBC)
+        # Set engine as encrypt mode
+        engine.encrypt
+        # Converts the key from hex to bytes
+        engine.key = [keyinhex].pack('H*')
+        # Generates a random iv with this settings
+        iv_rand = engine.random_iv
+        # Packs IV as a Base64 string
+        iv_base64 = [iv_rand].pack('m')
+        # Converts the packed key into bytes
+        unpacked = iv_base64.unpack('m')
+        iv = unpacked[0]
+        # Sets the IV into the engine
+        engine.iv = iv
+        # Encrypts the texts and stores the bytes
+        encrypted_bytes = engine.update(val) + engine.final
+        # Concatenates the (a) IV bytes and (b) the encrypted bytes then returns a
+        # base64 representation
+        [iv << encrypted_bytes].pack('m')
+      end
+
+      def authorize(money, payment, options = {})
+        post = {
+          operation: 'Authorize',
+          commerce_id: @options[:commerce_id],
+          user: @options[:user],
+          apikey: @options[:api_key],
+          testMode: (test? ? 'YES' : 'NO')
+        }
+        add_invoice(post, money, options)
+        # Payments contains the card information
+        add_payment(post, payment)
+        add_customer_data(post, options)
+        post[:key_session] = @options[:key_session]
+
+        post_to_json = post.to_json
+        post_to_json_encrypt = encrypt(post_to_json, @options[:key_session])
+
+        final_post = '<authorization>' + post_to_json_encrypt + '</authorization><dataID>' + @options[:user] + '</dataID>'
+        json_post = {}
+        json_post[:payload] = final_post
+        commit('sale', json_post)
+      end
+
+      def capture(money, authorization, options = {})
+        post = {
+          operation: 'Capture',
+          commerce_id: @options[:commerce_id],
+          user: @options[:user],
+          apikey: @options[:api_key],
+          testMode: (test? ? 'YES' : 'NO'),
+          transaction_id: authorization,
+          amount: amount(money)
+        }
+        post[:key_session] = @options[:key_session]
+
+        post_to_json = post.to_json
+        post_to_json_encrypt = encrypt(post_to_json, @options[:key_session])
+
+        final_post = '<capture>' + post_to_json_encrypt + '</capture><dataID>' + @options[:user] + '</dataID>'
+        json_post = {}
+        json_post[:payload] = final_post
+        commit('capture', json_post)
+      end
+
+      def refund(money, authorization, options = {})
+        post = {
+          operation: 'Refund',
+          commerce_id: @options[:commerce_id],
+          user: @options[:user],
+          apikey: @options[:api_key],
+          testMode: (test? ? 'YES' : 'NO'),
+          transaction_id: authorization,
+          auth: authorization,
+          amount: amount(money)
+        }
+        post[:key_session] = @options[:key_session]
+
+        post_to_json = post.to_json
+        post_to_json_encrypt = encrypt(post_to_json, @options[:key_session])
+
+        final_post = '<refund>' + post_to_json_encrypt + '</refund><dataID>' + @options[:user] + '</dataID>'
+        json_post = {}
+        json_post[:payload] = final_post
+        commit('refund', json_post)
+      end
+
+      def supports_scrubbing?
+        true
+      end
+
+      def scrub(transcript)
+        ret_transcript = transcript
+        auth_origin = ret_transcript[/<authorization>(.*?)<\/authorization>/, 1]
+        unless auth_origin.nil?
+          auth_decrypted = decrypt(auth_origin, @options[:key_session])
+          auth_json = JSON.parse(auth_decrypted)
+          auth_json['card'] = '[FILTERED]'
+          auth_json['cvv'] = '[FILTERED]'
+          auth_json['apikey'] = '[FILTERED]'
+          auth_json['key_session'] = '[FILTERED]'
+          auth_to_json = auth_json.to_json
+          auth_tagged = '<authorization>' + auth_to_json + '</authorization>'
+          ret_transcript = ret_transcript.gsub(/<authorization>(.*?)<\/authorization>/, auth_tagged)
+        end
+
+        cap_origin = ret_transcript[/<capture>(.*?)<\/capture>/, 1]
+        unless cap_origin.nil?
+          cap_decrypted = decrypt(cap_origin, @options[:key_session])
+          cap_json = JSON.parse(cap_decrypted)
+          cap_json['apikey'] = '[FILTERED]'
+          cap_json['key_session'] = '[FILTERED]'
+          cap_to_json = cap_json.to_json
+          cap_tagged = '<capture>' + cap_to_json + '</capture>'
+          ret_transcript = ret_transcript.gsub(/<capture>(.*?)<\/capture>/, cap_tagged)
+        end
+
+        ref_origin = ret_transcript[/<refund>(.*?)<\/refund>/, 1]
+        unless ref_origin.nil?
+          ref_decrypted = decrypt(ref_origin, @options[:key_session])
+          ref_json = JSON.parse(ref_decrypted)
+          ref_json['apikey'] = '[FILTERED]'
+          ref_json['key_session'] = '[FILTERED]'
+          ref_to_json = ref_json.to_json
+          ref_tagged = '<refund>' + ref_to_json + '</refund>'
+          ret_transcript = ret_transcript.gsub(/<refund>(.*?)<\/refund>/, ref_tagged)
+        end
+
+        res_origin = ret_transcript[/#{Regexp.escape('reading ')}(.*?)#{Regexp.escape('read')}/m, 1]
+        loop do
+          break if res_origin.nil?
+
+          resp_origin = res_origin[/#{Regexp.escape('"')}(.*?)#{Regexp.escape('"')}/m, 1]
+          resp_decrypted = decrypt(resp_origin, @options[:key_session])
+          ret_transcript[/#{Regexp.escape('reading ')}(.*?)#{Regexp.escape('read')}/m, 1] = resp_decrypted
+          ret_transcript = ret_transcript.sub('reading ', 'response: ')
+          res_origin = ret_transcript[/#{Regexp.escape('reading ')}(.*?)#{Regexp.escape('read')}/m, 1]
+        end
+
+        ret_transcript
+      end
+
+      private
+
+      def add_customer_data(post, options)
+        post[:email] = options[:email] || 'nadie@mit.test'
+      end
+
+      def add_invoice(post, money, options)
+        post[:amount] = amount(money)
+        post[:currency] = (options[:currency] || currency(money))
+        post[:reference] = options[:order_id]
+        post[:transaction_id] = options[:order_id]
+      end
+
+      def add_payment(post, payment)
+        post[:installments] = 1
+        post[:card] = payment.number
+        post[:expmonth] = payment.month
+        post[:expyear] = payment.year
+        post[:cvv] = payment.verification_value
+        post[:name_client] = [payment.first_name, payment.last_name].join(' ')
+      end
+
+      def commit(action, parameters)
+        json_str = JSON.generate(parameters)
+        cleaned_str = json_str.gsub('\n', '')
+        raw_response = ssl_post(live_url, cleaned_str, { 'Content-type' => 'application/json' })
+        response = JSON.parse(decrypt(raw_response, @options[:key_session]))
+
+        Response.new(
+          success_from(response),
+          message_from(response),
+          response,
+          authorization: authorization_from(response),
+          avs_result: AVSResult.new(code: response['some_avs_response_key']),
+          cvv_result: CVVResult.new(response['some_cvv_response_key']),
+          test: test?,
+          error_code: error_code_from(response)
+        )
+      end
+
+      def success_from(response)
+        response['response'] == 'approved'
+      end
+
+      def message_from(response)
+        response['response']
+      end
+
+      def authorization_from(response)
+        response['reference']
+      end
+
+      def post_data(action, parameters = {})
+        parameters.collect { |key, value| "#{key}=#{CGI.escape(value.to_s)}" }.join('&')
+      end
+
+      def error_code_from(response)
+        response['message'].split(' -- ', 2)[0] unless success_from(response)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'active_merchant/billing/gateways/modern_payments_cim'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class ModernPaymentsGateway < Gateway
+      self.supported_countries = ModernPaymentsCimGateway.supported_countries
+      self.supported_cardtypes = ModernPaymentsCimGateway.supported_cardtypes
+      self.homepage_url = ModernPaymentsCimGateway.homepage_url
+      self.display_name = ModernPaymentsCimGateway.display_name
+
+      self.abstract_class = true
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def purchase(money, credit_card, options = {})
+        customer_response = cim.create_customer(options)
+        return customer_response unless customer_response.success?
+
+        customer_id = customer_response.params['create_customer_result']
+
+        card_response = cim.modify_customer_credit_card(customer_id, credit_card)
+        return card_response unless card_response.success?
+
+        cim.authorize_credit_card_payment(customer_id, money)
+      end
+
+      private
+
+      def cim
+        @cim ||= ModernPaymentsCimGateway.new(@options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class ModernPaymentsCimGateway < Gateway #:nodoc:
+      self.test_url = 'https://secure.modpay.com/netservices/test/ModpayTest.asmx'
+      self.live_url = 'https://secure.modpay.com/ws/modpay.asmx'
+
+      LIVE_XMLNS = 'https://secure.modpay.com/ws/'
+      TEST_XMLNS = 'https://secure.modpay.com/netservices/test/'
+
+      self.supported_countries = ['US']
+      self.supported_cardtypes = %i[visa master american_express discover]
+      self.homepage_url = 'http://www.modpay.com'
+      self.display_name = 'Modern Payments'
+
+      SUCCESS_MESSAGE = 'Transaction accepted'
+      FAILURE_MESSAGE = 'Transaction failed'
+      ERROR_MESSAGE   = 'Transaction error'
+
+      PAYMENT_METHOD = {
+        check: 1,
+        credit_card: 2
+      }
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def create_customer(options = {})
+        post = {}
+        add_customer_data(post, options)
+        add_address(post, options)
+
+        commit('CreateCustomer', post)
+      end
+
+      def modify_customer_credit_card(customer_id, credit_card)
+        raise ArgumentError, 'The customer_id cannot be blank' if customer_id.blank?
+
+        post = {}
+        add_customer_id(post, customer_id)
+        add_credit_card(post, credit_card)
+
+        commit('ModifyCustomerCreditCard', post)
+      end
+
+      def authorize_credit_card_payment(customer_id, amount)
+        raise ArgumentError, 'The customer_id cannot be blank' if customer_id.blank?
+
+        post = {}
+        add_customer_id(post, customer_id)
+        add_amount(post, amount)
+
+        commit('AuthorizeCreditCardPayment', post)
+      end
+
+      def create_payment(customer_id, amount, options = {})
+        raise ArgumentError, 'The customer_id cannot be blank' if customer_id.blank?
+
+        post = {}
+        add_customer_id(post, customer_id)
+        add_amount(post, amount)
+        add_payment_details(post, options)
+
+        commit('CreatePayment', post)
+      end
+
+      private
+
+      def add_payment_details(post, options)
+        post[:pmtDate] = (options[:payment_date] || Time.now.utc).strftime('%Y-%m-%dT%H:%M:%SZ')
+        post[:pmtType] = PAYMENT_METHOD[options[:payment_method] || :credit_card]
+      end
+
+      def add_amount(post, money)
+        post[:pmtAmount] = amount(money)
+      end
+
+      def add_customer_id(post, customer_id)
+        post[:custId] = customer_id
+      end
+
+      def add_customer_data(post, options)
+        post[:acctNum] = options[:customer]
+      end
+
+      def add_address(post, options)
+        address = options[:billing_address] || options[:address] || {}
+
+        if name = address[:name]
+          post[:firstName], post[:lastName] = split_names(name)
+        else
+          post[:firstName] = address[:first_name]
+          post[:lastName]  = address[:last_name]
+        end
+
+        post[:address]   = address[:address1]
+        post[:city]      = address[:city]
+        post[:state]     = address[:state]
+        post[:zip]       = address[:zip]
+        post[:phone]     = address[:phone]
+        post[:fax]       = address[:fax]
+        post[:email]     = options[:email]
+      end
+
+      def add_credit_card(post, credit_card)
+        post[:ccName] = credit_card.name
+        post[:ccNum]  = credit_card.number
+        post[:expMonth] = credit_card.month
+        post[:expYear]  = credit_card.year
+      end
+
+      def build_request(action, params)
+        xml = Builder::XmlMarkup.new indent: 2
+        xml.instruct!
+        xml.tag! 'env:Envelope',
+          { 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+            'xmlns:env' => 'http://schemas.xmlsoap.org/soap/envelope/',
+            'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance' } do
+
+          xml.tag! 'env:Body' do
+            xml.tag! action, { 'xmlns' => xmlns(action) } do
+              xml.tag! 'clientId', @options[:login]
+              xml.tag! 'clientCode', @options[:password]
+              params.each { |key, value| xml.tag! key, value }
+            end
+          end
+        end
+        xml.target!
+      end
+
+      def xmlns(action)
+        if test? && action == 'AuthorizeCreditCardPayment'
+          TEST_XMLNS
+        else
+          LIVE_XMLNS
+        end
+      end
+
+      def url(action)
+        if test? && action == 'AuthorizeCreditCardPayment'
+          self.test_url
+        else
+          self.live_url
+        end
+      end
+
+      def commit(action, params)
+        data = ssl_post(url(action), build_request(action, params),
+          { 'Content-Type' => 'text/xml; charset=utf-8',
+            'SOAPAction' => "#{xmlns(action)}#{action}" })
+
+        response = parse(action, data)
+        Response.new(successful?(action, response), message_from(action, response), response,
+          test: test?,
+          authorization: authorization_from(action, response),
+          avs_result: { code: response[:avs_code] })
+      end
+
+      def authorization_from(action, response)
+        response[authorization_key(action)]
+      end
+
+      def authorization_key(action)
+        action == 'AuthorizeCreditCardPayment' ? :trans_id : "#{action.underscore}_result".to_sym
+      end
+
+      def successful?(action, response)
+        key = authorization_key(action)
+
+        if key == :trans_id
+          response[:approved] == 'true'
+        else
+          response[key].to_i > 0
+        end
+      end
+
+      def message_from(action, response)
+        if response[:faultcode]
+          ERROR_MESSAGE
+        elsif successful?(action, response)
+          SUCCESS_MESSAGE
+        else
+          FAILURE_MESSAGE
+        end
+      end
+
+      def parse(action, xml)
+        response = {}
+        response[:action] = action
+
+        xml = REXML::Document.new(xml)
+        if root = REXML::XPath.first(xml, "//#{action}Response")
+          root.elements.to_a.each do |node|
+            parse_element(response, node)
+          end
+        elsif root = REXML::XPath.first(xml, '//soap:Fault')
+          root.elements.to_a.each do |node|
+            response[node.name.underscore.to_sym] = node.text
+          end
+        end
+
+        response
+      end
+
+      def parse_element(response, node)
+        if node.has_elements?
+          node.elements.each { |e| parse_element(response, e) }
+        else
+          response[node.name.underscore.to_sym] = node.text.to_s.strip
+        end
+      end
+    end
+  end
+end