vantiv 0.1.0

data/lib/vantiv/api/request.rb

@@ -0,0 +1,75 @@
+module Vantiv
+  class Api::Request
+
+    attr_reader :body
+
+    def initialize(endpoint:, body:, response_object:)
+      @endpoint = endpoint
+      @body = body.to_json
+      @response_object = response_object
+      self.retry_count = 0
+    end
+
+    def run
+      vantiv_response = run_request_with_retries
+      response_object.load(vantiv_response)
+      response_object
+    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
+      }
+    end
+
+    private
+
+    attr_reader :endpoint, :response_object
+    attr_accessor :retry_count
+
+    def header
+      {
+        "Content-Type" =>"application/json",
+        "Authorization" => "VANTIV license=\"#{Vantiv.license_id}\""
+      }
+    end
+
+    def uri
+      @uri ||= URI.parse("#{root_uri}/#{endpoint}")
+    end
+
+    def root_uri
+      if Vantiv::Environment.production?
+        "https://apis.vantiv.com"
+      elsif Vantiv::Environment.certification?
+        "https://apis.cert.vantiv.com"
+      end
+    end
+
+    def max_retries_exceeded?
+      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
+      end
+    end
+  end
+end

data/lib/vantiv/api/request_body.rb

@@ -0,0 +1,111 @@
+module Vantiv
+  module Api
+    module RequestBody
+      def self.for_auth_or_sale(amount:, customer_id:, order_id:, payment_account_id:)
+        RequestBodyGenerator.run(
+          transaction_element(
+            amount: amount,
+            order_id: order_id,
+            customer_id: customer_id
+          ),
+          payment_account_element(payment_account_id: payment_account_id)
+        )
+      end
+
+      def self.for_auth_reversal(transaction_id:, amount: nil)
+        RequestBodyGenerator.run(
+          tied_transaction_element(transaction_id: transaction_id, amount: amount)
+        )
+      end
+
+      def self.for_capture(transaction_id:, amount: nil)
+        RequestBodyGenerator.run(
+          tied_transaction_element(transaction_id: transaction_id, amount: amount)
+        )
+      end
+
+      def self.for_credit(transaction_id:, amount: nil)
+        RequestBodyGenerator.run(
+          tied_transaction_element(transaction_id: transaction_id, amount: amount)
+        )
+      end
+
+      def self.for_return(amount:, customer_id:, order_id:, payment_account_id:)
+        transaction = transaction_element(
+          amount: amount,
+          order_id: order_id,
+          customer_id: customer_id
+        )
+        transaction["Transaction"].delete("PartialApprovedFlag")
+        RequestBodyGenerator.run(
+          transaction,
+          payment_account_element(payment_account_id: payment_account_id)
+        )
+      end
+
+      def self.for_tokenization(paypage_registration_id:)
+        RequestBodyGenerator.run(
+          card_element_for_tokenization(paypage_registration_id)
+        )
+      end
+
+      def self.for_direct_post_tokenization(card_number:, expiry_month:, expiry_year:, cvv:)
+        RequestBodyGenerator.run(
+          {
+            "Card" => {
+              "AccountNumber" => card_number,
+              "ExpirationMonth" => expiry_month,
+              "ExpirationYear" => expiry_year,
+              "CVV" => cvv
+            }
+          }
+        )
+      end
+
+      def self.for_void(transaction_id:)
+        RequestBodyGenerator.run(tied_transaction_element(transaction_id: transaction_id))
+      end
+
+      def self.card_element_for_tokenization(paypage_registration_id)
+        {
+          "Card" => {
+            "PaypageRegistrationID" => paypage_registration_id
+          }
+        }
+      end
+
+      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
+      end
+
+      def self.transaction_element(amount:, customer_id:, order_id:)
+        {
+          "Transaction" => {
+            "ReferenceNumber" => order_id,
+            "TransactionAmount" => '%.2f' % (amount / 100.0),
+            "OrderSource" => Vantiv.order_source,
+            "CustomerID" => customer_id,
+            "PartialApprovedFlag" => false
+          }
+        }
+      end
+
+      def self.payment_account_element(payment_account_id:)
+        {
+          "PaymentAccount" => {
+            "PaymentAccountID" => payment_account_id
+          }
+        }
+      end
+    end
+
+  end
+end

data/lib/vantiv/api/request_body_generator.rb

@@ -0,0 +1,43 @@
+require 'securerandom'
+
+module Vantiv
+  module Api
+    class RequestBodyGenerator
+      def self.run(*args)
+        new(*args).run
+      end
+
+      def initialize(*args)
+        @body_parts = args
+      end
+
+      def run
+        body = request_body_base
+        body_parts.each do |body_part|
+          body.merge!(body_part)
+        end
+        body
+      end
+
+      private
+
+      attr_accessor :body_parts
+
+      def request_body_base
+        {
+          "Credentials" => {
+            "AcceptorID" => Vantiv.acceptor_id
+          },
+          "Reports" => {
+            # NOTE: this is required by vantiv, so a default is left here.
+            #       If a user wants to use this Vantiv feature, it can be made dynamic.
+            "ReportGroup" => Vantiv.default_report_group
+          },
+          "Application" => {
+            "ApplicationID" => SecureRandom.hex(12)
+          }
+        }
+      end
+    end
+  end
+end

data/lib/vantiv/api/response.rb

