vantiv 0.3.0 → 1.0.0

data/lib/vantiv/api/account_updater_response.rb

@@ -1,51 +1,46 @@
+require "forwardable"
+
 module Vantiv
   module Api
-    class AccountUpdaterResponse
-      def initialize(account_updater)
-        @account_updater_response = account_updater
-      end
+    class CardTokenInfo
+      attr_accessor :payment_account_id, :card_type, :expiry_month, :expiry_year, :bin
 
-      def payment_account_id
-        new_card_token_info["PaymentAccountID"]
+      def expiry_date=(string)
+        @expiry_month = string[0..1]
+        @expiry_year = string[2..3]
       end
+    end
 
-      def card_type
-        new_card_token_info["Type"]
-      end
+    class ExtendedCardResponse
+      attr_accessor :code, :message
+    end
 
-      def expiry_month
-        new_card_token_info["ExpirationMonth"]
-      end
+    class AccountUpdaterResponse
+      extend Forwardable
 
-      def expiry_year
-        new_card_token_info["ExpirationYear"]
+      attr_accessor :original_card_token_info, :new_card_token_info, :extended_card_response
+
+      def initialize
+        @new_card_token_info = CardTokenInfo.new
+        @extended_card_response = ExtendedCardResponse.new
       end
 
+      def_delegators :new_card_token_info, :payment_account_id, :card_type, :expiry_month, :expiry_year
+
       def extended_card_response_code
-        extended_card_response["code"]
+        extended_card_response.code
       end
 
       def extended_card_response_message
-        extended_card_response["message"]
+        extended_card_response.message
       end
 
       def new_card_token?
-        new_card_token_info.any?
+        !!payment_account_id
       end
 
       def extended_card_response?
-        extended_card_response.any?
-      end
-
-      private
-      attr_reader :account_updater_response
-
-      def new_card_token_info
-        account_updater_response.fetch("newCardTokenInfo", {})
-      end
-
-      def extended_card_response
-        account_updater_response.fetch("extendedCardResponse", {})
+        !!extended_card_response_code || !!extended_card_response_message
       end
     end
   end

data/lib/vantiv/api/address.rb

@@ -0,0 +1,8 @@
+module Vantiv
+  module Api
+    class Address
+      attr_accessor :billing_name, :billing_address_1, :billing_address_2,
+                    :billing_city, :billing_state, :billing_zipcode, :billing_country
+    end
+  end
+end

data/lib/vantiv/api/apple_pay_response.rb

@@ -0,0 +1,9 @@
+module Vantiv
+  module Api
+    class ApplePayResponse
+      attr_accessor :online_payment_cryptogram
+      # if online_payment_cryptogram is present you must pass
+      # it in the next auth or sale transaction
+    end
+  end
+end

data/lib/vantiv/api/capture_response.rb

@@ -19,7 +19,7 @@ module Vantiv
       private
 
       def transaction_response_name
-        "captureResponse"
+        "capture_response"
       end
     end
   end

data/lib/vantiv/api/card.rb

@@ -0,0 +1,47 @@
+module Vantiv
+  module Api
+    class Card
+      attr_writer :cvv, :card_number, :account_number
+      attr_accessor :expiry_month, :expiry_year, :type, :paypage_registration_id, :payment_account_id
+
+      def initialize(expiry_month: nil, expiry_year: nil, cvv: nil, card_number: nil, account_number: nil, paypage_registration_id: nil)
+        @expiry_month = expiry_month
+        @expiry_year = expiry_year
+        @cvv = cvv
+        @card_number = card_number
+        @account_number = account_number
+        @paypage_registration_id = paypage_registration_id
+      end
+
+      def expiry_month
+        format_expiry(@expiry_month) if @expiry_month
+      end
+
+      def expiry_year
+        format_expiry(@expiry_year) if @expiry_year
+      end
+
+      def card_number
+        format_card_number(@card_number) if @card_number
+      end
+
+      def account_number
+        format_card_number(@account_number) if @account_number
+      end
+
+      def cvv
+        @cvv.to_s if @cvv
+      end
+
+      private
+
+      def format_expiry(raw_value)
+        raw_value.to_s.reverse[0..1].reverse.rjust(2, "0")
+      end
+
+      def format_card_number(card_number)
+        card_number.to_s.gsub(/\D*/, "") if card_number
+      end
+    end
+  end
+end

data/lib/vantiv/api/cardholder_authentication.rb

