paycertify 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 40f7fc2a6ff69e2391ef10a9d2f2339c233790ea
-  data.tar.gz: 95161a2a11a02aa3c7b9a780c2d32b5f19aac3f7
+  metadata.gz: 4853d8c8ab842f2530d63b7c7880e51b0131c6cb
+  data.tar.gz: 65aa6d612b3c3c7154595a7d59cb5f31278f4fb9
 SHA512:
-  metadata.gz: 00a5764ed1ede47fec3395647cb80f1a2f561e9864311de6abdc97c4771e9a2c619a8fbaaacfde9e60d627505f99383a6f9700958717e0ddae8c6d52e3265e9b
-  data.tar.gz: f35887568dd908a566f90c7474ff79e671832e1d13c44b089c3c0ed7742ddbdad2a1744a9a4907ded979956cfa1d62d6565f578fbc0440d3ff8e77bf50350e6e
+  metadata.gz: accec71a0359c602880883d965b315fd65f2bb9189719ad9003e33145f3ec079c78983e6d864f6ead27f453edb42dfb4ef34c998ca416093601f3e44b7a1241e
+  data.tar.gz: df636c0cd6d851677d7fc2e4428be57c5b9b426c2ad1de1f86122daf6756fd9368628b3f890ca1ae4dcd6be22aa63316e0fa3a77a5976cc360e6f985bb6618dd

data/lib/paycertify.rb

@@ -3,5 +3,7 @@ require 'active_support/core_ext'
 
 require 'paycertify/three_ds'
 require 'paycertify/gateway'
+require 'paycertify/confirmation'
+require 'paycertify/insurance'
 
 module PayCertify; end

data/lib/paycertify/confirmation.rb

@@ -0,0 +1,94 @@
+module PayCertify
+  class Confirmation
+
+    class NoCredentialsError < StandardError; end
+    
+    API_ENDPOINT = 'https://www.paycertify.com/'
+    
+    MANDATORY_FIELDS = [
+      :transaction_id, :cc_last_four_digits, :name, :email, 
+      :phone, :amount, :currency, :payment_gateway
+    ]
+    
+    OPTIONAL_FIELDS = [
+      :status, :transaction_date, :order_description, :card_type, :name_on_card, 
+      :address, :city, :zip, :state, :country, :confirmation_type, :fraud_score_processing, :scheduled_messages, 
+      :thank_you_page_url, :metadata
+    ]
+
+    attr_accessor :attributes, :errors, :response
+
+    delegate :api_key, to: :class
+
+    def initialize(attributes)
+      raise NoCredentialsError, 'No api key provided.' unless api_key.present?
+
+      self.attributes = HashWithIndifferentAccess.new(attributes)
+      self.errors = {}
+
+      validate!
+    end
+
+    def success?
+      response.success?
+    end
+
+    def start!
+      data = attributes.slice *[MANDATORY_FIELDS + OPTIONAL_FIELDS].flatten
+
+      api_response = connection.post do |request|
+        request.url path_for('merchant/transactions')
+        request.headers['Content-Type'] = 'application/json'
+        request.headers['PAYCERTIFYKEY'] = api_key
+        request.body = JSON.generate(data)
+      end
+
+      self.response = Response.new(api_response)
+      self.errors = errors.merge(response) unless response.success?
+
+      response
+    end
+
+    class << self
+      attr_accessor :api_key
+
+      def configure(&block)
+        yield self if block_given?
+      end
+    end
+
+    class Response < HashWithIndifferentAccess
+      attr_accessor :original_response
+
+      def initialize(response)
+        self.original_response = response
+        super JSON.parse(response.body)
+      end
+
+      def success?
+        original_response.status < 400
+      end
+    end
+
+    private
+      def validate!
+        MANDATORY_FIELDS.each do |field|
+          unless attributes[field].present?
+            self.errors[field] = "Required attribute not present"
+          end
+        end
+      end
+
+      def connection
+        @connection ||= Faraday.new(url: API_ENDPOINT, ssl: {verify: false}) do |faraday|
+          faraday.request :url_encoded
+          faraday.response :logger
+          faraday.adapter  Faraday.default_adapter
+        end
+      end
+
+      def path_for(path)
+        return "api/v1/" + path
+      end
+  end
+end

data/lib/paycertify/gateway.rb

@@ -1,34 +1,34 @@
 require_relative './gateway/attribute_mapping'
+require_relative './gateway/base'
+require_relative './gateway/charge'
 require_relative './gateway/client'
+require_relative './gateway/credit_card'
+require_relative './gateway/customer'
 require_relative './gateway/response'
 require_relative './gateway/transaction'
-require_relative './gateway/validation'
 
 require 'json'
 
 module PayCertify
   class Gateway
-
-    attr_accessor :client, :attributes
-
-    delegate :api_key, :mode, to: :class
-
-    def initialize(attributes)
-      self.attributes = attributes
-      self.client = PayCertify::Gateway::Client.new(api_key: api_key, mode: mode)
-    end
-
-
-    def process_transaction!
-      transaction = PayCertify::Gateway::Transaction.new(client, attributes)
-      transaction.process
-    end
+    CREDENTIALS_PATH = '/ws/encgateway2.asmx/GetCredential'
 
     class << self
