activemerchant 1.24.0 → 1.25.0

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

@@ -10,6 +10,46 @@ raise "Need braintree gem 2.x.y. Run `gem install braintree --version '~>2.0'` t
 
 module ActiveMerchant #:nodoc:
   module Billing #:nodoc:
+    # For more information on the Braintree Gateway please visit their
+    # {Developer Portal}[https://www.braintreepayments.com/developers]
+    #
+    # ==== About this implementation
+    #
+    # This implementation leverages the Braintree-authored ruby gem:
+    # https://github.com/braintree/braintree_ruby
+    #
+    # ==== Debugging Information
+    #
+    # Setting an ActiveMerchant +wiredump_device+ will automatically
+    # configure the Braintree logger (via the Braintree gem's
+    # configuration) when the BraintreeBlueGateway is instantiated.
+    # Additionally, the log level will be set to +DEBUG+.  Therefore,
+    # all you have to do is set the +wiredump_device+ and you'll
+    # get your debug output from your HTTP interactions with the
+    # remote gateway. (Don't enable this in production.)
+    #
+    # For example:
+    #
+    #     ActiveMerchant::Billing::BraintreeBlueGateway.wiredump_device = Logger.new(STDOUT)
+    #     # => #<Logger:0x107d385f8 ...>
+    #
+    #     Braintree::Configuration.logger
+    #     # => (some other logger, created by default by the gem)
+    #
+    #     Braintree::Configuration.logger.level
+    #     # => 1 (INFO)
+    #
+    #     ActiveMerchant::Billing::BraintreeBlueGateway.new(:merchant_id => 'x', :public_key => 'x', :private_key => 'x')
+    #
+    #     Braintree::Configuration.logger
+    #     # => #<Logger:0x107d385f8 ...>
+    #
+    #     Braintree::Configuration.logger.level
+    #     # => 0 (DEBUG)
+    #
+    #  Alternatively, you can avoid setting the +wiredump_device+
+    #  and set +Braintree::Configuration.logger+ and/or
+    #  +Braintree::Configuration.logger.level+ directly.
     class BraintreeBlueGateway < Gateway
       include BraintreeCommon
 
@@ -23,8 +63,11 @@ module ActiveMerchant #:nodoc:
         Braintree::Configuration.public_key = options[:public_key]
         Braintree::Configuration.private_key = options[:private_key]
         Braintree::Configuration.environment = (options[:environment] || (test? ? :sandbox : :production)).to_sym
-        Braintree::Configuration.logger.level = Logger::ERROR if Braintree::Configuration.logger
         Braintree::Configuration.custom_user_agent = "ActiveMerchant #{ActiveMerchant::VERSION}"
+        if wiredump_device
+          Braintree::Configuration.logger = wiredump_device
+          Braintree::Configuration.logger.level = Logger::DEBUG
+        end
         super
       end
 
