workarea-worldpay_xml 1.0.1

data/app/models/workarea/payment/authorize/credit_card.decorator

@@ -0,0 +1,36 @@
+module Workarea
+  decorate Payment::Authorize::CreditCard, with: :worldpay_xml_api do
+    decorated do
+      include Payment::CreditCardData
+      delegate :address, to: :tender
+    end
+
+    def complete!
+     return unless Payment::StoreCreditCard.new(tender, options).save!
+
+      transaction.response = handle_active_merchant_errors do
+        gateway.authorize(
+          transaction.amount.cents,
+          tender.to_token_or_active_merchant,
+          transaction_options
+        )
+      end
+    end
+
+    private
+
+    def transaction_options
+      {
+        order_id: order_id,
+        pay_by_token: true,
+        token: tender.token,
+        shopper_id: tender.profile.email,
+        email: tender.profile.email,
+        address: billing_address,
+        order_content: order_content,
+        currency: currency_code
+      }
+    end
+  end
+end
+

data/app/models/workarea/payment/credit_card_data.rb

@@ -0,0 +1,48 @@
+module Workarea
+  class Payment
+    module CreditCardData
+      def billing_address
+        {
+          name:       "#{address.first_name} #{address.last_name}",
+          company:    address.company,
+          address1:   address.street,
+          city:       address.city,
+          state:      address.region,
+          country:    address.country.try(:alpha2),
+          zip:        address.postal_code,
+          phone:      nil
+        }
+      end
+
+      def order
+        @order ||= Workarea::Order.find(tender.payment.id)
+      end
+
+      def order_content
+        @order_content ||= begin
+          contents = order.items.map { |oi| oi.sku }.join(',')
+          "Env: #{Rails.env}, Items: #{contents}"
+        end
+      end
+
+      def currency_code
+        @currency_code = order.total_price.currency.iso_code
+      end
+
+      # Worldpay requires a unique order code per transaction, even
+      # if the transaction was a failure and a new card is used.
+      # Appending the time stamp gives some historical context
+      # in the payment admin
+      #
+      #  !!!! A duplicate order code could cause a users credit card
+      #  to be charged multiple times. Make sure this method returns a unique
+      #  value each time. !!!!
+      def order_id
+        @order_id ||= begin
+          stamp = DateTime.now.strftime('%Y_%m_%d_%H_%M_%S')
+          "#{tender.payment.id}_#{stamp}"
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/payment/purchase/credit_card.decorator

@@ -0,0 +1,36 @@
+module Workarea
+  decorate Payment::Purchase::CreditCard, with: :worldpay_xml_api do
+    decorated do
+      include Payment::CreditCardData
+      delegate :address, to: :tender
+    end
+
+    def complete!
+      return unless Workarea::Payment::StoreCreditCard.new(tender, options).save!
+
+      transaction.response = handle_active_merchant_errors do
+        gateway.purchase(
+          transaction.amount.cents,
+          tender.to_token_or_active_merchant,
+          transaction_options
+        )
+      end
+    end
+
+    private
+
+    def transaction_options
+      {
+        order_id: order_id,
+        pay_by_token: true,
+        token: tender.token,
+        shopper_id: tender.profile.email,
+        email: tender.profile.email,
+        address: billing_address,
+        order_content: order_content,
+        currency: currency_code
+      }
+    end
+  end
+end
+

data/app/models/workarea/payment/refund/credit_card.decorator

@@ -0,0 +1,28 @@
+module Workarea
+  decorate Payment::Refund::CreditCard, with: :worldpay_xml_api do
+    decorated do
+      include Payment::CreditCardData
+      delegate :address, to: :tender
+    end
+
+    def complete!
+      validate_reference!
+
+      transaction.response = handle_active_merchant_errors do
+        gateway.refund(
+          transaction.amount.cents,
+          transaction.reference.response.authorization,
+          transaction_options
+        )
+      end
+    end
+
+    private
+
+    def transaction_options
+      {
+         currency: currency_code
+      }
+    end
+  end
+end

data/app/models/workarea/payment/store_credit_card.decorator

@@ -0,0 +1,27 @@
+module Workarea
+  decorate Payment::StoreCreditCard, with: :worldpay_xml_api do
+    decorated do
+      include Payment::CreditCardData
+      delegate :address, to: :tender
+    end
+
+    def perform!
+      return true if @credit_card.token.present?
+
+      response = handle_active_merchant_errors do
+        gateway.create_token(@credit_card.to_active_merchant, token_options)
+      end
+
+      @credit_card.token = response.params["payment_token_id"]
+    end
+
+    private
+
+    def token_options
+      {
+        shopper_id: @credit_card.profile.email,
+        order_id:   @credit_card.profile.reference
+      }
+    end
+  end
+end

