workarea-payware_connect 2.1.2

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

@@ -0,0 +1,37 @@
+module Workarea
+  decorate Payment::Purchase::CreditCard, with: :payware_connect do
+    decorated { delegate :address, to: :tender }
+
+    def complete!
+      transaction.response = handle_active_merchant_errors do
+        gateway.purchase(
+          transaction.amount.cents,
+          tender_payment.merge(billing_address: address)
+        )
+      end
+
+      if transaction.response.success?
+        tender.token = transaction.response.troutd
+        tender.save!
+      end
+
+      transaction.response
+    end
+
+    def cancel!
+      return unless transaction.success?
+
+      transaction.cancellation = handle_active_merchant_errors do
+        gateway.void(transaction.response.troutd)
+      end
+    end
+
+    private
+
+    def tender_payment
+      return { troutd: tender.token } if tender.tokenized?
+
+      { credit_card: tender.to_active_merchant }
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module Workarea
+  decorate Payment::Refund::CreditCard, with: :payware_connect do
+    def complete!
+      validate_reference!
+
+      transaction.response = handle_active_merchant_errors do
+        gateway.refund(
+          transaction.amount.cents,
+          transaction.reference.response.troutd
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Workarea
+  decorate Payment::StoreCreditCard, with: :payware_connect do
+    def perform!
+      return true if @credit_card.token.present?
+
+      response = handle_active_merchant_errors do
+        gateway.store(@credit_card.to_active_merchant)
+      end
+
+      @credit_card.token = response.troutd
+    end
+  end
+end

data/app/workers/workarea/save_user_order_details.decorator

@@ -0,0 +1,33 @@
+module Workarea
+  decorate SaveUserOrderDetails, with: :payware_connect do
+    def save_payment_details(order, user)
+      payment = Payment.find_or_initialize_by(id: order.id)
+      payment_profile = Payment::Profile.lookup(PaymentReference.new(user))
+      billing_address = extract_address_attributes(payment.address)
+
+      if billing_address.present?
+        user.auto_save_billing_address(billing_address)
+
+        if user.public_info.blank?
+          user.update_attributes!(
+            first_name: billing_address[:first_name],
+            last_name: billing_address[:last_name]
+          )
+        end
+      end
+
+      if payment.credit_card? && !payment.credit_card.saved?
+        payment_profile.credit_cards.create(
+          first_name: payment.credit_card.first_name,
+          last_name: payment.credit_card.last_name,
+          display_number: payment.credit_card.display_number,
+          issuer: payment.credit_card.issuer,
+          month: payment.credit_card.month,
+          year: payment.credit_card.year,
+          token: payment.credit_card.token,
+          partial_number: payment.credit_card.partial_number
+        )
+      end
+    end
+  end
+end

data/bin/rails

@@ -0,0 +1,18 @@
+#!/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/payware_connect/engine", __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 "rails/engine/commands"

data/config/initializers/00_defaults.rb

@@ -0,0 +1 @@
+Workarea::PaywareConnect.auto_configure_gateway

data/lib/active_merchant/billing/bogus_payware_connect_gateway.rb

@@ -0,0 +1,130 @@
+module ActiveMerchant
+  module Billing
+    class BogusPaywareConnectGateway < ActiveMerchant::Billing::BogusGateway
+      def authorize(cents, credit_card_or_troutd, options = {})
+        credit_card_or_troutd = credit_card_or_troutd[:credit_card] || credit_card_or_troutd[:troutd]
+        case normalize(credit_card_or_troutd)
+        when /1$/, ActiveMerchant::Billing::BogusGateway::AUTHORIZATION
+          successful_auth_response(cents)
+        when /2$/
+          failure_response(cents)
+        else
+          raise Error, error_message(credit_card_or_troutd)
+        end
+      end
+
+      def purchase(cents, credit_card_or_troutd, options = {})
+        credit_card_or_troutd = credit_card_or_troutd[:credit_card] || credit_card_or_troutd[:troutd]
+        case normalize(credit_card_or_troutd)
+        when /1$/, ActiveMerchant::Billing::BogusGateway::AUTHORIZATION
+          successful_purchase_response(cents)
+        when /2$/
+          failure_response(cents)
+        else
+          raise Error, error_message(credit_card_or_troutd)
+        end
+      end
+
+      def store(credit_card, options = {})
+        authorize(0, credit_card: credit_card, amount: "0.0")
+      end
+
+      private
+
+        def failure_response(money)
+          Response.new(
+            false,
+            FAILURE_MESSAGE,
+            { authorized_amount: money, error: FAILURE_MESSAGE },
+            { test: true, error_code: STANDARD_ERROR_CODE[:processing_error] }
+          )
+        end
+
+        def successful_auth_response(cents)
+          result = "APPROVED"
+          troutd = ActiveMerchant::Billing::BogusGateway::AUTHORIZATION
+
+          params = {
+            "RESPONSE" => {
+              "AUTH_CODE"          => "094073",
+              "AVS_CODE"           => "Y",
+              "BATCH_NUM"          => "329001",
+              "CLIENT_ID"          => "7769900010001",
+              "COMMAND"            => "PRE_AUTH",
+              "CTROUTD"            => "24",
+              "CVV2_CODE"          => "Y",
+              "INTRN_SEQ_NUM"      => "4666700",
+              "INVOICE"            => "4666700",
+              "PAYMENT_MEDIA"      => "VISA",
+              "PAYMENT_TYPE"       => "CREDIT",
+              "PY_RESP_CODE"       => "A",
+              "REFERENCE"          => "00000020",
+              "RESPONSE_CODE"      => "A",
+              "RESPONSE_TEXT"      => result,
+              "RESULT"             => result,
+              "RESULT_CODE"        => "5",
+              "TERMINATION_STATUS" => "SUCCESS",
+              "TRANS_AMOUNT"       => "%.2f" % (cents.to_f / 100.0),
+              "TRANS_DATE"         => "2013.11.25",
+              "TRANS_SEQ_NUM"      => "30",
+              "TRANS_TIME"         => "15:13:17",
+              "TROUTD"             => troutd
+            }
+          }
+
+          ActiveMerchant::Billing::Response.new(
+            true,
+            "APPROVED",
+            params,
+            test: true,
+            authorization: params["RESPONSE"]["TROUTD"],
+            cvv_result: params["RESPONSE"]["CVV2_CODE"],
+            avs_result: { code: params["RESPONSE"]["AVS_CODE"] }
+          )
+        end
+
+        def successful_purchase_response(cents)
+          result = "APPROVED"
+          troutd = ActiveMerchant::Billing::BogusGateway::AUTHORIZATION
+
+          params = {
+            "RESPONSE" => {
+              "AUTH_CODE"          => "094073",
+              "AVS_CODE"           => "Y",
+              "BATCH_NUM"          => "329001",
+              "CLIENT_ID"          => "7769900010001",
+              "COMMAND"            => "SALE",
+              "CTROUTD"            => "24",
+              "CVV2_CODE"          => "Y",
+              "INTRN_SEQ_NUM"      => "4666700",
+              "INVOICE"            => "4666700",
+              "PAYMENT_MEDIA"      => "VISA",
+              "PAYMENT_TYPE"       => "CREDIT",
+              "PY_RESP_CODE"       => "A",
+              "REFERENCE"          => "00000020",
+              "RESPONSE_CODE"      => "A",
+              "RESPONSE_TEXT"      => result,
+              "RESULT"             => result,
+              "RESULT_CODE"        => "5",
+              "TERMINATION_STATUS" => "SUCCESS",
+              "TRANS_AMOUNT"       => "%.2f" % (cents.to_f / 100.0),
+              "TRANS_DATE"         => "2013.11.25",
+              "TRANS_SEQ_NUM"      => "30",
+              "TRANS_TIME"         => "15:13:17",
+              "TROUTD"             => troutd
+            }
+          }
+
+          ActiveMerchant::Billing::Response.new(
+            true,
+            "APPROVED",
+            params,
+            test: true,
+            authorization: params["RESPONSE"]["TROUTD"],
+            cvv_result: params["RESPONSE"]["CVV2_CODE"],
+            avs_result: { code: params["RESPONSE"]["AVS_CODE"] }
+          )
+        end
+    end
+  end
+end

data/lib/active_merchant/billing/payware_connect_gateway.rb

@@ -0,0 +1,137 @@
+module ActiveMerchant
+  module Billing
+    class PaywareConnectGateway < ActiveMerchant::Billing::Gateway
+      require "active_merchant/billing/payware_response"
+      require "active_merchant/billing/payware_connect_gateway/xml_builder"
+      require "active_merchant/billing/payware_connect_gateway/actions/authorize"
+      require "active_merchant/billing/payware_connect_gateway/actions/capture"
+      require "active_merchant/billing/payware_connect_gateway/actions/purchase"
+      require "active_merchant/billing/payware_connect_gateway/actions/refund"
+      require "active_merchant/billing/payware_connect_gateway/actions/void"
+      require "active_merchant/billing/payware_connect_gateway/admin_xml_builder"
+      require "active_merchant/billing/payware_connect_gateway/admin_actions/add_contract"
+      require "active_merchant/billing/payware_connect_gateway/admin_actions/add_customer"
+      require "active_merchant/billing/payware_connect_gateway/admin_actions/add_customer_and_contract"
+      require "active_merchant/billing/payware_connect_gateway/admin_actions/update_contract"
+      require "active_merchant/billing/payware_connect_gateway/admin_actions/update_customer"
+
+      self.ssl_version = :TLSv1_2
+      self.test_url = "https://cert.api.vfipayna.com/IPCHAPI/RH.ASPX"
+      self.live_url = "https://api.vfipayna.com/IPCHAPI/RH.ASPX"
+
+      cattr_accessor :test_admin_url, :live_admin_url
+      self.test_admin_url = "https://cert1.ipcharge.net/ipcadminapi/RH.ipc"
+      self.live_admin_url = "https://prod1.ipcharge.net/ipcadminapi/RH.ipc"
+
+      def initialize(options = {})
+        requires!(options, :login, :password)
+        super
+      end
+
+      def authorize(cents, command_options = {})
+        commit(Actions::Authorize.new(cents, command_options.merge(options)).build)
+      end
+
+      def store(credit_card, command_options = {})
+        command_options = command_options.merge(credit_card: credit_card)
+        commit(Actions::Authorize.new(0, command_options.merge(options)).build)
+      end
+
+      def refund(cents, command_options = {})
+        commit(Actions::Refund.new(cents, command_options.merge(options)).build)
+      end
+
+      def purchase(cents, command_options = {})
+        commit(Actions::Purchase.new(cents, command_options.merge(options)).build)
+      end
+
+      def capture(cents, authorization, command_options = {})
+        commit(Actions::Capture.new(cents, authorization, command_options.merge(options)).build)
+      end
+
+      def void(authorization, command_options = {})
+        commit(Actions::Void.new(authorization, command_options.merge(options)).build)
+      end
+
+      def add_customer(command_options = {})
+        requires!(command_options, :customer_id)
+        commit_admin(AdminActions::AddCustomer.new(command_options.merge(options)).build)
+      end
+
+      def update_customer(command_options = {})
+        requires!(command_options, :customer_id)
+        commit_admin(AdminActions::UpdateCustomer.new(command_options.merge(options)).build)
+      end
+
+      def add_customer_and_contract(command_options = {})
+        requires!(command_options, :customer_id, :contract_id)
+        commit_admin(AdminActions::AddCustomerAndContract.new(command_options.merge(options)).build)
+      end
+
+      def add_contract(command_options = {})
+        requires!(command_options, :customer_id, :contract_id, :credit_card)
+        commit_admin(AdminActions::AddContract.new(command_options.merge(options)).build)
+      end
+
+      def update_contract(command_options = {})
+        requires!(command_options, :customer_id, :contract_id, :credit_card)
+        commit_admin(AdminActions::UpdateContract.new(command_options.merge(options)).build)
+      end
+
+      private
+
+        def commit_admin(request)
+          url = test? ? test_admin_url : live_admin_url
+          response = perform_api_call(request, url)
+
+          success = response["AdminResponse"]["Status_Code"] == "1"
+          message = response["AdminResponse"]["Message"]
+          params = response
+
+          ActiveMerchant::Billing::Response.new(
+            success,
+            message,
+            params,
+            test: test?
+          )
+        end
+
+        SUCCESS_CODES = ["APPROVED", "CAPTURED", "VOIDED", "VERIFIED"]
+
+        def commit(request)
+          url = test? ? test_url : live_url
+          response = perform_api_call(request, url)
+
+          success = SUCCESS_CODES.include?(response["RESPONSE"]["RESULT"])
+          message = response["RESPONSE"]["RESPONSE_TEXT"]
+          params = response
+
+          response_options = {
+            authorization: response["RESPONSE"]["AUTH_CODE"],
+            test: test?
+          }
+
+          if response["RESPONSE"]["AVS_CODE"].present?
+            response_options.merge!(avs_result: { code: response["RESPONSE"]["AVS_CODE"] })
+          end
+
+          if response["RESPONSE"]["CVV2_CODE"].present?
+            response_options.merge!(cvv_result: response["RESPONSE"]["CVV2_CODE"])
+          end
+
+          ActiveMerchant::Billing::Response.new(success, message, params, response_options)
+        end
+
+        def perform_api_call(request, url)
+          ::Rails.logger.debug(request) if ::Rails.env.development?
+
+          raw_response = ssl_post(url, request, "Content-Type" => "text/xml")
+
+          ::Rails.logger.debug(raw_response) if ::Rails.env.development?
+
+          raw_response.gsub!(/[\n\r]/, "")
+          Hash.from_xml(raw_response)
+        end
+    end
+  end
+end

data/lib/active_merchant/billing/payware_connect_gateway/actions/authorize.rb

@@ -0,0 +1,63 @@
+module ActiveMerchant
+  module Billing
+    class PaywareConnectGateway < ActiveMerchant::Billing::Gateway
+      module Actions
+        class Authorize < PaywareConnectGateway::XMLBuilder
+          attr_reader :cents
+
+          def initialize(cents, merged_options)
+            @cents = cents
+
+            super(merged_options)
+          end
+
+          def build
+            build_credit_request do |xml|
+              xml.COMMAND "PRE_AUTH"
+              xml.TRANS_AMOUNT "%.2f" % (cents.to_f / 100.0)
+              xml.PRESENT_FLAG "1"
+
+              if options[:invoice_number]
+                xml.INVOICE options[:invoice_number]
+              end
+
+              if options[:force]
+                xml.FORCE_FLAG "true"
+              end
+
+              if options[:billing_address]
+                address = options[:billing_address]
+                xml.CARDHOLDER "#{address.first_name} #{address.last_name}"
+                xml.CUSTOMER_STREET address.street[0..19] # max length of this field is 20 characters
+                xml.CUSTOMER_CITY address.city
+                xml.CUSTOMER_STATE address.region
+                xml.CUSTOMER_ZIP address.postal_code
+              end
+
+              if options[:customer_id] && options[:contract_id]
+                xml.RBCUSTOMER_ID options[:customer_id]
+                xml.RBCONTRACT_ID options[:contract_id]
+
+              elsif options[:credit_card]
+                credit_card = options[:credit_card]
+                xml.ACCT_NUM credit_card.number
+                xml.CVV2 credit_card.verification_value
+
+                month = credit_card.month
+                month = month.to_s.rjust(2, "0")
+                xml.EXP_MONTH month
+                xml.EXP_YEAR credit_card.year.to_s[-2, 2] # last two digits of year
+
+              elsif options[:troutd]
+                xml.REF_TROUTD options[:troutd]
+
+              else
+                raise "Authorize requires either 1) customer and contract ids, 2) credit card, 3) troutd from previous authorization"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end