-      cattr_accessor :api_key, :mode
+      attr_accessor :api_key, :mode, :vendor
 
       def configure(&block)
         yield self if block_given?
+
+        client = PayCertify::Gateway::Client.new(api_key: api_key, mode: mode)
+        response = client.get(path: CREDENTIALS_PATH)
+        
+        self.vendor = response['response']['vendor']
+
+        return {
+          api_key: api_key,
+          mode: mode,
+          vendor: vendor
+        }
       end
     end
   end

data/lib/paycertify/gateway/attribute_mapping.rb

@@ -2,7 +2,7 @@ module PayCertify
   class Gateway
     module AttributeMapping
       module_function
-        def wrapper_to_gateway
+        def transaction
           {
             'Amount' => :amount,
             'Currency' => :currency,
@@ -25,8 +25,40 @@ module PayCertify
             'Email' => :email,
             'Description' => :order_description,
             'CustomerID' => :customer_id,
-            'ServerID' => :ip,
-            'ExtData' => :metadata
+            'ServerID' => :ip
+          }
+        end
+
+        def customer
+          {
+            'CustomerID' => :app_customer_id,
+            'CustomerKey' => :customer_id,
+            'CustomerName' => :name,
+            'Street1' => :address,
+            'City' => :city,
+            'StateID' => :state,
+            'Zip' => :zip,
+            'MobilePhone' => :phone,
+            'Fax' => :fax,
+            'Email' => :email,
+            'Status' => :status
+          }
+        end
+
+        def credit_card
+          {
+            'CardNum' => :card_number,
+            'NameOnCard' => :name_on_card,
+            'CustomerKey' => :customer_id,
+            'PostalCode' => :zip
+          }
+        end
+
+        def charge
+          {
+            'CardToken' => :credit_card_id,
+            'Amount' => :amount,
+            'PNRef' => :transaction_id
           }
         end
 
@@ -34,9 +66,20 @@ module PayCertify
           { 'ExpDate' => [transaction.expiration_month, transaction.expiration_year].join }
         end
 
-        def transaction_type(transaction)
-          { 'TransType' => transaction.type.to_s.capitalize }
+        def type(object)
+          case object.class.name
+          when /.*Transaction.*/, /.*Charge.*/
+            { 'TransType' => object.type.to_s.capitalize }
+          when /.*Customer.*/
+            { 'TransType' => object.type.to_s.upcase }
+          else
+            {}
+          end
+        end
+
+        def status(customer)
+          object.status.to_s.upcase
         end
     end
   end
-end
+end

data/lib/paycertify/gateway/base.rb

@@ -0,0 +1,8 @@
+require_relative './base/resource'
+require_relative './base/validation'
+
+module PayCertify
+  class Gateway
+    module Base; end
+  end
+end

data/lib/paycertify/gateway/base/resource.rb

@@ -0,0 +1,87 @@
+module PayCertify
+  class Gateway
+    module Base
+      class Resource
+        attr_accessor :client, :original_attributes, :response, :errors
+
+        delegate :api_key, :mode, to: PayCertify::Gateway
+
+        def initialize(attributes)
+          self.original_attributes = attributes
+          self.client = PayCertify::Gateway::Client.new(api_key: api_key, mode: mode)
+
+          if validatable?
+            # Validate + attribute assignment
+            validation.attributes.each do |key, value|
+              self.send("#{key}=", value)
+            end
+
+            self.errors = validation.errors
+          else
+            # Attribute assignment only
+            self.class.const_get('ATTRIBUTES').each do |key|
+              self.send("#{key}=", attributes[key])
+            end
+          end
+        end
+
+        def success?
+          errors.empty?
+        end
+
+        def validatable?
+          self.class.const_get('Validation')
+          true
+        rescue NameError
+          false
+        end
+
+        def validation
+          @validation ||= self.class.const_get('Validation').new(original_attributes)
+        end
+
+        def attributes
+          {}.tap do |attributes|
+            self.class.const_get('ATTRIBUTES').each do |attribute|
+              value = self.send(attribute)
+              attributes[attribute] = value if value.present?
+            end
+
+            if response.present?
+              attributes['gateway_response'] = response
+            end
+
+            attributes
+          end
+        end
+
+        def to_json
+          JSON.generate(attributes)
+        end
+
+        def save!
+          self.response = client.post(
+            path: self.class.const_get('API_ENDPOINT'),
+            data: attributes_to_gateway_format
+          )
+        end
+
+        def attributes_to_gateway_format
+          {}.tap do |formatted|
+            attribute_mapping = PayCertify::Gateway::AttributeMapping
+            mapping_name = self.class.name.underscore.split('/').last
+
+            attribute_mapping.send(mapping_name).each do |key, value|
+              [value].flatten.tap do |method_chain|
+                new_value = method_chain.map { |method_name| self.send(method_name) }.join
+                formatted[key] = new_value
+              end
+            end
+
+            formatted
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paycertify/gateway/base/validation.rb