@@ -0,0 +1,11 @@
+module Vantiv
+  module Api
+    class CardholderAuthentication
+      attr_accessor :authentication_value
+
+      def initialize(authentication_value:)
+        @authentication_value = authentication_value
+      end
+    end
+  end
+end

data/lib/vantiv/api/fraud_result.rb

@@ -0,0 +1,7 @@
+module Vantiv
+  module Api
+    class FraudResult
+      attr_accessor :avs_result, :card_validation_result
+    end
+  end
+end

data/lib/vantiv/api/live_transaction_response.rb

@@ -12,8 +12,8 @@ module Vantiv
       }.freeze
 
       LIVE_TRANSACTION_RESPONSE_NAMES = {
-        auth: "authorizationResponse",
-        sale: "saleResponse"
+        auth: "authorization_response",
+        sale: "sale_response"
       }
 
       def initialize(transaction_name)
@@ -43,9 +43,8 @@ module Vantiv
       end
 
       def account_updater
-        @account_updater ||= AccountUpdaterResponse.new(
-          litle_transaction_response.fetch("accountUpdater", {})
-        )
+        @account_updater ||=
+          litle_transaction_response.account_updater || AccountUpdaterResponse.new
       end
 
       private

data/lib/vantiv/api/payment_account.rb

@@ -0,0 +1,11 @@
+module Vantiv
+  module Api
+    class PaymentAccount
+      attr_accessor :id
+
+      def initialize(id: nil)
+        @id = id
+      end
+    end
+  end
+end

data/lib/vantiv/api/request.rb

@@ -1,74 +1,113 @@
 module Vantiv
   class Api::Request
-
     attr_reader :body
 
+    ENDPOINT_XML_TRANSACTION_TYPE = {
+      :"payment/sp2/credit/v1/authorization" => :authorization,
+      :"payment/sp2/credit/v1/authorizationCompletion" => :capture,
+      :"payment/sp2/credit/v1/reversal" => :authReversal,
+      :"payment/sp2/credit/v1/sale" => :sale,
+      :"payment/sp2/credit/v1/credit" => :credit,
+      :"payment/sp2/credit/v1/return" => :credit,
+      :"payment/sp2/services/v1/paymentAccountCreate" => :registerTokenRequest,
+      :"payment/sp2/credit/v1/void" => :void
+    }.freeze
+
     def initialize(endpoint:, body:, response_object:)
       @endpoint = endpoint
-      @body = body.to_json
       @response_object = response_object
-      self.retry_count = 0
+      @retry_count = 0
+
+      @body = populated_request_body(body)
     end
 
     def run
-      vantiv_response = run_request_with_retries
-      response_object.load(vantiv_response)
-      response_object
+      run_request_with_retries
     end
 
     def run_request
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = true
-
-      request = Net::HTTP::Post.new(uri.request_uri, header)
-      request.body = body
-      raw_response = http.request(request)
-      parsed_body = JSON.parse(raw_response.body)
-      {
-        httpok: raw_response.code_type == Net::HTTPOK,
-        http_response_code: raw_response.code,
-        body: parsed_body
-      }
+      http_response = make_request
+      populated_response(@response_object, http_response)
     end
 
     private
 
-    attr_reader :endpoint, :response_object
-    attr_accessor :retry_count
+    def populated_request_body(body)
+      populated_body = body.dup
+
+      if populated_body.card && populated_body.payment_account
+        populated_body.card.payment_account_id = populated_body.payment_account.id
+      end
+
+      populated_body.transaction ||= Vantiv::Api::Transaction.new
+      populated_body.transaction.type = ENDPOINT_XML_TRANSACTION_TYPE.fetch(@endpoint.to_sym)
+      populated_body.transaction.address = populated_body.address
+      populated_body.transaction.card = populated_body.card if populated_body.card
+      populated_body.transaction.report_group = populated_body.report_group
+      populated_body.transaction.application_id = populated_body.application_id
+
+      populated_body.xmlns = "http://www.litle.com/schema"
+      populated_body.version = "10.2"
+
+      populated_body
+    end
+
+    def make_request
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      request = Net::HTTP::Post.new(uri.request_uri, header)
+      request.body = body.to_xml
+      http.request(request)
+    end
 
     def header
       {
-        "Content-Type" =>"application/json",
-        "Authorization" => "VANTIV license=\"#{Vantiv.license_id}\""
+        "Content-Type" =>"text/xml"
       }
     end
 
     def uri
-      @uri ||= URI.parse("#{root_uri}/#{endpoint}")
+      @uri ||= URI.parse("#{root_uri}/vap/communicator/online")
     end
 
     def root_uri
       if Vantiv::Environment.production?