data/app/models/workarea/payment/tender/credit_card.decorator

@@ -0,0 +1,7 @@
+module Workarea
+  decorate Payment::Tender::CreditCard, with: :worldpay_xml_api do
+    def to_token_or_active_merchant
+      token.presence || to_active_merchant
+    end
+  end
+end

data/bin/rails

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/workarea/worldpay_xml/engine', __FILE__)
+APP_PATH = File.expand_path('../../test/dummy/config/application', __FILE__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require "action_controller/railtie"
+require "action_view/railtie"
+require "action_mailer/railtie"
+require "rails/test_unit/railtie"
+require "sprockets/railtie"
+require 'teaspoon-mocha'
+
+require 'rails/engine/commands'

data/config/initializers/workarea.rb

@@ -0,0 +1 @@
+Workarea::WorldpayXml.auto_initialize_gateway

data/lib/active_merchant/billing/bogus_worldpay_gateway.rb

@@ -0,0 +1,65 @@
+module ActiveMerchant
+  module Billing
+    class BogusWorldpayGateway < BogusGateway
+      def create_token(paysource, options= {})
+        case normalize(paysource)
+          when /1$/
+            Response.new(
+              true,
+              SUCCESS_MESSAGE,
+              { payment_token_id: SecureRandom.hex(10).upcase + '1' },
+              :test => true,
+              :authorization => AUTHORIZATION
+            )
+          when /2$/
+            Response.new(
+              false,
+              FAILURE_MESSAGE,
+              { payment_token_id: nil, error: FAILURE_MESSAGE },
+              :test => true,
+              :error_code => STANDARD_ERROR_CODE[:processing_error]
+            )
+          else
+            raise Error, error_message(paysource)
+        end
+      end
+
+      def authorize_swipe(money, paysource, options = {})
+        money = amount(money)
+        case normalize(paysource)
+          when /2$/
+            Response.new(false, FAILURE_MESSAGE, {:authorized_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+          when /3$/
+            Response.new(false, FAILURE_MESSAGE, {:authorized_amount => money, :error => FAILURE_MESSAGE }, :test => true, :error_code => STANDARD_ERROR_CODE[:processing_error])
+          else
+            Response.new(true, SUCCESS_MESSAGE, {:authorized_amount => money}, :test => true, :authorization => AUTHORIZATION )
+        end
+      end
+
+      def purchase_swipe(money, paysource, options = {})
+        money = amount(money)
+        case normalize(paysource)
+          when /3$/
+            raise Error, error_message(paysource)
+          when /2$/
+            Response.new(
+              false,
+              FAILURE_MESSAGE,
+              {:paid_amount => money, :error => FAILURE_MESSAGE },
+              :test => true,
+              :error_code => STANDARD_ERROR_CODE[:processing_error]
+            )
+          else
+            Response.new(
+              true,
+              SUCCESS_MESSAGE,
+              {:paid_amount => money},
+              :test => true,
+              :authorization => AUTHORIZATION
+            )
+        end
+      end
+    end
+  end
+end
+

data/lib/active_merchant/billing/worldpay_tokenize.rb

@@ -0,0 +1,118 @@
+ActiveMerchant::Billing::WorldpayGateway.class_eval do
+  def create_token(payment_method, options = {})
+    requires!(options, :order_id)
+    create_token_request(payment_method, options)
+  end
+
+  private
+
+  def create_token_request(payment_method, options)
+    commit('payment_token_create', build_create_token_request(payment_method, options), nil)
+  end
+
+  def build_create_token_request(payment_method, options)
+    build_request do |xml|
+      xml.tag! 'submit' do
+        xml.tag! 'paymentTokenCreate' do
+          xml.tag! 'authenticatedShopperID', options[:shopper_id]
+          add_token_details(xml, options)
+          add_token_payment_method(xml, payment_method, options)
+        end
+      end
+    end
+  end
+
+  def add_token_details(xml, options)
+    return unless options[:order_id]
+    xml.tag! 'createToken' do
+      xml.tag! 'tokenEventReference', options[:order_id]
+      xml.tag! 'tokenReason', 'Saved payment method'
+    end
+  end
+
+  def add_token_payment_method(xml, payment_method, options)
+    return unless options[:order_id]
+    xml.tag! 'paymentInstrument' do
+      xml.tag! 'cardDetails' do
+        xml.tag! 'cardNumber', payment_method.number
+        xml.tag! 'expiryDate' do
+          xml.tag! 'date', 'month' => format(payment_method.month, :two_digits), 'year' => format(payment_method.year, :four_digits)
+        end
+        xml.tag! 'cardHolderName', payment_method.name
+        xml.tag! 'cvc', payment_method.verification_value
+      end
+      add_address(xml, (options[:billing_address] || options[:address]))
+    end
+  end
+
+  # success_criteria can be:
+  #   - a string or an array of strings (if one of many responses)
+  #   - An array of strings if one of many responses could be considered a
+  #     success.
+  #   - if empty then look for error codes
+  def success_and_message_from(raw, success_criteria)
+    success = if success_criteria.compact.empty?
+      !(raw[:error].present? && raw[:error_code].present?)
+    else
+      (success_criteria.include?(raw[:last_event]) || raw[:ok].present?)
+    end
+
+    if success
+      message = "SUCCESS"
+    else
+      message = (raw[:iso8583_return_code_description] || raw[:error] || required_status_message(raw, success_criteria))
+    end
+
+    [ success, message ]
+  end
+
+  def add_payment_method(xml, amount, payment_method, options)
+    if payment_method.is_a?(String)
+      if options[:merchant_code]
+        xml.tag! 'payAsOrder', 'orderCode' => payment_method, 'merchantCode' => options[:merchant_code] do
+          add_amount(xml, amount, options)
+        end
+      elsif options[:pay_by_token]
+        xml.tag! 'paymentDetails' do
+          xml.tag! 'TOKEN-SSL', 'tokenScope' => 'shopper' do
+            xml.tag! 'paymentTokenID', payment_method
+          end
+        end
+      else
+        xml.tag! 'payAsOrder', 'orderCode' => payment_method do
+          add_amount(xml, amount, options)
+        end
+      end
+    else
+      xml.tag! 'paymentDetails' do
+        xml.tag! CARD_CODES[card_brand(payment_method)] do
+          xml.tag! 'cardNumber', payment_method.number
+          xml.tag! 'expiryDate' do
+            xml.tag! 'date', 'month' => format(payment_method.month, :two_digits), 'year' => format(payment_method.year, :four_digits)
+          end
+
+          xml.tag! 'cardHolderName', payment_method.name
+          xml.tag! 'cvc', payment_method.verification_value
+
+          add_address(xml, (options[:billing_address] || options[:address]))
+        end
+        if options[:ip] && options[:session_id]
+          xml.tag! 'session', 'shopperIPAddress' => options[:ip], 'id' => options[:session_id]
+        else
+          xml.tag! 'session', 'shopperIPAddress' => options[:ip] if options[:ip]
+          xml.tag! 'session', 'id' => options[:session_id] if options[:session_id]
+        end
+      end
+    end
+  end
+
+  def add_email(xml, options)
+    return unless options[:email]
+    xml.tag! 'shopper' do
+      xml.tag! 'shopperEmailAddress', options[:email]
+      if options[:pay_by_token]
+        xml.tag! 'authenticatedShopperID', options[:shopper_id]
+      end
+    end
+  end
+end

data/lib/workarea/worldpay_xml.rb

@@ -0,0 +1,48 @@
+require 'workarea'
+require 'workarea/storefront'
+require 'workarea/admin'
+
+require 'workarea/worldpay_xml/engine'
+require 'workarea/worldpay_xml/version'
+
+require 'active_merchant/billing/bogus_worldpay_gateway'
+require 'active_merchant/billing/worldpay_tokenize'
+
+
+module Workarea
+  module WorldpayXml
+    # Credentials for WorldpayGateway from Rails secrets.
+    #
+    # @return [Hash]
+    def self.credentials
+      return {} unless Rails.application.secrets.worldpay.present?
+      Rails.application.secrets.worldpay.symbolize_keys
+    end
+
+    # Conditionally use the real gateway when secrets are present.
+    # Otherwise, use the bogus gateway.
+    #
+    # @return [ActiveMerchant::Billing::Gateway]
+    def self.gateway
+      Workarea.config.gateways.credit_card
+    end
+
+    def self.gateway=(gateway)
+      Workarea.config.gateways.credit_card = gateway
+    end
+
+    def self.auto_initialize_gateway
+      if credentials.present?
+        if ENV['HTTP_PROXY'].present?
+          uri = URI.parse(ENV['HTTP_PROXY'])
+          ActiveMerchant::Billing::WorldpayGateway.proxy_address = uri.host
+          ActiveMerchant::Billing::WorldpayGateway.proxy_port = uri.port
+        end
+
+        self.gateway = ActiveMerchant::Billing::WorldpayGateway.new credentials
+      else
+        self.gateway = ActiveMerchant::Billing::BogusWorldpayGateway.new
+      end
+    end
+  end
+end