jelaniharris-activemerchant 1.24.1

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

@@ -0,0 +1,359 @@
+begin
+  require "vindicia-api"
+rescue LoadError
+  raise "Could not load the vindicia-api gem.  Use `gem install vindicia-api` to install it."
+end
+
+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)
+
+        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}
+
+        @options = options
+        @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/gateways/wirecard.rb

@@ -0,0 +1,318 @@
+require 'base64'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class WirecardGateway < Gateway
+      # Test server location
+      TEST_URL = 'https://c3-test.wirecard.com/secure/ssl-gateway'
+     
+      # Live server location
+      LIVE_URL = 'https://c3.wirecard.com/secure/ssl-gateway'
+
+      # The Namespaces are not really needed, because it just tells the System, that there's actually no namespace used.
+      # It's just specified here for completeness.
+      ENVELOPE_NAMESPACES = {
+        'xmlns:xsi' => 'http://www.w3.org/1999/XMLSchema-instance',
+				'xsi:noNamespaceSchemaLocation' => 'wirecard.xsd'
+			}
+
+			PERMITTED_TRANSACTIONS = %w[ AUTHORIZATION CAPTURE_AUTHORIZATION PURCHASE ]
+
+      RETURN_CODES = %w[ ACK NOK ]
+
+      # Wirecard only allows phone numbers with a format like this: +xxx(yyy)zzz-zzzz-ppp, where: 
+      #   xxx = Country code 
+      #   yyy = Area or city code 
+      #   zzz-zzzz = Local number 
+      #   ppp = PBX extension 
+      # For example, a typical U.S. or Canadian number would be "+1(202)555-1234-739" indicating PBX extension 739 at phone 
+      # number 5551234 within area code 202 (country code 1).
+      VALID_PHONE_FORMAT = /\+\d{1,3}(\(?\d{3}\)?)?\d{3}-\d{4}-\d{3}/
+      
+      # The countries the gateway supports merchants from as 2 digit ISO country codes
+      # TODO: Check supported countries
+      self.supported_countries = ['DE']
+
+      # Wirecard supports all major credit and debit cards:
+      # Visa, Mastercard, American Express, Diners Club,
+      # JCB, Switch, VISA Carte Bancaire, Visa Electron and UATP cards.
+      # They also support the latest anti-fraud systems such as Verified by Visa or Master Secure Code.
+      self.supported_cardtypes = [
+        :visa, :master, :american_express, :diners_club, :jcb, :switch
+      ]
+
+      # The homepage URL of the gateway
+      self.homepage_url = 'http://www.wirecard.com'
+
+      # The name of the gateway
+      self.display_name = 'Wirecard'
+
+      # The currency should normally be EUROs
+      self.default_currency = 'EUR'
+
+      # 100 is 1.00 Euro
+      self.money_format = :cents
+
+      def initialize(options = {})
+        # verify that username and password are supplied
+        requires!(options, :login, :password)
+        # unfortunately Wirecard also requires a BusinessCaseSignature in the XML request
+        requires!(options, :signature)
+        @options = options
+        super
+      end
+
+      # Should run against the test servers or not?
+      def test?
+        @options[:test] || super
+      end
+
+      # Authorization
+      def authorize(money, creditcard, options = {})
+        prepare_options_hash(options)
+        @options[:credit_card] = creditcard
+        request = build_request(:authorization, money, @options)
+        commit(request)
+      end
+
+
+      # Capture Authorization
+      def capture(money, authorization, options = {})
+        prepare_options_hash(options)
+        @options[:authorization] = authorization
+        request = build_request(:capture_authorization, money, @options)
+        commit(request)
+      end
+
+
+      # Purchase
+      def purchase(money, creditcard, options = {})
+        prepare_options_hash(options)
+        @options[:credit_card] = creditcard
+        request = build_request(:purchase, money, @options)
+        commit(request)
+      end
+
+    private
+
+      def prepare_options_hash(options)
+        @options.update(options)
+        setup_address_hash!(options)
+      end
+
+      # Create all address hash key value pairs so that
+      # it still works if only provided with one or two of them
+      def setup_address_hash!(options)
+        options[:billing_address] = options[:billing_address] || options[:address] || {}
+        options[:shipping_address] = options[:shipping_address] || {}
+        # Include Email in address-hash from options-hash
+        options[:billing_address][:email] = options[:email] if options[:email]
+      end
+
+      # Contact WireCard, make the XML request, and parse the
+      # reply into a Response object
+      def commit(request)
+	      headers = { 'Content-Type' => 'text/xml',
+	                  'Authorization' => encoded_credentials }
+
+	      response = parse(ssl_post(test? ? TEST_URL : LIVE_URL, request, headers))
+        # Pending Status also means Acknowledged (as stated in their specification)
+	      success = response[:FunctionResult] == "ACK" || response[:FunctionResult] == "PENDING"
+	      message = response[:Message]
+        authorization = (success && @options[:action] == :authorization) ? response[:GuWID] : nil
+
+        Response.new(success, message, response,
+          :test => test?,
+          :authorization => authorization,
+          :avs_result => { :code => response[:avsCode] },
+          :cvv_result => response[:cvCode]
+        )
+      end
+
+      # Generates the complete xml-message, that gets sent to the gateway
+      def build_request(action, money, options = {})
+				xml = Builder::XmlMarkup.new :indent => 2
+				xml.instruct!
+				xml.tag! 'WIRECARD_BXML' do
+				  xml.tag! 'W_REQUEST' do
+          xml.tag! 'W_JOB' do
+              # TODO: OPTIONAL, check what value needs to be insert here
+              xml.tag! 'JobID', 'test dummy data'
+              # UserID for this transaction
+              xml.tag! 'BusinessCaseSignature', options[:signature] || options[:login]
+              # Create the whole rest of the message
+              add_transaction_data(xml, action, money, options)
+				    end
+				  end
+				end
+				xml.target!
+      end
+
+      # Includes the whole transaction data (payment, creditcard, address)
+      def add_transaction_data(xml, action, money, options = {})
+        options[:action] = action
+        # TODO: require order_id instead of auto-generating it if not supplied
+        options[:order_id] ||= generate_unique_id
+        transaction_type = action.to_s.upcase
+
+        xml.tag! "FNC_CC_#{transaction_type}" do
+          # TODO: OPTIONAL, check which param should be used here
+          xml.tag! 'FunctionID', options[:description] || 'Test dummy FunctionID'
+
+          xml.tag! 'CC_TRANSACTION' do
+            xml.tag! 'TransactionID', options[:order_id]
+            if [:authorization, :purchase].include?(action)
+              add_invoice(xml, money, options)
+              add_creditcard(xml, options[:credit_card])
+              add_address(xml, options[:billing_address])
+            elsif action == :capture_authorization
+              xml.tag! 'GuWID', options[:authorization] if options[:authorization]
+            end
+          end
+        end
+      end
+
+			# Includes the payment (amount, currency, country) to the transaction-xml
+      def add_invoice(xml, money, options)
+        xml.tag! 'Amount', amount(money)
+        xml.tag! 'Currency', options[:currency] || currency(money)
+        xml.tag! 'CountryCode', options[:billing_address][:country]
+        xml.tag! 'RECURRING_TRANSACTION' do
+          xml.tag! 'Type', options[:recurring] || 'Single'
+        end
+      end
+
+			# Includes the credit-card data to the transaction-xml
+			def add_creditcard(xml, creditcard)
+        raise "Creditcard must be supplied!" if creditcard.nil?
+        xml.tag! 'CREDIT_CARD_DATA' do
+          xml.tag! 'CreditCardNumber', creditcard.number
+          xml.tag! 'CVC2', creditcard.verification_value
+          xml.tag! 'ExpirationYear', creditcard.year
+          xml.tag! 'ExpirationMonth', format(creditcard.month, :two_digits)
+          xml.tag! 'CardHolderName', [creditcard.first_name, creditcard.last_name].join(' ')
+        end
+      end
+
+			# Includes the IP address of the customer to the transaction-xml
+      def add_customer_data(xml, options)
+        return unless options[:ip]
+				xml.tag! 'CONTACT_DATA' do
+					xml.tag! 'IPAddress', options[:ip]
+				end
+			end
+
+      # Includes the address to the transaction-xml
+      def add_address(xml, address)
+        return if address.nil?
+        xml.tag! 'CORPTRUSTCENTER_DATA' do
+	        xml.tag! 'ADDRESS' do
+	          xml.tag! 'Address1', address[:address1]
+	          xml.tag! 'Address2', address[:address2] if address[:address2]
+	          xml.tag! 'City', address[:city]
+	          xml.tag! 'ZipCode', address[:zip]
+	          
+	          if address[:state] =~ /[A-Za-z]{2}/ && address[:country] =~ /^(us|ca)$/i
+	            xml.tag! 'State', address[:state].upcase
+	          end
+	          
+	          xml.tag! 'Country', address[:country]
+            xml.tag! 'Phone', address[:phone] if address[:phone] =~ VALID_PHONE_FORMAT
+	          xml.tag! 'Email', address[:email]
+	        end
+	      end
+      end
+
+
+      # Read the XML message from the gateway and check if it was successful,
+			# and also extract required return values from the response.
+      def parse(xml)
+        basepath = '/WIRECARD_BXML/W_RESPONSE'
+        response = {}
+
+        xml = REXML::Document.new(xml)
+        if root = REXML::XPath.first(xml, "#{basepath}/W_JOB")
+          parse_response(response, root)
+        elsif root = REXML::XPath.first(xml, "//ERROR")
+          parse_error(response, root)
+        else
+          response[:Message] = "No valid XML response message received. \
+                                Propably wrong credentials supplied with HTTP header."
+        end
+
+        response
+      end
+
+      # Parse the <ProcessingStatus> Element which containts all important information
+      def parse_response(response, root)
+        status = nil
+        # get the root element for this Transaction
+        root.elements.to_a.each do |node|
+          if node.name =~ /FNC_CC_/
+            status = REXML::XPath.first(node, "CC_TRANSACTION/PROCESSING_STATUS")
+          end
+        end
+        message = ""
+        if status
+          if info = status.elements['Info']
+            message << info.text
+          end
+          # Get basic response information
+          status.elements.to_a.each do |node|
+            response[node.name.to_sym] = (node.text || '').strip
+          end
+        end
+        parse_error(root, message)
+        response[:Message] = message
+      end
+
+      # Parse a generic error response from the gateway
+      def parse_error(root, message = "")
+        # Get errors if available and append them to the message
+        errors = errors_to_string(root)
+        unless errors.strip.blank?
+          message << ' - ' unless message.strip.blank?
+          message << errors
+        end
+        message
+      end
+
+      # Parses all <ERROR> elements in the response and converts the information
+      # to a single string
+      def errors_to_string(root)
+        # Get context error messages (can be 0..*)
+        errors = []
+        REXML::XPath.each(root, "//ERROR") do |error_elem|
+          error = {}
+          error[:Advice] = []
+          error[:Message] = error_elem.elements['Message'].text
+          error_elem.elements.each('Advice') do |advice|
+            error[:Advice] << advice.text
+          end
+          errors << error
+        end
+        # Convert all messages to a single string
+        string = ''
+        errors.each do |error|
+          string << error[:Message]
+          error[:Advice].each_with_index do |advice, index|
+            string << ' (' if index == 0
+            string << "#{index+1}. #{advice}"
+            string << ' and ' if index < error[:Advice].size - 1
+            string << ')' if index == error[:Advice].size - 1
+          end
+        end
+        string
+      end
+
+      # Encode login and password in Base64 to supply as HTTP header
+      # (for http basic authentication)
+      def encoded_credentials
+        credentials = [@options[:login], @options[:password]].join(':')
+        "Basic " << Base64.encode64(credentials).strip
+      end
+      
+    end
+  end
+end
+