@@ -0,0 +1,105 @@
+module PayCertify
+  class Gateway
+    module Base
+      class Validation
+
+        EMAIL_REGEX = /\A([\w+\-].?)+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
+        CREDIT_CARD_REGEX = /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})$/i
+        
+        attr_accessor :attributes, :errors
+
+        def initialize(attributes)
+          self.attributes = attributes
+          self.errors = {}
+        end
+
+        def no_validation(_); end
+
+        def presence_validation(attribute)
+          if value_for(attribute).blank?
+            add_error(attribute, "Required attribute not present")
+          end
+        end
+
+        def email_validation(attribute)
+          unless value_for(attribute) =~ EMAIL_REGEX
+            add_error(attribute, "Doesn't validate as an email.")
+          end
+        end
+
+        def zip_validation(attribute)
+          set_attribute(attribute, Integer(value_for(attribute)).to_s)
+
+          unless value_for(attribute).length == 5
+            add_error(attribute, "Must be a 5-digit string that can evaluate to a number.")
+          end
+
+        rescue
+          add_error(attribute, "Must be a 5-digit string that can evaluate to a number.")
+        end
+
+        def card_number_validation(attribute)
+          # Non decimal numbers should be stripped to match.
+          set_attribute(attribute, value_for(attribute).gsub(/\D/, ''))
+
+          unless value_for(attribute) =~ CREDIT_CARD_REGEX
+            add_error(attribute, "Doesn't validate as a credit card.")
+          end
+        end
+
+        def expiration_month_validation(attribute)
+          # if a string, check if length = 2 and smaller than int 12
+          # if int, transform into string with zero pad and check if smaller than int 12
+          integer = Integer(value_for(attribute))
+
+          if integer > 12
+            add_error(attribute, "Must be smaller than 12.")
+          end
+
+          set_attribute(attribute, integer.to_s.rjust(2, '0'))
+          
+        rescue ArgumentError
+          add_error(attribute, "Must be an integer.")
+        end
+
+        def expiration_year_validation(attribute)
+          # if length = 4, strip to 2;
+          # if a string, check if length = 2 and smaller than int 12
+          # if int, transform into string with zero pad and check if smaller than int 12
+
+
+          is_four_digit = if value_for(attribute).is_a?(String)
+            value_for(attribute).length == 4
+          else
+            value_for(attribute) > 999
+          end
+
+          integer_value = Integer(value_for(attribute))
+
+          set_attribute(attribute, integer_value.to_s.last(2))
+        rescue
+          add_error(attribute, "Must be a 2 to 4-digit string.")
+        end
+
+        def amount_validation(attribute)
+          set_attribute(attribute, Float(value_for(attribute)))
+        rescue ArgumentError
+          add_error(attribute, "Must be a float, integer or decimal")
+        end
+        
+        def value_for(attribute)
+          attributes[attribute[:name]]
+        end
+
+        def set_attribute(attribute, value)
+          self.attributes[attribute[:name]] = value
+        end
+
+        def add_error(attribute, message)
+          self.errors[attribute[:name]] ||= []
+          self.errors[attribute[:name]] << message
+        end
+      end
+    end
+  end
+end

data/lib/paycertify/gateway/charge.rb

@@ -0,0 +1,58 @@
+module PayCertify
+  class Gateway
+    class Charge < PayCertify::Gateway::Base::Resource
+
+      API_ENDPOINT = '/ws/cardsafe.asmx/ProcessStoredCard'
+
+      ATTRIBUTES = [
+        :transaction_id, :app_transaction_id, :type, :amount, 
+        :credit_card_id, :gateway_response
+      ]
+
+      attr_accessor *ATTRIBUTES
+
+      alias :execute! :save!
+
+      def type
+        'sale'
+      end
+
+      def success?
+        response['response']['transaction_result']['result'] == '0'
+      end
+
+      def save!
+        super
+        self.transaction_id = response['response']['transaction_result']['pn_ref']
+        self
+      end
+
+      def attributes_to_gateway_format
+        formatted = super
+        attribute_mapping = PayCertify::Gateway::AttributeMapping
+
+        formatted.merge! attribute_mapping.type(self)
+        formatted.merge!({'TokenMode' => 'DEFAULT'})
+
+        formatted
+      end
+
+      class Validation < PayCertify::Gateway::Base::Validation
+        ALL_VALIDATIONS = [
+          { name: :credit_card_id, validation: :no_validation, required: true },
+          { name: :amount, validation: :amount_validation, required: true },
+          { name: :transaction_id, validation: :no_validation, required: true },
+        ]
+
+        def initialize(attributes={})
+          super(attributes)
+
+          ALL_VALIDATIONS.each do |attribute|
+            presence_validation(attribute) if attribute[:required]
+            send(attribute[:validation], attribute) if value_for(attribute).present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paycertify/gateway/client.rb

@@ -19,8 +19,14 @@ module PayCertify
         @api_endpoint ||= 'https://'+ (live?? 'gateway' : 'demo') +'.paycertify.net'
       end
 
+      def get(path:, data: {})
+        data.merge!(token_payload)
+        response = connection.get(path, data)
+        respond_with response
+      end
+
       def post(path:, data:)
-        body = data.merge('ApiToken' => api_key)
+        body = data.merge(token_payload)
 
         response = connection.post do |request|
           request.url path
@@ -47,6 +53,10 @@ module PayCertify
           end
         end
 
+        def token_payload
+          { 'ApiToken' => api_key }
+        end
+
         def respond_with(response)
           self.response = PayCertify::Gateway::Response.new(response)
         end