-        "https://apis.vantiv.com"
+        "https://transact.litle.com"
       elsif Vantiv::Environment.certification?
-        "https://apis.cert.vantiv.com"
+        "https://transact-prelive.litle.com"
       end
     end
 
+    def populated_response(response, http_response)
+      new_response = response.dup
+
+      new_response.raw_body = http_response.body
+      new_response.httpok = http_response.code_type == Net::HTTPOK
+      new_response.http_response_code = http_response.code
+
+      response_body = ResponseBodyRepresenterXml.new(
+        Vantiv::Api::ResponseBody.new
+      ).from_xml(http_response.body)
+
+      new_response.body = response_body
+
+      new_response
+    end
+
+    def increment_retry_count
+      @retry_count += 1
+    end
+
     def max_retries_exceeded?
-      retry_count > 3
+      @retry_count > 3
     end
 
     def run_request_with_retries
       begin
         run_request
-      rescue JSON::ParserError => e
-        self.retry_count += 1
-        if max_retries_exceeded?
-          raise e
-        else
-          run_request_with_retries
-        end
+      rescue MultiJson::ParseError, Nokogiri::XML::SyntaxError => e
+        increment_retry_count
+        max_retries_exceeded? ? raise(e) : retry
       end
     end
   end

data/lib/vantiv/api/request_body.rb

@@ -1,131 +1,134 @@
+require 'securerandom'
+
 module Vantiv
   module Api
-    module RequestBody
-      def self.for_auth_or_sale(amount:, customer_id:, order_id:, payment_account_id:, expiry_month:, expiry_year:)
-        RequestBodyGenerator.run(
-          transaction_element(
-            amount: amount,
-            order_id: order_id,
-            customer_id: customer_id
-          ),
-          card_element_for_live_transactions(
-            expiry_month: expiry_month,
-            expiry_year: expiry_year
-          ),
-          payment_account_element(payment_account_id: payment_account_id)
-        )
+    class Authentication
+      attr_accessor :user, :password
+      def user
+        Vantiv.user
+      end
+      def password
+        Vantiv.password
       end
+    end
 
-      def self.for_auth_reversal(transaction_id:, amount: nil)
-        RequestBodyGenerator.run(
-          tied_transaction_element(transaction_id: transaction_id, amount: amount)
-        )
+    class RequestBody
+      attr_reader :merchant_id, :application_id, :report_group
+      attr_accessor :card, :transaction, :payment_account, :address
+
+      attr_accessor :version, :authentication, :xmlns
+
+      def initialize(card: nil, transaction: nil, payment_account: nil)
+        @card = card
+        @transaction = transaction
+        @payment_account = payment_account
+
+        @merchant_id = Vantiv.merchant_id
+        @application_id = SecureRandom.hex(12)
+        @report_group = Vantiv.default_report_group
+
+        @authentication = Authentication.new
       end
 
-      def self.for_capture(transaction_id:, amount: nil)
-        RequestBodyGenerator.run(
-          tied_transaction_element(transaction_id: transaction_id, amount: amount)
-        )
+      def to_json
+        ::RequestBodyRepresenter.new(self).to_json
       end
 
-      def self.for_credit(transaction_id:, amount: nil)
-        RequestBodyGenerator.run(
-          tied_transaction_element(transaction_id: transaction_id, amount: amount)
-        )
+      def to_xml
+        ::RequestBodyRepresenterXml.new(self).to_xml
       end
 