@@ -105,6 +148,7 @@ module ActiveMerchant #:nodoc:
           credit_card_params = merge_credit_card_options({
             :credit_card => {
               :number => creditcard.number,
+              :cvv => creditcard.verification_value,
               :expiration_month => creditcard.month.to_s.rjust(2, "0"),
               :expiration_year => creditcard.year.to_s
             }

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

@@ -17,6 +17,8 @@ module ActiveMerchant #:nodoc:
     class CyberSourceGateway < Gateway
       TEST_URL = 'https://ics2wstest.ic3.com/commerce/1.x/transactionProcessor'
       LIVE_URL = 'https://ics2ws.ic3.com/commerce/1.x/transactionProcessor'
+
+      XSD_VERSION = "1.69"
           
       # visa, master, american_express, discover
       self.supported_cardtypes = [:visa, :master, :american_express, :discover]
@@ -104,10 +106,10 @@ module ActiveMerchant #:nodoc:
       # Request an authorization for an amount from CyberSource 
       #
       # You must supply an :order_id in the options hash 
-      def authorize(money, creditcard, options = {})
-        requires!(options,  :order_id, :email)
+      def authorize(money, creditcard_or_reference, options = {})
+        requires!(options,  :order_id)
         setup_address_hash(options)
-        commit(build_auth_request(money, creditcard, options), options )
+        commit(build_auth_request(money, creditcard_or_reference, options), options )
       end
       
       def auth_reversal(money, identification, options = {})
@@ -122,10 +124,10 @@ module ActiveMerchant #:nodoc:
 
       # Purchase is an auth followed by a capture
       # You must supply an order_id in the options hash  
-      def purchase(money, creditcard, options = {})
-        requires!(options, :order_id, :email)
+      def purchase(money, creditcard_or_reference, options = {})
+        requires!(options, :order_id)
         setup_address_hash(options)
-        commit(build_purchase_request(money, creditcard, options), options)
+        commit(build_purchase_request(money, creditcard_or_reference, options), options)
       end
       
       def void(identification, options = {})
@@ -141,6 +143,33 @@ module ActiveMerchant #:nodoc:
         refund(money, identification, options)
       end
 
+      # Stores a customer subscription/profile with type "on-demand".
+      # To charge the card while creating a profile, pass options[:setup_fee] => money
+      def store(creditcard, options = {})
+        requires!(options, :order_id)
+        setup_address_hash(options)
+        commit(build_create_subscription_request(creditcard, options), options)
+      end
+
+      # Updates a customer subscription/profile
+      def update(reference, creditcard, options = {})
+        requires!(options, :order_id)
+        setup_address_hash(options)
+        commit(build_update_subscription_request(reference, creditcard, options), options)
+      end
+
+      # Removes a customer subscription/profile
+      def unstore(reference, options = {})
+        requires!(options, :order_id)
+        commit(build_delete_subscription_request(reference, options), options)
+      end
+
+      # Retrieves a customer subscription/profile
+      def retrieve(reference, options = {})
+        requires!(options, :order_id)
+        commit(build_retrieve_subscription_request(reference, options), options)
+      end
+
       # CyberSource requires that you provide line item information for tax calculations
       # If you do not have prices for each item or want to simplify the situation then pass in one fake line item that costs the subtotal of the order
       #
@@ -171,18 +200,17 @@ module ActiveMerchant #:nodoc:
         commit(build_tax_calculation_request(creditcard, options), options)	  
       end
       
-      private                       
+      private
+
       # Create all address hash key value pairs so that we still function if we were 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] || {}
       end
       
-      def build_auth_request(money, creditcard, options)
+      def build_auth_request(money, creditcard_or_reference, options)
         xml = Builder::XmlMarkup.new :indent => 2
-        add_address(xml, creditcard, options[:billing_address], options)
-        add_purchase_data(xml, money, true, options)
-        add_creditcard(xml, creditcard)
+        add_creditcard_or_subscription(xml, money, creditcard_or_reference, options)
         add_auth_service(xml)
         add_business_rules_data(xml)
         xml.target!
@@ -210,11 +238,9 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end 
 
-      def build_purchase_request(money, creditcard, options)
+      def build_purchase_request(money, creditcard_or_reference, options)
         xml = Builder::XmlMarkup.new :indent => 2
-        add_address(xml, creditcard, options[:billing_address], options)
-        add_purchase_data(xml, money, true, options)
-        add_creditcard(xml, creditcard)
+        add_creditcard_or_subscription(xml, money, creditcard_or_reference, options)
         add_purchase_service(xml, options)
         add_business_rules_data(xml)
         xml.target!
@@ -249,6 +275,47 @@ module ActiveMerchant #:nodoc:
         xml.target!
       end
 
+      def build_create_subscription_request(creditcard, options)
+        options[:subscription] = (options[:subscription] || {}).merge(:frequency => "on-demand", :amount => 0, :automatic_renew => false)
+
+        xml = Builder::XmlMarkup.new :indent => 2
+        add_address(xml, creditcard, options[:billing_address], options)
+        add_purchase_data(xml, options[:setup_fee] || 0, true, options)
+        add_creditcard(xml, creditcard)
+        add_creditcard_payment_method(xml)
+        add_subscription(xml, options)
+        add_purchase_service(xml, options) if options[:setup_fee]
+        add_subscription_create_service(xml, options)
+        add_business_rules_data(xml)
+        xml.target!
+      end
+
+      def build_update_subscription_request(reference, creditcard, options)
+        xml = Builder::XmlMarkup.new :indent => 2
+        add_address(xml, creditcard, options[:billing_address], options) unless options[:billing_address].blank?
+        add_purchase_data(xml, options[:setup_fee], true, options) unless options[:setup_fee].blank?
+        add_creditcard(xml, creditcard)    if creditcard
+        add_creditcard_payment_method(xml) if creditcard
+        add_subscription(xml, options, reference)
+        add_subscription_update_service(xml, options)
+        add_business_rules_data(xml)
+        xml.target!
+      end
+
+      def build_delete_subscription_request(reference, options)
+        xml = Builder::XmlMarkup.new :indent => 2
+        add_subscription(xml, options, reference)
+        add_subscription_delete_service(xml, options)
+        xml.target!
+      end
+
+      def build_retrieve_subscription_request(reference, options)
+        xml = Builder::XmlMarkup.new :indent => 2
+        add_subscription(xml, options, reference)
+        add_subscription_retrieve_service(xml, options)
+        xml.target!
+      end
+
       def add_business_rules_data(xml)
         xml.tag! 'businessRules' do
           xml.tag!('ignoreAVSResult', 'true') if @options[:ignore_avs]
@@ -272,8 +339,8 @@ module ActiveMerchant #:nodoc:
         xml.tag! 'merchantID', @options[:login]
         xml.tag! 'merchantReferenceCode', options[:order_id]
         xml.tag! 'clientLibrary' ,'Ruby Active Merchant'
-        xml.tag! 'clientLibraryVersion',  '1.0'
-        xml.tag! 'clientEnvironment' , 'Linux'
+        xml.tag! 'clientLibraryVersion',  VERSION
+        xml.tag! 'clientEnvironment' , RUBY_PLATFORM
       end
 
       def add_purchase_data(xml, money = 0, include_grand_total = false, options={})
@@ -283,17 +350,24 @@ module ActiveMerchant #:nodoc:
         end
       end
 
-      def add_address(xml, creditcard, address, options, shipTo = false)      
+      def add_address(xml, creditcard, address, options, shipTo = false)
+        requires!(options, :email)
+
         xml.tag! shipTo ? 'shipTo' : 'billTo' do
-          xml.tag! 'firstName', creditcard.first_name
-          xml.tag! 'lastName', creditcard.last_name 
-          xml.tag! 'street1', address[:address1]
-          xml.tag! 'street2', address[:address2]
-          xml.tag! 'city', address[:city]
-          xml.tag! 'state', address[:state]
-          xml.tag! 'postalCode', address[:zip]
-          xml.tag! 'country', address[:country]
-          xml.tag! 'email', options[:email]
+          xml.tag! 'firstName',             creditcard.first_name             if creditcard
+          xml.tag! 'lastName',              creditcard.last_name              if creditcard
+          xml.tag! 'street1',               address[:address1]
+          xml.tag! 'street2',               address[:address2]                unless address[:address2].blank?
+          xml.tag! 'city',                  address[:city]
+          xml.tag! 'state',                 address[:state]
+          xml.tag! 'postalCode',            address[:zip]
+          xml.tag! 'country',               address[:country]
+          xml.tag! 'company',               address[:company]                 unless address[:company].blank?
+          xml.tag! 'companyTaxID',          address[:companyTaxID]            unless address[:company_tax_id].blank?
+          xml.tag! 'phoneNumber',           address[:phone_number]            unless address[:phone_number].blank?
+          xml.tag! 'email',                 options[:email]
+          xml.tag! 'driversLicenseNumber',  options[:drivers_license_number]  unless options[:drivers_license_number].blank?
+          xml.tag! 'driversLicenseState',   options[:drivers_license_state]   unless options[:drivers_license_state].blank?
         end 
       end
 
@@ -329,7 +403,7 @@ module ActiveMerchant #:nodoc:
         xml.tag! 'ccAuthService', {'run' => 'true'}
         xml.tag! 'ccCaptureService', {'run' => 'true'}
       end
-      
+
       def add_void_service(xml, request_id, request_token)
         xml.tag! 'voidService', {'run' => 'true'} do
           xml.tag! 'voidRequestID', request_id
@@ -351,6 +425,60 @@ module ActiveMerchant #:nodoc:
         end
       end
 
+      def add_subscription_create_service(xml, options)
+        xml.tag! 'paySubscriptionCreateService', {'run' => 'true'}
+      end
+
+      def add_subscription_update_service(xml, options)
+        xml.tag! 'paySubscriptionUpdateService', {'run' => 'true'}
+      end
+
+      def add_subscription_delete_service(xml, options)
+        xml.tag! 'paySubscriptionDeleteService', {'run' => 'true'}
+      end
+
+      def add_subscription_retrieve_service(xml, options)
+        xml.tag! 'paySubscriptionRetrieveService', {'run' => 'true'}
+      end
+
+      def add_subscription(xml, options, reference = nil)
+        options[:subscription] ||= {}
+
+        xml.tag! 'recurringSubscriptionInfo' do
+          if reference
+            reference_code, subscription_id, request_token = reference.split(";")
+            xml.tag! 'subscriptionID',  subscription_id
+          end
+
+          xml.tag! 'status',            options[:subscription][:status]                         if options[:subscription][:status]
+          xml.tag! 'amount',            options[:subscription][:amount]                         if options[:subscription][:amount]
+          xml.tag! 'numberOfPayments',  options[:subscription][:occurrences]                    if options[:subscription][:occurrences]
+          xml.tag! 'automaticRenew',    options[:subscription][:automatic_renew]                if options[:subscription][:automatic_renew]
+          xml.tag! 'frequency',         options[:subscription][:frequency]                      if options[:subscription][:frequency]
+          xml.tag! 'startDate',         options[:subscription][:start_date].strftime("%Y%m%d")  if options[:subscription][:start_date]
+          xml.tag! 'endDate',           options[:subscription][:end_date].strftime("%Y%m%d")    if options[:subscription][:end_date]
+          xml.tag! 'approvalRequired',  options[:subscription][:approval_required] || false
+          xml.tag! 'event',             options[:subscription][:event]                          if options[:subscription][:event]
+          xml.tag! 'billPayment',       options[:subscription][:bill_payment]                   if options[:subscription][:bill_payment]
+        end
+      end
+
+      def add_creditcard_payment_method(xml)
+        xml.tag! 'subscription' do
+          xml.tag! 'paymentMethod', "credit card"
+        end
+      end
+
+      def add_creditcard_or_subscription(xml, money, creditcard_or_reference, options)
+        if creditcard_or_reference.is_a?(String)
+          add_purchase_data(xml, money, true, options)
+          add_subscription(xml, options, creditcard_or_reference)
+        else
+          add_address(xml, creditcard_or_reference, options[:billing_address], options)
+          add_purchase_data(xml, money, true, options)
+          add_creditcard(xml, creditcard_or_reference)
+        end
+      end
       
       # Where we actually build the full SOAP request using builder
       def build_request(body, options)
@@ -366,7 +494,7 @@ module ActiveMerchant #:nodoc:
               end
             end
             xml.tag! 's:Body', {'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance', 'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema'} do
-              xml.tag! 'requestMessage', {'xmlns' => 'urn:schemas-cybersource-com:transaction-data-1.32'} do
+              xml.tag! 'requestMessage', {'xmlns' => "urn:schemas-cybersource-com:transaction-data-#{XSD_VERSION}"} do
                 add_merchant_data(xml, options)
                 xml << body
               end

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

@@ -11,14 +11,18 @@ module ActiveMerchant #:nodoc:
     #
     #   tendollar = 1000
     #
-    # Next, create a credit card object using a TC approved test card.
+    # The transaction result is based on the cent value of the transaction. $10.15 will return a failed transaction
+    # with a response code of "15 – No Issuer", while $10.00 will return "00 – Transaction Approved."
+    #
+    # Next, create a credit card object using a eWay approved test card number (4444333322221111).
     #
     #   creditcard = ActiveMerchant::Billing::CreditCard.new(
-    #	    :number => '4111111111111111',
+    #	    :number => '4444333322221111',
     #	    :month => 8,
     #	    :year => 2006,
     #	    :first_name => 'Longbob',
-    #     :last_name => 'Longsen'
+    #     :last_name => 'Longsen',
+    #     :verification_value => '123'
     #   )
     #   options = {
     #     :order_id => '1230123',
@@ -28,12 +32,12 @@ module ActiveMerchant #:nodoc:
     #                   :state => 'WA',
     #                   :country => 'Australia',
     #                   :zip => '2000'
-    #                 }
+    #                 },
     #     :description => 'purchased items'
     #   }
     #
     # To finish setting up, create the active_merchant object you will be using, with the eWay gateway. If you have a
-    # functional eWay account, replace :login with your account info. 
+    # functional eWay account, replace :login with your Customer ID.
     #
     #   gateway = ActiveMerchant::Billing::Base.gateway(:eway).new(:login => '87654321')
     #
@@ -41,7 +45,7 @@ module ActiveMerchant #:nodoc:
     #
     #   response = gateway.purchase(tendollar, creditcard, options)
     #
-    # Sending a transaction to TrustCommerce with active_merchant returns a Response object, which consistently allows you to:
+    # Sending a transaction to eWay with active_merchant returns a Response object, which consistently allows you to:
     #
     # 1) Check whether the transaction was successful
     #
@@ -131,7 +135,7 @@ module ActiveMerchant #:nodoc:
       
 	    self.money_format = :cents
       self.supported_countries = ['AU']
-      self.supported_cardtypes = [:visa, :master, :american_express]
+      self.supported_cardtypes = [:visa, :master, :american_express, :diners_club]
       self.homepage_url = 'http://www.eway.com.au/'
       self.display_name = 'eWAY'
 	    
@@ -143,7 +147,7 @@ module ActiveMerchant #:nodoc:
 
       # ewayCustomerEmail, ewayCustomerAddress, ewayCustomerPostcode
       def purchase(money, creditcard, options = {})
-        requires!(options, :order_id)
+        requires_address!(options)
 
         post = {}
         add_creditcard(post, creditcard)
@@ -161,6 +165,11 @@ module ActiveMerchant #:nodoc:
       end
       
       private                       
+
+      def requires_address!(options)
+        raise ArgumentError.new("Missing eWay required parameters: address or billing_address") unless (options.has_key?(:address) or options.has_key?(:billing_address))
+      end
+
       def add_creditcard(post, creditcard)
         post[:CardNumber]  = creditcard.number
         post[:CardExpiryMonth]  = sprintf("%.2i", creditcard.month)

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

@@ -0,0 +1,152 @@
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    class FatZebraGateway < Gateway
+      LIVE_URL    = "https://gateway.fatzebra.com.au/v1.0"
+      SANDBOX_URL = "https://gateway.sandbox.fatzebra.com.au/v1.0"
+
+      self.supported_countries = ['AU']
+      self.default_currency = 'AUD'
+      self.money_format = :cents
+      self.supported_cardtypes = [:visa, :master, :american_express, :jcb]
+
+      self.homepage_url = 'https://www.fatzebra.com.au/'
+      self.display_name = 'Fat Zebra'
+    
+      # Setup a new instance of the gateway.
+      #
+      # The options hash should include :username and :token
+      # You can find your username and token at https://dashboard.fatzebra.com.au
+      # Under the Your Account section
+      def initialize(options = {})
+        requires!(options, :username)
+        requires!(options, :token)
+        @username = options[:username]
+        @token    = options[:token]
+        super
+      end
+
+      # To create a purchase on a credit card use:
+      #
+      #   purchase(money, creditcard , { ... })
+      #
+      # To charge a tokenized card
+      #
+      #   purchase(money, {:token => "abzy87u", :cvv => "123"}, { ... }})
+      def purchase(money, creditcard, options = {})
+        post = {}
+
+        add_amount(post, money, options)
+        add_creditcard(post, creditcard, options)
+        post[:reference] = options[:order_id]
+        post[:customer_ip] = options[:ip]
+
+        commit(:post, 'purchases', post)
+      end
+
+      # Refund a transaction
+      #
+      # amount - Integer - the amount to refund
+      # txn_id - String - the original transaction to be refunded
+      # reference - String - your transaction reference
+      def refund(money, txn_id, reference)
+        post = {}
+
+        post[:amount] = money
+        post[:transaction_id] = txn_id
+        post[:reference] = reference
+
+        commit(:post, "refunds", post)
+      end
+
+      # Tokenize a credit card
+      def store(creditcard)
+        post = {}
+        add_creditcard(post, creditcard)
+
+        commit(:post, "credit_cards", post)
+      end
+
+      private
+      # Add the money details to the request
+      def add_amount(post, money, options)
+        post[:amount] = money
+      end
+
+      # Add the credit card details to the request
+      def add_creditcard(post, creditcard, options = {})
+        if creditcard.respond_to?(:number)
+          post[:card_number] = creditcard.number
+          post[:card_expiry] = "#{creditcard.month}/#{creditcard.year}"
+          post[:cvv] = creditcard.verification_value if creditcard.verification_value?
+          post[:card_holder] = creditcard.name if creditcard.name
+        else
+            post[:card_token] = creditcard[:token]
+            post[:cvv] = creditcard[:cvv]
+        end
+      end
+
+      # Post the data to the gateway
+      def commit(method, uri, parameters=nil)
+        raw_response = response = nil
+        success = false
+        begin
+          raw_response = ssl_request(method, get_url(uri), parameters.to_json, headers)
+          response = parse(raw_response)
+          success = response["successful"] && (response["response"]["successful"] || response["response"]["token"])
+        rescue ResponseError => e
+          if e.response.code == "401"
+            return Response.new(false, "Invalid Login")
+          end
+
+          raw_response = e.response.body
+          response = parse(raw_response)
+        rescue JSON::ParserError
+          response = json_error(raw_response)
+        end
+
+        message = response["response"]["message"]
+        unless response["successful"]
+          # There is an error, so we will show that instead
+          message = response["errors"].empty? ? "Unknown Error" : response["errors"].join(", ")
+        end
+
+        Response.new(success,
+          message,
+          response,
+          :test => response.has_key?("test") ? response["test"] : false,
+          :authorization => response["response"]["id"] || response["response"]["token"])
+      end
+
+      # Parse the returned JSON, if parse errors are raised then return a detailed error.
+      def parse(response)
+        begin
+          JSON.parse(response)
+        rescue JSON::ParserError
+          msg = 'Invalid JSON response received from Fat Zebra. Please contact support@fatzebra.com.au if you continue to receive this message.'
+          msg += "  (The raw response returned by the API was #{response.inspect})"
+          {
+            "successful" => false,
+            "response" => {},
+            "errors" => [msg]
+          }
+        end
+      end
+
+      # Build the URL based on the AM mode and the URI
+      def get_url(uri)
+        base = test? ? SANDBOX_URL : LIVE_URL
+        base + "/" + uri
+      end
+
+      # Builds the auth and U-A headers for the request
+      def headers
+        {
+          "Authorization" => "Basic " + Base64.strict_encode64(@username.to_s + ":" + @token.to_s).strip,
+          "User-Agent" => "Fat Zebra v1.0/ActiveMerchant #{ActiveMerchant::VERSION}"
+        }
+      end 
+    end
+  end
+end