Adds preliminary support for Klarna

lib/active_merchant/billing/integrations/helper.rb

@@ -19,16 +19,16 @@ def self.inherited(subclass)
 
         def initialize(order, account, options = {})
           options.assert_valid_keys([:amount, :currency, :test, :credential2, :credential3, :credential4, :country, :account_name, :transaction_type, :authcode, :notify_url, :return_url, :redirect_param, :forward_url])
-          @fields             = {}
-          @raw_html_fields    = []
-          @test               = options[:test]
-          self.order          = order
-          self.account        = account
-          self.amount         = options[:amount]
-          self.currency       = options[:currency]
-          self.credential2    = options[:credential2]
-          self.credential3    = options[:credential3]
-          self.credential4    = options[:credential4]
+          @fields          = {}
+          @raw_html_fields = []
+          @test            = options[:test]
+          self.order       = order
+          self.account     = account
+          self.amount      = options[:amount]
+          self.currency    = options[:currency]
+          self.credential2 = options[:credential2]
+          self.credential3 = options[:credential3]
+          self.credential4 = options[:credential4]
           self.notify_url     = options[:notify_url]
           self.return_url     = options[:return_url]
           self.redirect_param = options[:redirect_param]
@@ -100,8 +100,9 @@ def lookup_country_code(name_or_code, format = country_format)
 
         def method_missing(method_id, *args)
           method_id = method_id.to_s.gsub(/=$/, '').to_sym
-          # Return and do nothing if the mapping was not found. This allows
-          # For easy substitution of the different integrations
+
+          # Return and do nothing if the mapping was not found. This allows 
+          # for easy substitution of the different integrations
           return if mappings[method_id].nil?
 
           mapping = mappings[method_id]

lib/active_merchant/billing/integrations/klarna.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/klarna/helper.rb'
+require File.dirname(__FILE__) + '/klarna/notification.rb'
+require 'digest'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Klarna
+        mattr_accessor :service_url
+        self.service_url = 'https://api.hostedcheckout.io/api/v1/checkout'
+
+        def self.notification(post_body, options = {})
+          Notification.new(post_body, options)
+        end
+
+        def self.return(query_string, options = {})
+          Return.new(query_string, options)
+        end
+
+        def self.cart_items_payload(fields, cart_items)
+          check_required_fields!(fields)
+
+          payload = fields['purchase_country'].to_s + 
+                    fields['purchase_currency'].to_s + 
+                    fields['locale'].to_s
+
+          cart_items.each do |item|
+            payload << item[:type].to_s +
+                       item[:reference].to_s +
+                       item[:quantity].to_s +
+                       item[:unit_price].to_s +
+                       item.fetch(:discount_rate, nil).to_s
+          end
+
+          payload << fields['merchant_id'].to_s +
+                     fields['merchant_terms_uri'].to_s +
+                     fields['merchant_checkout_uri'].to_s +
+                     fields['merchant_base_uri'].to_s +
+                     fields['merchant_confirmation_uri'].to_s
+
+          payload
+        end
+
+        def self.sign(fields, cart_items, shared_secret)
+          payload = cart_items_payload(fields, cart_items)
+
+          digest(payload, shared_secret)
+        end
+
+        def self.digest(payload, shared_secret)
+          Digest::SHA256.base64digest(payload + shared_secret.to_s)
+        end
+
+        private
+
+        def self.check_required_fields!(fields)
+          %w(purchase_country 
+             purchase_currency
+             locale
+             merchant_id
+             merchant_terms_uri
+             merchant_checkout_uri
+             merchant_base_uri
+             merchant_confirmation_uri).each do |required_field|
+            raise ArgumentError, "Missing required field #{required_field}" if fields[required_field].nil?
+          end
+        end
+      end
+    end
+  end
+end

lib/active_merchant/billing/integrations/klarna/helper.rb