@@ -0,0 +1,50 @@
+module Vantiv
+  module Api
+    class Response
+      attr_reader :httpok, :http_response_code, :body
+
+      def load(httpok:, http_response_code:, body:)
+        @httpok = httpok
+        @http_response_code = http_response_code
+        @body = body
+      end
+
+      # Only returned by cert API?
+      def request_id
+        body["RequestID"]
+      end
+
+      def api_level_failure?
+        !httpok ||
+          # NOTE: this kind of sucks, but at the commit point, the DevHub
+          #   Api sometimes gives 200OK when litle had a parse issue and returns
+          #   'Error validating xml data...' instead of an actual error
+          @body["litleOnlineResponse"]["@message"].match(/error/i)
+      end
+
+      def message
+        litle_transaction_response["message"]
+      end
+
+      def response_code
+        litle_transaction_response["response"]
+      end
+
+      def transaction_id
+        litle_transaction_response["TransactionID"]
+      end
+
+      private
+
+      attr_reader :transaction_response_name
+
+      def litle_response
+        api_level_failure? ? {} : body["litleOnlineResponse"]
+      end
+
+      def litle_transaction_response
+        api_level_failure? ? {} : litle_response[transaction_response_name]
+      end
+    end
+  end
+end

data/lib/vantiv/api/tied_transaction_response.rb

@@ -0,0 +1,30 @@
+module Vantiv
+  module Api
+    class TiedTransactionResponse < Api::Response
+      RESPONSE_CODES = {
+        transaction_received: '001'
+      }
+      TIED_TRANSACTION_RESPONSE_NAMES = {
+        auth_reversal: 'authReversalResponse',
+        capture: "captureResponse",
+        credit: "creditResponse",
+        return: "creditResponse",
+        void: "voidResponse"
+      }
+
+      def initialize(transaction_name)
+        unless @transaction_response_name = TIED_TRANSACTION_RESPONSE_NAMES[transaction_name]
+          raise "Implementation Error: Tied transactions do not include #{transaction_name}"
+        end
+      end
+
+      def success?
+        !api_level_failure? && response_code == RESPONSE_CODES[:transaction_received]
+      end
+
+      def failure?
+        !success?
+      end
+    end
+  end
+end

data/lib/vantiv/api/tokenization_response.rb

@@ -0,0 +1,45 @@
+module Vantiv
+  module Api
+    class TokenizationResponse < Api::Response
+      RESPONSE_CODES = {
+        account_successfully_registered: "801",
+        account_already_registered: "802",
+        credit_card_number_invalid: "820",
+        merchant_not_authorized_for_tokens: "821",
+        token_not_found: "822",
+        token_invalid: "823",
+        invalid_paypage_registration_id: "877",
+        expired_paypage_registration_id: "878",
+        generic_token_registration_error: "898",
+        generic_token_use_error: "899"
+      }
+
+      def success?
+        !api_level_failure? && tokenization_successful?
+      end
+
+      def failure?
+        !success?
+      end
+
+      def payment_account_id
+        success? ? litle_transaction_response["PaymentAccountID"] : nil
+      end
+
+      def invalid_card_number?
+        response_code == RESPONSE_CODES[:credit_card_number_invalid]
+      end
+
+      private
+
+      def tokenization_successful?
+        response_code == RESPONSE_CODES[:account_successfully_registered] ||
+          response_code == RESPONSE_CODES[:account_already_registered]
+      end
+
+      def transaction_response_name
+        "registerTokenResponse"
+      end
+    end
+  end
+end

data/lib/vantiv/certification/cert_request_body_compiler.rb

@@ -0,0 +1,38 @@
+module Vantiv
+  module Certification
+    class CertRequestBodyCompiler
+      attr_accessor :matchers
+
+      def initialize(*matchers)
+        @matchers = matchers
+      end
+
+      def compile(hash)
+        dup = {}
+        hash.each do |key, value|
+          if value.is_a?(Hash)
+            dup[key] = compile(value)
+          else
+            dup[key] = compile_value(value)
+          end
+        end
+        dup
+      end
+
+      private
+
+      def compile_value(value)
+        matchers.each do |matcher|
+          if matches = matcher[:regex].match(value)
+            matches = matches.to_a
+            matches.shift
+            matches.each do |match|
+              value = matcher[:fetcher].call(value, match)
+            end
+          end
+        end
+        value
+      end
+    end
+  end
+end

data/lib/vantiv/certification/paypage_driver.rb

@@ -0,0 +1,54 @@
+require "vantiv/certification/paypage_server"
+require "selenium-webdriver"
+
+module Vantiv
+  module Certification
+    class PaypageDriver
+
+      def start
+        paypage_server.start
+        start_driver
+        self
+      end
+
+      def stop
+        paypage_server.stop
+        driver.quit
+      end
+
+      def get_paypage_registration_id(card_number, cvv = '123')
+        driver.navigate.to paypage_server.root_path
+
+        driver.switch_to.frame('vantiv-payframe')
+        driver.find_element(:id, 'accountNumber').send_keys card_number
+        driver.find_element(:id, 'cvv').send_keys cvv
+
+        driver.switch_to.default_content
+        button = driver.find_element(:id, 'submit')
+        button.click
+
+        wait = Selenium::WebDriver::Wait.new(:timeout => 10)
+        wait.until {
+          driver.find_element(:id, "request-status").text.include?("Request Complete")
+        }
+
+        driver.find_element(:id, 'temp-token').text
+      end
+
+      private
+
+      def start_driver
+        driver.manage.timeouts.implicit_wait = 10
+      end
+
+      def driver
+        @driver ||= Selenium::WebDriver.for :phantomjs
+      end
+
+      def paypage_server
+        @paypage_server ||= Vantiv::Certification::PaypageServer.new
+      end
+
+    end
+  end
+end