-      def self.for_return(amount:, customer_id:, order_id:, payment_account_id:, expiry_month:, expiry_year:)
-        transaction = transaction_element(
-          amount: amount,
+      def self.for_auth_or_sale(amount:, customer_id:, order_id:, payment_account_id:,
+          expiry_month:, expiry_year:, cvv: nil, order_source: Vantiv.default_order_source,
+          online_payment_cryptogram: nil)
+
+
+        if online_payment_cryptogram
+          cardholder_authentication = CardholderAuthentication.new(
+            authentication_value: online_payment_cryptogram
+          )
+        else
+          cardholder_authentication = nil
+        end
+
+        transaction = Transaction.new(
           order_id: order_id,
-          customer_id: customer_id
+          amount_in_cents: amount,
+          customer_id: customer_id,
+          order_source: order_source,
+          partial_approved_flag: false,
+          cardholder_authentication: cardholder_authentication
         )
-        transaction["Transaction"].delete("PartialApprovedFlag")
-        RequestBodyGenerator.run(
-          transaction,
-          card_element_for_live_transactions(
-            expiry_month: expiry_month,
-            expiry_year: expiry_year
-          ),
-          payment_account_element(payment_account_id: payment_account_id)
+        card = Card.new(
+          expiry_month: expiry_month,
+          expiry_year: expiry_year,
+          cvv: cvv
         )
-      end
+        payment_account = PaymentAccount.new(id: payment_account_id)
 
-      def self.for_tokenization(paypage_registration_id:)
-        RequestBodyGenerator.run(
-          card_element_for_tokenization(paypage_registration_id)
+        new(
+          transaction: transaction,
+          card: card,
+          payment_account: payment_account
         )
       end
 
-      def self.for_direct_post_tokenization(card_number:, expiry_month:, expiry_year:, cvv:)
-        RequestBodyGenerator.run(
-          {
-            "Card" => {
-              "AccountNumber" => card_number.to_s.gsub(/\D*/, ""),
-              "ExpirationMonth" => format_expiry(expiry_month),
-              "ExpirationYear" => format_expiry(expiry_year),
-              "CVV" => cvv.to_s
-            }
-          }
-        )
+      def self.for_auth_reversal(transaction_id:, amount: nil)
+        transaction = Transaction.new(id: transaction_id, amount_in_cents: amount)
+        new(transaction: transaction)
       end
 
-      def self.for_void(transaction_id:)
-        RequestBodyGenerator.run(tied_transaction_element(transaction_id: transaction_id))
+      def self.for_capture(transaction_id:, amount: nil)
+        transaction = Transaction.new(id: transaction_id, amount_in_cents: amount)
+        new(transaction: transaction)
       end
 
-      def self.card_element_for_tokenization(paypage_registration_id)
-        {
-          "Card" => {
-            "PaypageRegistrationID" => paypage_registration_id
-          }
-        }
+      def self.for_credit(transaction_id:, amount: nil)
+        transaction = Transaction.new(id: transaction_id, amount_in_cents: amount)
+        new(transaction: transaction)
       end
 
-      def self.card_element_for_live_transactions(expiry_month:, expiry_year:)
-        {
-          "Card" => {
-            "ExpirationMonth" => format_expiry(expiry_month),
-            "ExpirationYear" => format_expiry(expiry_year)
-          }
-        }
-      end
+      def self.for_return(amount:, customer_id:, order_id:, payment_account_id:,
+          expiry_month:, expiry_year:, order_source: Vantiv.default_order_source)
+        transaction = Transaction.new(
+          order_id: order_id,
+          amount_in_cents: amount,
+          order_source: order_source,
+          customer_id: customer_id
+        )
+        card = Card.new(
+          expiry_month: expiry_month,
+          expiry_year: expiry_year
+        )
+        payment_account = PaymentAccount.new(id: payment_account_id)
 
-      def self.tied_transaction_element(transaction_id:, amount: nil)
-        res = {
-          "Transaction" => {
-            "TransactionID" => transaction_id
-          }
-        }
-        if amount
-          res["Transaction"]["TransactionAmount"] = '%.2f' % (amount / 100.0)
-        end
-        res
+        new(
+          transaction: transaction,
+          card: card,
+          payment_account: payment_account
+        )
       end
 
-      def self.transaction_element(amount:, customer_id:, order_id:)
-        {
-          "Transaction" => {
-            "ReferenceNumber" => order_id.to_s,
-            "TransactionAmount" => '%.2f' % (amount / 100.0),
-            "OrderSource" => Vantiv.order_source,
-            "CustomerID" => customer_id,
-            "PartialApprovedFlag" => false
-          }
-        }
+      def self.for_tokenization(paypage_registration_id:)
+        card = Card.new(paypage_registration_id: paypage_registration_id)
+        new(card: card)
       end
 
-      def self.payment_account_element(payment_account_id:)
-        {
-          "PaymentAccount" => {
-            "PaymentAccountID" => payment_account_id
-          }
-        }
+      def self.for_direct_post_tokenization(card_number:, expiry_month:, expiry_year:, cvv:)
+        card = Card.new(
+          account_number: card_number,
+          expiry_month: expiry_month,
+          expiry_year: expiry_year,
+          cvv: cvv
+        )
+        new(card: card)
       end
 
-      def self.format_expiry(raw_value)
-        raw_value.to_s.reverse[0..1].reverse.rjust(2, "0")
+      def self.for_void(transaction_id:)
+        transaction = Transaction.new(id: transaction_id)
+        new(transaction: transaction)
       end
+
     end
   end
 end