@@ -0,0 +1,91 @@
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Klarna
+        class Helper < ActiveMerchant::Billing::Integrations::Helper
+          mapping :currency, 'purchase_currency'
+          mapping :return_url, 'merchant_confirmation_uri'
+          mapping :notify_url, 'merchant_push_uri'
+          mapping :cancel_return_url, ['merchant_terms_uri', 'merchant_checkout_uri', 'merchant_base_uri']
+          mapping :account, 'merchant_id'
+          mapping :customer, email: 'shipping_address_email'
+
+          def initialize(order, account, options = {})
+            super
+            @shared_secret = options[:credential2]
+
+            add_field('platform_type', application_id)
+            add_field('test_mode', test?)
+          end
+
+          def line_item(item)
+            @line_items ||= []
+            @line_items << item
+
+            i = @line_items.size - 1
+
+            add_field("cart_item-#{i}_type", item.fetch(:type, ''))
+            add_field("cart_item-#{i}_reference", item.fetch(:reference, ''))
+            add_field("cart_item-#{i}_name", item.fetch(:name, ''))
+            add_field("cart_item-#{i}_quantity", item.fetch(:quantity, ''))
+            add_field("cart_item-#{i}_unit_price", item.fetch(:unit_price, ''))
+            add_field("cart_item-#{i}_discount_rate", item.fetch(:discount_rate, ''))
+            add_field("cart_item-#{i}_tax_rate", item.fetch(:tax_rate, ''))
+
+            @fields
+          end
+
+          def billing_address(billing_fields)
+            country = billing_fields[:country]
+
+            add_field('purchase_country', country)
+            add_field('locale', guess_locale_based_on_country(country))
+          end
+
+          def shipping_address(shipping_fields)
+            add_field('shipping_address_given_name', shipping_fields[:first_name])
+            add_field('shipping_address_family_name', shipping_fields[:last_name])
+
+            street_address = [shipping_fields[:address1], shipping_fields[:address2]].join(', ')
+            add_field('shipping_address_street_address', street_address)
+
+            add_field('shipping_address_postal_code', shipping_fields[:zip])
+            add_field('shipping_address_city', shipping_fields[:city])
+            add_field('shipping_address_country', shipping_fields[:country])
+            add_field('shipping_address_phone', shipping_fields[:phone])
+          end
+
+          def form_fields
+            sign_fields
+
+            super
+          end
+
+          def sign_fields
+            merchant_digest = Klarna.sign(@fields, @line_items, @shared_secret)
+            add_field('merchant_digest', merchant_digest)
+          end
+
+          private
+
+          def street_address
+            [address1, address2].compact.join(', ')
+          end
+
+          def guess_locale_based_on_country(country_code)
+            case country_code
+            when /no/i
+              "nb-no"
+            when /fi/i
+              "fi-fi"
+            when /se/i
+              "sv-se"
+            else
+              raise StandardError, "Unable to guess locale based on country #{country_code}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/active_merchant/billing/integrations/klarna/notification.rb

@@ -0,0 +1,98 @@
+require 'net/http'
+require 'json'
+
+module ActiveMerchant #:nodoc:
+  module Billing #:nodoc:
+    module Integrations #:nodoc:
+      module Klarna
+        class Notification < ActiveMerchant::Billing::Integrations::Notification
+          def initialize(post, options = {})
+            super
+            @shared_secret = @options[:credential2]
+          end
+
+          def complete?
+            status == 'Complete'
+          end
+
+          def item_id
+            params["reservation"]
+          end
+
+          def transaction_id
+            params["reference"]
+          end
+
+          def received_at
+            params["completed_at"]
+          end
+
+          def payer_email
+            params["billing_address"]["email"]
+          end
+
+          def receiver_email
+            params["shipping_address"]["email"]
+          end
+
+          def currency
+            params["purchase_currency"]
+          end
+
+          def gross
+            amount = Float(gross_cents) / 100
+            sprintf("%.2f", amount)
+          end
+
+          def gross_cents
+            params["cart"]["total_price_including_tax"]
+          end
+
+          def status
+            case params['status']
+            when 'checkout_complete'
+              'Complete'
+            else
+              params['status']
+            end
+          end
+
+          def acknowledge(authcode = nil)
+            Verifier.new(@options[:authorization_header], @raw, @shared_secret).verify
+          end
+
+          private
+
+          def parse(post)
+            @raw = post.to_s
+            @params = JSON.parse(post)
+          end
+
+          class Verifier
+            attr_reader :header, :payload, :digest, :shared_secret
+            def initialize(header, payload, shared_secret)
+              @header, @payload, @shared_secret = header, payload, shared_secret
+
+              @digest = extract_digest
+            end
+
+            def verify
+              digest_matches?
+            end
+
+            private
+
+            def extract_digest
+              match = header.match(/^Klarna (?<digest>.+)$/)
+              match && match[:digest]
+            end
+
+            def digest_matches?
+              Klarna.digest(payload, shared_secret) == digest
+            end
+          end
+        end
+      end
+    end
+  end
+end

test/test_helper.rb

@@ -10,6 +10,8 @@
 end
 
 require 'test/unit'
+require 'minitest/autorun'
+
 require 'money'
 require 'mocha/version'
 if(Mocha::VERSION.split(".")[1].to_i < 12)
@@ -61,7 +63,6 @@ class SimpleTestGateway < ActiveMerchant::Billing::Gateway
 class SubclassGateway < SimpleTestGateway
 end
 
-
 module ActiveMerchant
   module Assertions
     AssertionClass = RUBY_VERSION > '1.9' ? MiniTest::Assertion : Test::Unit::AssertionFailedError
@@ -72,7 +73,7 @@ def assert_field(field, value)
       end
     end
 
-    # Allows the testing of you to check for negative assertions:
+    # Allows testing of negative assertions:
     #
     #   # Instead of
     #   assert !something_that_is_false
@@ -91,7 +92,7 @@ def assert_false(boolean, message = nil)
       end
     end
 
-    # A handy little assertion to check for a successful response:
+    # An assertion of a successful response:
     #
     #   # Instead of
     #   assert response.success?
@@ -231,7 +232,6 @@ def symbolize_keys(hash)
 end
 
 module ActionViewHelperTestHelper
-
   def self.included(base)
     base.send(:include, ActiveMerchant::Billing::Integrations::ActionViewHelper)
     base.send(:include, ActionView::Helpers::FormHelper)