data/lib/paycertify/gateway/credit_card.rb

@@ -0,0 +1,65 @@
+module PayCertify
+  class Gateway
+    class CreditCard < PayCertify::Gateway::Base::Resource
+
+      API_ENDPOINT = '/ws/cardsafe.asmx/StoreCard'
+      SAFE_CARD_REGEX = /\<CardSafeToken>(.*)<\/CardSafeToken>/
+      
+      ATTRIBUTES = [
+        :credit_card_id, :card_number, :expiration_month, :expiration_year, 
+        :customer_id, :name_on_card, :zip
+      ]
+
+      attr_accessor *ATTRIBUTES
+
+      def success?
+        super && response['response']['result'] == '0'
+      end
+
+      def save!
+        super
+        self.credit_card_id = get_credit_card_id
+        self
+      end
+
+      def attributes_to_gateway_format
+        formatted = super
+        attribute_mapping = PayCertify::Gateway::AttributeMapping
+
+        formatted.merge! attribute_mapping.expiration_date(self)
+        formatted.merge!({'TokenMode' => 'DEFAULT'})
+
+        formatted
+      end
+
+      def get_credit_card_id
+        response['response']['ext_data'].match(SAFE_CARD_REGEX)
+        credit_card_id = $1
+        credit_card_id.presence || response['response']['ext_data']['safe_card_token']
+      end
+
+      class Validation < PayCertify::Gateway::Base::Validation
+        ALL_VALIDATIONS = [
+          # Mandatory fields
+          { name: :card_number, validation: :card_number_validation, required: true },
+          { name: :expiration_month, validation: :expiration_month_validation, required: true },
+          { name: :expiration_year, validation: :expiration_year_validation, required: true },
+          { name: :name_on_card, validation: :no_validation, required: true },
+          { name: :customer_id, validation: :no_validation, required: true },
+          
+          # Optional fields
+          { name: :zip, validation: :zip_validation, required: false }
+        ]
+
+        def initialize(attributes={})
+          super(attributes)
+
+          ALL_VALIDATIONS.each do |attribute|
+            presence_validation(attribute) if attribute[:required]
+            send(attribute[:validation], attribute) if value_for(attribute).present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paycertify/gateway/customer.rb

@@ -0,0 +1,60 @@
+module PayCertify
+  class Gateway
+    class Customer < PayCertify::Gateway::Base::Resource
+      
+      API_ENDPOINT = '/ws/recurring.asmx/ManageCustomer'
+
+      ATTRIBUTES = [
+        :app_customer_id, :name, :customer_id, :type, :address, :city, 
+        :state, :zip, :phone, :fax, :email, :status
+      ]
+
+      attr_accessor *ATTRIBUTES
+
+      def save!
+        super
+        self.customer_id = self.response['response']['customer_key']
+        self
+      end
+
+      def attributes_to_gateway_format
+        formatted = super
+        attribute_mapping = PayCertify::Gateway::AttributeMapping
+        formatted.merge! attribute_mapping.type(self)
+        formatted
+      end
+
+      class Validation < PayCertify::Gateway::Base::Validation
+        ALL_VALIDATIONS = [
+          # Mandatory fields
+          { name: :app_customer_id, validation: :no_validation, required: true },
+          { name: :type, validation: :type_validation, required: true },
+          { name: :name, validation: :no_validation, required: true },
+          
+          # Optional fields
+          { name: :zip, validation: :zip_validation, required: false },
+          { name: :email, validation: :email_validation, required: false },
+          { name: :status, validation: :status_validation, required: false }
+        ]
+
+        ALLOWED_TYPES = %w(add update delete)
+        ALLOWED_STATUSES = %w(active inactive pending closed)
+
+        def initialize(attributes={})
+          super(attributes)
+
+          ALL_VALIDATIONS.each do |attribute|
+            presence_validation(attribute) if attribute[:required]
+            send(attribute[:validation], attribute) if value_for(attribute).present?
+          end
+        end
+
+        def type_validation(attribute)
+          unless value_for(attribute).try(:to_s).in?(ALLOWED_TYPES)
+            add_error(attribute, "Must be one of #{ALLOWED_TYPES.join(', ')}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/paycertify/gateway/response.rb

@@ -8,24 +8,27 @@ module PayCertify
       
       def initialize(response)
         self.status = response.status
-        self.original_body = Hash.from_xml(response.body)['Response']
+        self.original_body = Hash.from_xml(response.body)
 
-        super(
-          id: original_body['PNRef'],
-          status: response.status,
-          status_string: original_body['Result'] == APPROVED ? 'approved' : 'declined',
-          message: [original_body['Message'], original_body['Message1'], original_body['Message2']].compact.join(' / '),
-          amount: original_body['Amount'].to_d,
-          auth_code: original_body['AuthCode'],
-          payment_type: original_body['PaymentType'],
-          card_number: original_body['Account'],
-          created_at: DateTime.strptime([original_body['TransDate'], original_body['TransTime']].join, '%m%d%Y%H%M%s')
-        )
+        super(convert_hash_keys(original_body))
       end
 
-      def success?
-        self['status_string'] == 'approved'
-      end
+      private
+        def underscore_key(k)
+          k.to_s.underscore.to_sym
+        end
+
+        def convert_hash_keys(value)
+          case value
+            when Array
+              value.map { |v| convert_hash_keys(v) }
+              # or `value.map(&method(:convert_hash_keys))`
+            when Hash
+              Hash[value.map { |k, v| [underscore_key(k), convert_hash_keys(v)] }]
+            else
+              value
+           end
+        end
     end
   end
 end

data/lib/paycertify/gateway/transaction.rb

@@ -1,54 +1,116 @@
+require 'ipaddr'
+
 module PayCertify
   class Gateway
-    class Transaction
-
-      TRANSACTION_PATH = '/ws/encgateway2.asmx/ProcessCreditCard'
-
-      attr_accessor :client, :original_attributes
+    class Transaction < PayCertify::Gateway::Base::Resource
 
-      attr_accessor :type, :amount, :currency, :card_number, :expiration_month, :expiration_year, 
-        :name_on_card, :cvv, :transaction_id, :billing_address, :billing_city, :billing_state, :billing_country, :billing_zip,
-        :shipping_address, :shipping_city, :shipping_state, :shipping_country, 
-        :shipping_zip, :email, :phone, :ip, :order_description, :customer_id, :metadata
+      API_ENDPOINT = '/ws/encgateway2.asmx/ProcessCreditCard'
+      
+      ATTRIBUTES = [
+        :transaction_id, :type, :amount, :currency, :card_number, :expiration_month, :expiration_year, 
+        :name_on_card, :cvv, :billing_address, :billing_city, :billing_state, :billing_country, 
+        :billing_zip, :shipping_address, :shipping_city, :shipping_state, :shipping_country,  :shipping_zip, 
+        :email, :phone, :ip, :order_description, :customer_id
+      ]
 
-      def initialize(client, attributes)
-        self.original_attributes = attributes
-        self.client = client
+      attr_accessor *ATTRIBUTES
 
-        validation.attributes.each do |key, value|
-          self.send("#{key}=", value)
-        end
+      def save!
+        super
+        self.transaction_id = response['response']['pn_ref']
+        self
       end
 
-      def validation
-        @validation ||= PayCertify::Gateway::Validation.new(original_attributes)
+      def success?
+        super && response['response']['result'] == '0'
       end
 
-      def process
-        client.post(
-          path: TRANSACTION_PATH,
-          data: attributes_to_gateway_format
-        )
+      def attributes_to_gateway_format
+        formatted = super
+        attribute_mapping = PayCertify::Gateway::AttributeMapping
+        formatted.merge! attribute_mapping.expiration_date(self)
+        formatted.merge! attribute_mapping.type(self)
+        formatted
       end
 
-      private
-        def attributes_to_gateway_format
-          {}.tap do |formatted|
-            attribute_mapping = PayCertify::Gateway::AttributeMapping
+      class Validation < PayCertify::Gateway::Base::Validation
+        ALL_VALIDATIONS = [
+          # Mandatory fields
+          { name: :type, validation: :type_validation, required: true },
+          { name: :amount, validation: :amount_validation, required: true },
+          { name: :currency, validation: :currency_validation, required: true },
+          { name: :card_number, validation: :card_number_validation, required: true },
+          { name: :expiration_month, validation: :expiration_month_validation, required: true },
+          { name: :expiration_year, validation: :expiration_year_validation, required: true },
+          { name: :name_on_card, validation: :no_validation, required: true },
+          { name: :cvv, validation: :no_validation, required: true },
+          { name: :transaction_id, validation: :no_validation, required: true },
+          { name: :billing_city, validation: :no_validation, required: true },
+          { name: :billing_state, validation: :no_validation, required: true },
+          { name: :billing_country, validation: :no_validation, required: true },
+          { name: :billing_zip, validation: :zip_validation, required: true },
+          
+          # Optional fields
+          { name: :shipping_zip, validation: :zip_validation, required: false },
+          { name: :email, validation: :email_validation, required: false },
+          { name: :ip, validation: :ip_validation, required: false }
+        ]
+
+        CAPTURE_VALIDATIONS = [
+          { name: :type, validation: :type_validation, required: true },
+          { name: :amount, validation: :amount_validation, required: true },
+          { name: :transaction_id, validation: :no_validation, required: true }
+        ]
 
-            attribute_mapping.wrapper_to_gateway.each do |key, value|
-              [value].flatten.tap do |method_chain|
-                new_value = method_chain.map { |method_name| self.send(method_name) }.join
-                formatted[key] = new_value
-              end
-            end
+        VOID_VALIDATIONS = [
+          { name: :type, validation: :type_validation, required: true },
+          # { name: :amount, validation: :amount_validation, required: true },
+          { name: :transaction_id, validation: :no_validation, required: true }
+        ]
 
-            formatted.merge! attribute_mapping.expiration_date(self)
-            formatted.merge! attribute_mapping.transaction_type(self)
+        ALLOWED_TYPES = %w(sale auth return void force recurring)
+        ALLOWED_CURRENCIES = %w(USD EUR)
 
-            formatted
+        def initialize(attributes={})
+          super(attributes)
+
+          validations.each do |attribute|
+            presence_validation(attribute) if attribute[:required]
+            send(attribute[:validation], attribute) if value_for(attribute).present?
           end
         end
+
+        def validations
+          case attributes[:type]
+          when 'force'
+            CAPTURE_VALIDATIONS
+          when 'void', 'return'
+            VOID_VALIDATIONS
+          else
+            ALL_VALIDATIONS
+          end
+        end
+
+        def type_validation(attribute)
+          unless value_for(attribute).try(:to_s).in?(ALLOWED_TYPES)
+            add_error(attribute, "Must be one of #{ALLOWED_TYPES.join(', ')}")
+          end
+        end
+
+        def currency_validation(attribute)
+          set_attribute(attribute, value_for(attribute).upcase)
+
+          unless value_for(attribute).try(:to_s).in?(ALLOWED_CURRENCIES)
+            add_error(attribute, "Must be one of #{ALLOWED_CURRENCIES.join(', ')}")
+          end
+        end
+
+        def ip_validation(attribute)
+          IPAddr.new(value_for(attribute))
+        rescue IPAddr::InvalidAddressError
+          add_error(attribute, "Doesn't validate as an IP.")
+        end
+      end
     end
   end
 end

data/lib/paycertify/insurance.rb

@@ -0,0 +1,118 @@
+module PayCertify
+  class Insurance
+
+    class NoCredentialsError < StandardError; end
+    
+    API_ENDPOINT = 'https://connect.paycertify.com/'
+    
+    MANDATORY_FIELDS = [
+      :firstname, :lastname, :email, :order_number, :items_ordered, :charge_amount, 
+      :billing_address, :billing_address2, :billing_city, :billing_state, :billing_country, :billing_zip_code
+    ]
+    
+    OPTIONAL_FIELDS = [
+      :phone, :shipping_address, :shipping_address2, :shipping_city, 
+      :shipping_state, :shipping_country, :shipping_zip_code, :shipping_carrier, :tracking_number
+    ]
+
+    attr_accessor :attributes, :errors, :response
+
+    delegate :client_id, :token, to: :class
+
+    def initialize(attributes)
+      raise NoCredentialsError, 'No token found for api_client/secret/client_id combination.' unless token.present?
+
+      self.attributes = HashWithIndifferentAccess.new(attributes)
+      self.errors = {}
+
+      validate!
+    end
+
+    def success?
+      response.success?
+    end
+
+    def save!
+      data = attributes.slice *[MANDATORY_FIELDS + OPTIONAL_FIELDS].flatten
+      data[:ship_to_billing_addr] = true unless data[:shipping_address].present?
+
+      api_response = connection.post do |request|
+        request.url path_for('orders')
+        request.headers['Content-Type'] = 'application/json'
+        request.headers['Authorization'] = "JWT #{token}"
+        request.body = JSON.generate(data)
+      end
+
+      self.response = Response.new(api_response)
+      self.errors = errors.merge(response) unless response.success?
+
+      response
+    end
+
+    class << self
+      attr_accessor :api_public_key, :api_secret_key, :client_id, :token
+
+      def configure(&block)
+        yield self if block_given?
+
+        connection = Faraday.new(url: API_ENDPOINT, ssl: {verify: false}) do |faraday|
+          faraday.request :url_encoded
+          faraday.response :logger
+          faraday.adapter  Faraday.default_adapter
+        end
+
+        response = connection.get do |request|
+          request.url 'api/v1/token'
+          request.headers['api-public-key'] = api_public_key
+          request.headers['api-secret-key'] = api_secret_key
+          request.headers['api-client-id']  = client_id
+        end
+
+        json = JSON.parse(response.body)
+        
+        self.token = json['jwt']
+
+        return {
+          api_public_key: api_public_key,
+          api_secret_key: api_secret_key,
+          client_id: client_id,
+          token: token
+        }
+      end
+    end
+
+    class Response < HashWithIndifferentAccess
+      attr_accessor :original_response
+
+      def initialize(response)
+        self.original_response = response
+        super JSON.parse(response.body)
+      end
+
+      def success?
+        original_response.status < 400
+      end
+    end
+
+    private
+      def validate!
+        MANDATORY_FIELDS.each do |field|
+          unless attributes[field].present?
+            self.errors[field] = "Required attribute not present"
+          end
+        end
+      end
+
+      def connection
+        @connection ||= Faraday.new(url: API_ENDPOINT, ssl: {verify: false}) do |faraday|
+          faraday.request :url_encoded
+          faraday.response :logger
+          faraday.adapter  Faraday.default_adapter
+        end
+      end
+
+      def path_for(path)
+        return "api/v1/#{client_id}/#{path}/"
+      end
+  end
+end

data/lib/paycertify/three_ds.rb

@@ -63,7 +63,7 @@ module PayCertify
     end
 
     class << self
-      cattr_accessor :api_key, :api_secret, :mode
+      attr_accessor :api_key, :api_secret, :mode
 
       def configure(&block)
         yield self if block_given?

data/lib/paycertify/three_ds/callback.rb

@@ -19,6 +19,14 @@ module PayCertify
         self['_frictionless_3ds_callback'].present?
       end
 
+      def handshake
+        self.slice('cavv', 'eci', 'cavv_algorithm', 'xid')
+      end
+
+      def redirect_to(location)
+        "<script>window.location.href = '#{location}'</script>"
+      end
+
       def authenticate!
         PayCertify::ThreeDS.authenticate!(settings: session, callback_params: params)
       end

data/lib/paycertify/three_ds/client.rb

@@ -1,4 +1,5 @@
 require 'faraday'
+require 'faraday_curl'
 
 module PayCertify
   class ThreeDS
@@ -56,12 +57,16 @@ module PayCertify
         def connection
           @connection ||= Faraday.new(url: API_ENDPOINT, ssl: {verify: false}) do |faraday|
             faraday.request :url_encoded
+            faraday.request :curl, Logger.new(STDOUT), :warn
             faraday.response :logger
             faraday.adapter  Faraday.default_adapter
           end
         end
 
         def signature(path, data)
+          10.times{puts}
+          puts "#{api_key}#{path_for(path)}#{data}#{api_secret}"
+          10.times{puts}
           Digest::SHA256.hexdigest "#{api_key}#{path_for(path)}#{data}#{api_secret}"
         end
 

data/lib/paycertify/three_ds/form.rb

@@ -46,7 +46,7 @@ module PayCertify
           </script>
         HTML
       end
-      
+
       def frictionless
         html = <<-HTML.squish
           <style> #frame { display: none; } </style>
@@ -69,42 +69,40 @@ module PayCertify
               var frame = document.getElementById('frame');
               var form = document.getElementById('callback-form');
               var interval = 500;
-              var timeout = interval * 30;
-              var counter = 0;
+              var timeout = interval * 15;
 
               frame.contentDocument.write('#{form}');
               frame.contentDocument.form3ds.submit();
 
-              setInterval(function() {
-                counter = counter + interval;
-
-                if (counter < timeout) {
-                  try {
-                    var frameContent = frame.contentDocument;
-                    var frameDoc = frameContent.documentElement;
+              var interval = setInterval(function() {
+                try {
+                  var frameContent = frame.contentDocument;
+                  var frameDoc = frameContent.documentElement;
 
-                    var text = frameContent.body.innerHTML || frameDoc.textContent || frameDoc.innerText;
-                    var json = JSON.parse(text);
-                    
-                    var input;
+                  var text = frameContent.body.innerHTML || frameDoc.textContent || frameDoc.innerText;
+                  var json = JSON.parse(text);
 
-                    for(key in json) {
-                      input = document.createElement('input');
-                      input.type = 'hidden';
-                      input.name = key;
-                      input.value = json[key];
+                  var input;
 
-                      form.appendChild(input);
-                    };
+                  for(key in json) {
+                    input = document.createElement('input');
+                    input.type = 'hidden';
+                    input.name = key;
+                    input.value = json[key];
 
-                    form.submit();
-                  } catch(e) {
-                    return false;
+                    form.appendChild(input);
                   };
-                } else {
+
+                  clearInterval(interval);
                   form.submit();
-                }
+                } catch(e) {
+                  return false;
+                };
               }, interval);
+
+              setTimeout(function() {
+                form.submit();
+              }, timeout);
             })();
           </script>
         HTML

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paycertify
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - PayCertify Engineering Team
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday_curl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Interact with the Gateway, 3DS, Kount, and FraudPortal
 email: engineering@paycertify.com
 executables: []
@@ -45,12 +59,19 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/paycertify.rb
+- lib/paycertify/confirmation.rb
 - lib/paycertify/gateway.rb
 - lib/paycertify/gateway/attribute_mapping.rb
+- lib/paycertify/gateway/base.rb
+- lib/paycertify/gateway/base/resource.rb
+- lib/paycertify/gateway/base/validation.rb
+- lib/paycertify/gateway/charge.rb
 - lib/paycertify/gateway/client.rb
+- lib/paycertify/gateway/credit_card.rb
+- lib/paycertify/gateway/customer.rb
 - lib/paycertify/gateway/response.rb
 - lib/paycertify/gateway/transaction.rb
-- lib/paycertify/gateway/validation.rb
+- lib/paycertify/insurance.rb
 - lib/paycertify/three_ds.rb
 - lib/paycertify/three_ds/callback.rb
 - lib/paycertify/three_ds/client.rb

data/lib/paycertify/gateway/validation.rb

@@ -1,174 +0,0 @@
-require 'ipaddr'
-
-module PayCertify
-  class Gateway
-    class Validation
-
-      ATTRIBUTES = [
-        # Mandatory fields
-        { name: :type, validation: :type_validation, required: true },
-        { name: :amount, validation: :amount_validation, required: true },
-        { name: :currency, validation: :currency_validation, required: true },
-        { name: :card_number, validation: :card_number_validation, required: true },
-        { name: :expiration_month, validation: :expiration_month_validation, required: true },
-        { name: :expiration_year, validation: :expiration_year_validation, required: true },
-        { name: :name_on_card, validation: :no_validation, required: true },
-        { name: :cvv, validation: :no_validation, required: true },
-        { name: :transaction_id, validation: :no_validation, required: true },
-        { name: :billing_city, validation: :no_validation, required: true },
-        { name: :billing_state, validation: :no_validation, required: true },
-        { name: :billing_country, validation: :no_validation, required: true },
-        { name: :billing_zip, validation: :zip_validation, required: true },
-        
-        # Optional fields
-        { name: :billing_address, validation: :no_validation, required: false },
-        { name: :shipping_address, validation: :no_validation, required: false },
-        { name: :shipping_city, validation: :no_validation, required: false },
-        { name: :shipping_state, validation: :no_validation, required: false },
-        { name: :shipping_country, validation: :no_validation, required: false },
-        { name: :shipping_zip, validation: :zip_validation, required: false },
-        { name: :email, validation: :email_validation, required: false },
-        { name: :phone, validation: :no_validation, required: false },
-        { name: :ip, validation: :ip_validation, required: false },
-        { name: :order_description, validation: :no_validation, required: false },
-        { name: :customer_id, validation: :no_validation, required: false },
-        { name: :metadata, validation: :no_validation, required: false }
-      ]
-
-      ALLOWED_TYPES = %w(sale auth refund void force recurring)
-      ALLOWED_CURRENCIES = %w(USD EUR)
-      CREDIT_CARD_REGEX = /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})$/i
-      EMAIL_REGEX = /\A([\w+\-].?)+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i
-
-      class ValidationError < StandardError; end
-
-      attr_accessor :attributes, :errors
-
-      def initialize(attributes={})
-        self.attributes = attributes
-
-        ATTRIBUTES.each do |attribute|
-          presence_validation(attribute) if attribute[:required]
-          send(attribute[:validation], attribute) if value_for(attribute).present?
-        end
-      end
-
-      protected
-        def presence_validation(attribute)
-          if value_for(attribute).blank?
-            raise ValidationError, "Required attribute not present: #{attribute[:name]}."
-          end
-        end
-
-        def no_validation(_); end
-
-        def type_validation(attribute)
-          unless value_for(attribute).try(:to_s).in?(ALLOWED_TYPES)
-            raise ValidationError, error_message(attribute, "Must be one of #{ALLOWED_TYPES.join(', ')}")
-          end
-        end
-
-        def amount_validation(attribute)
-          set_attribute(attribute, Float(value_for(attribute)))
-        rescue ArgumentError
-          raise ValidationError, error_message(attribute, "Must be a float, integer or decimal")
-        end
-
-        def currency_validation(attribute)
-          set_attribute(attribute, value_for(attribute).upcase)
-
-          unless value_for(attribute).try(:to_s).in?(ALLOWED_CURRENCIES)
-            raise ValidationError, error_message(attribute, "Must be one of #{ALLOWED_CURRENCIES.join(', ')}")
-          end
-        end
-
-        def card_number_validation(attribute)
-          # Non decimal numbers should be stripped to match.
-          set_attribute(attribute, value_for(attribute).gsub(/\D/, ''))
-
-          unless value_for(attribute) =~ CREDIT_CARD_REGEX
-            raise ValidationError, error_message(attribute, "Doesn't validate as a credit card.")
-          end
-        end
-
-        def zip_validation
-          # Check if it's a number
-          set_attribute(attribute, Integer(value_for(attribute)).to_s)
-
-          if value_for(attribute).length > 5
-            # Raise validation error
-          end
-        end
-
-        def expiration_month_validation(attribute)
-          # if a string, check if length = 2 and smaller than int 12
-          # if int, transform into string with zero pad and check if smaller than int 12
-          integer = Integer(value_for(attribute))
-
-          if integer > 12
-            raise ValidationError, error_message(attribute, "Must be smaller than 12.")
-          end
-
-          set_attribute(attribute, integer.to_s.rjust(2, '0'))
-          
-        rescue ArgumentError
-          raise ValidationError, error_message(attribute, "Must be an integer.")
-        end
-
-        def expiration_year_validation(attribute)
-          # if length = 4, strip to 2;
-          # if a string, check if length = 2 and smaller than int 12
-          # if int, transform into string with zero pad and check if smaller than int 12
-
-
-          is_four_digit = if value_for(attribute).is_a?(String)
-            value_for(attribute).length == 4
-          else
-            value_for(attribute) > 999
-          end
-
-          integer_value = Integer(value_for(attribute))
-
-          set_attribute(attribute, integer_value.to_s.last(2))
-        rescue
-          raise ValidationError, error_message(attribute, "Must be a 2 to 4-digit string.")
-        end
-
-        def zip_validation(attribute)
-          set_attribute(attribute, Integer(value_for(attribute)).to_s)
-
-          unless value_for(attribute).length == 5
-            raise ValidationError, error_message(attribute, "Must be a 5-digit string that can evaluate to a number.")
-          end
-
-        rescue
-          raise ValidationError, error_message(attribute, "Must be a 5-digit string that can evaluate to a number.")
-        end
-
-        def email_validation(attribute)
-          unless value_for(attribute) =~ EMAIL_REGEX
-            raise ValidationError, error_message(attribute, "Doesn't validate as an email.")
-          end
-        end
-
-        def ip_validation(attribute)
-          IPAddr.new(value_for(attribute))
-        rescue IPAddr::InvalidAddressError
-          raise ValidationError, error_message(attribute, "Doesn't validate as an IP.")
-        end
-
-      private
-        def value_for(attribute)
-          attributes[attribute[:name]]
-        end
-
-        def set_attribute(attribute, value)
-          self.attributes[attribute[:name]] = value
-        end
-
-        def error_message(attribute, message)
-          "Attribute #{attribute[:name]} passed as: #{value_for(attribute)}. #{message}"
-        end
-    end
-  end
-end