paysafe 0.6.2 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d342047f484e12247acaa0f8763e0cd252228e83
-  data.tar.gz: b70bf62d28be40941f816525715c6d65fc5a761e
+  metadata.gz: d6bbfa2b88d67e16221b48a7fdc9e2048f3e83e2
+  data.tar.gz: f4e8670f77a2ca5a406b5a52794a446f87f2dabe
 SHA512:
-  metadata.gz: 3fae18580d0b5a010b03a5d0f0c804aac8ebc3b76d1119155f99c01d9d90a020e2ce1b30390b18b1d944c68d155a796b8b46335b37a8c4b16428859eaac40b4a
-  data.tar.gz: bd5ee3aab0093d1521b7f97ab7df8cea404b60f3dc577369f9e7de32a4bea0e1bedf3af13a03e6d63901cdaa54bfe1a0a610781439b186d11e5fb3d447d9c92e
+  metadata.gz: dd143b165e5467ae27d084c9011ce710d80dd40eff19fbd2896a4514b6a3d1dff4ccefea27ee533aa05b2c37825970a3644bd7cd14111ec313ba4192fdd725f6
+  data.tar.gz: f577618983eaa4dc510f5fa4def95780be2c85c8ec791d35ea8c300018acbc56780f3f58a7fbf6e5c0558e9ce6d8114cc5fc89c7c8b96d34b69ce77b2205eeb0

data/.env.sample

@@ -1,3 +1,8 @@
 PAYSAFE_ACCOUNT_NUMBER="YOUR_ACCOUNT_NUMBER"
 PAYSAFE_API_KEY="YOUR_API_KEY"
 PAYSAFE_API_SECRET="YOUR_API_SECRET"
+
+# This is only needed if you want to generate your own Single
+# Use Tokens which utilize a different API key and secret.
+PAYSAFE_SUT_API_KEY="YOUR_SINGLE_USE_TOKEN_API_KEY"
+PAYSAFE_SUT_API_SECRET="YOUR_SINGLE_USE_TOKEN_API_SECRET"

data/.travis.yml

@@ -1,13 +1,13 @@
 language: ruby
 rvm:
-  - 2.1.5
-  - 2.2.3
-before_install: gem install bundler -v 1.10.6
+  - 2.3.4
+  - 2.4.1
+before_install: gem install bundler
 cache: bundler
 sudo: false
 fast_finish: true
 env:
-  - SKIP_INTEGRATION_TESTS=true
+  - SKIP_INTEGRATION=true
 notifications:
   email:
     on_success: always

data/CHANGELOG.md

@@ -0,0 +1,28 @@
+Changelog
+=========
+
+## 0.9.0 (2017-04-19)
+
+This is a major update with breaking changes so moving the version up quite a bit since I'd also like to move to a 1.0 release soon after.
+
+* Requires Ruby 2.3 and up.
+* All API methods now accept params in snake_case and are converted to camelCase.
+* Responses are now typed with classes using snake_case properties (converted from camelCase) handling nested complex objects and lazily loaded. No more hashes.
+* Field names match Paysafe API docs except when making requests and working with responses, its all in snake_case.
+* Renamed config `timeout_options` renamed to `timeouts`.
+* Removed default value for `timeouts` config.
+* Added new methods to work with single use tokens:
+  * `create_single_use_token` (requires different API key and secret)
+  * `create_verification_from_token`
+  * `create_profile_from_token`
+  * `create_card_from_token`
+* Updated `bin/setup` script.
+* Updated API base domain to paysafe.com.
+
+## 0.6.2 (2016-04-25)
+
+* Upgrade http gem to v2.0
+
+## 0.6.1 (2016-03-02)
+
+* Add `update_profile` method to client

data/README.md

@@ -3,54 +3,88 @@
 [![Gem Version](https://badge.fury.io/rb/paysafe.svg)][gem]
 [![Build Status](https://travis-ci.org/javierjulio/paysafe.svg?branch=master)][travis]
 
-[gem]: https://rubygems.org/gems/paysafe
-[travis]: https://travis-ci.org/javierjulio/paysafe
-
-A tested Ruby interface to the Paysafe REST API (formerly Optimal Payments). Note: requires Ruby 2.1 and up. Not all API actions are supported yet.
+A well tested Ruby interface to the [Paysafe REST API](paysafe_api_reference) (formerly Optimal Payments). Requires Ruby 2.3 and up. Not all API actions are supported yet. Since the Paysafe API uses camelCase, this gem will handle converting to and from snake_case for you.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add the following to your application's Gemfile:
 
 ```ruby
 gem 'paysafe'
 ```
 
-And then execute:
+Or install directly with `gem install paysafe`.
 
-    $ bundle
+To try out the gem, just follow the Development section instructions as the built in setup script will direct you on how to provide the necessary API info.
 
-Or install it yourself as:
+## Usage
 
-    $ gem install paysafe
+### Client Configuration
 
-To try out the gem and experiment, you're better off following the development instructions.
+Create and configure a client with your API authentication.
 
-## Usage
+```ruby
+client = Paysafe::REST::Client.new do |config|
+  config.account_number = '1234567890'
+  config.api_key = 'api_key'
+  config.api_secret = 'api_secret'
+  # Enable production requests
+  # config.test_mode = false
+  # Provide explicit timeouts
+  # config.timeouts = { connect: 2, read: 5, write: 10 }
+end
+```
 
-TODO: Write usage instructions here
+### Making Requests
 
-## Development
+Make an API request with a payload in the structure documented by the [Paysafe REST API](paysafe_api_reference) but using snake_case. The request payload will be converted to camelCase for you.
 
-1. Clone the repo: `git clone https://github.com/javierjulio/paysafe.git`
-2. Use Ruby 2.1 and up. If you need to install use [rbenv](https://github.com/sstephenson/rbenv) and [ruby-build](https://github.com/sstephenson/ruby-build) and then run:
+```ruby
+profile = client.create_profile(
+  merchant_customer_id: '123',
+  locale: 'en_US',
+  card: {
+    card_num: '4111111111111111',
+    card_expiry: {
+      month: 12,
+      year: 2020
+    }
+  }
+)
+```
 
-        gem update --system
-        gem update
-        gem install bundler --no-rdoc --no-ri
+### Handling Responses
 
-3. From project root run `./bin/setup` script
-4. Run `./bin/console` for an interactive prompt with an authenticated client for you to experiment:
+Response data is in snake_case (converted from camelCase) typed with individual methods and predicates, including nested complex objects and array of objects as shown below:
 
-  ```ruby
-  profile = client.create_profile(merchantCustomerId: '123', locale: 'en_US')
-  puts profile[:id]
-  # => b088ac37...
-  ```
+```ruby
+profile.id?
+# => true
+profile.id
+# => b088ac37...
+profile.cards.first.card_expiry.year
+# => 2020
+```
+
+Further API methods are provided in the `Paysafe::REST::Client` object.
+
+## Development
+
+1. `git clone https://github.com/javierjulio/paysafe.git`
+2. Run `./bin/setup` to install dependencies and fill out API key info
+3. Run `./bin/console` for an interactive prompt with an authenticated client for you to experiment:
+
+    ```ruby
+    profile = client.create_profile(merchant_customer_id: '123', locale: 'en_US')
+    puts profile.id
+    # => b088ac37...
+    ```
+
+All code is written in snake_case since requests and responses are converted to and from camelCase for you.
 
 ### Tests
 
-Run `bundle exec rake test` or to skip integration tests run with `SKIP_INTEGRATION_TESTS=true`.
+Run `bundle exec rake test` or to skip integration tests run with `SKIP_INTEGRATION=true`.
 
 ### Releasing
 
@@ -63,3 +97,7 @@ Bug reports and pull requests for missing API support are welcome on GitHub at h
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+[gem]: https://rubygems.org/gems/paysafe
+[travis]: https://travis-ci.org/javierjulio/paysafe
+[paysafe_api_reference]: https://developer.paysafe.com/en/api-reference/

data/bin/setup

@@ -4,15 +4,16 @@ IFS=$'\n\t'
 
 bundle install
 
-read -r -p 'Do you have an Optimal Payments Developer Centre account? (y/n) ' has_account
+read -r -p 'Do you have an Paysafe Developer account? (y/n) ' has_account
 
 if [[ "$has_account" =~ ^(Yes|yes|Y|y)$ ]]; then
   echo "Great! You can get your account credentials from:"
-  echo "  https://developer.optimalpayments.com/en/my-account/"
+  echo "  https://login.test.netbanx.com/office/public/preLogin.htm"
   echo
 else
-  echo "Then you'll need to create an account first at:"
-  echo "  https://developer.optimalpayments.com/en/get-started/"
+  echo "Then you'll need to create an account first."
+  echo "Click the 'Sign Up' button on the following page:"
+  echo "  https://developer.paysafe.com/"
   echo
   read -s -p "Press Enter key if you're ready to continue..."
   echo
@@ -24,8 +25,8 @@ read -p 'API Key: ' api_key
 read -p 'API Secret: ' api_secret
 
 cp .env.sample .env
-sed -i -e s/YOUR_ACCOUNT_NUMBER/"$account_number"/g .env
-sed -i -e s/YOUR_API_KEY/"$api_key"/g .env
-sed -i -e s/YOUR_API_SECRET/"$api_secret"/g .env
+sed -i '' -e "s/YOUR_ACCOUNT_NUMBER/$account_number/g" .env
+sed -i '' -e "s/YOUR_API_KEY/$api_key/g" .env
+sed -i '' -e "s/YOUR_API_SECRET/$api_secret/g" .env
 
 echo "Done."

data/lib/paysafe/address.rb

@@ -0,0 +1,9 @@
+require 'paysafe/result'
+
+module Paysafe
+  class Address < Result
+    attributes :id, :nick_name, :street, :street2, :city,
+      :country, :state, :zip, :recipient_name, :phone, :status,
+      :default_shipping_address_indicator
+  end
+end

data/lib/paysafe/authorization.rb

@@ -0,0 +1,14 @@
+require 'paysafe/result'
+
+module Paysafe
+  class Authorization < Result
+    attributes :id, :merchant_ref_num, :amount, :settle_with_auth,
+      :pre_auth, :available_to_settle, :child_account_num, :auth_code,
+      :recurring, :customer_ip, :dup_check, :description, :txn_time,
+      :currency_code, :avs_response, :cvv_verification, :status, :keywords
+
+    object_attribute :Card, :card
+    object_attribute :Profile, :profile
+    object_attribute :Address, :billing_details
+  end
+end

data/lib/paysafe/birth_date.rb

@@ -0,0 +1,7 @@
+require 'paysafe/result'
+
+module Paysafe
+  class BirthDate < Result
+    attributes :year, :month, :day
+  end
+end

data/lib/paysafe/card.rb

@@ -0,0 +1,13 @@
+require 'paysafe/result'
+
+module Paysafe
+  class Card < Result
+    attributes :id, :nick_name, :merchant_ref_num, :holder_name,
+      :card_num, :card_bin, :last_digits, :card_type, :billing_address_id,
+      :default_card_indicator, :payment_token, :single_use_token, :status,
+      :cvv, :track1, :track2, :type
+
+    object_attribute :CardExpiry, :card_expiry
+    object_attribute :Address, :billing_address
+  end
+end

data/lib/paysafe/card_expiry.rb

@@ -0,0 +1,7 @@
+require 'paysafe/result'
+
+module Paysafe
+  class CardExpiry < Result
+    attributes :year, :month
+  end
+end

data/lib/paysafe/error.rb

@@ -81,22 +81,21 @@ module Paysafe
       # @param body [String]
       # @param code [Integer]
       # @return [Paysafe::Error]
-      def error_from_response(body, code)
+      def from_response(body, code)
         klass = ERRORS[code] || Paysafe::Error
         message, error_code = parse_error(body)
         klass.new(message: message, code: error_code, response: body)
       end
 
-    private
+      private
 
       def parse_error(body)
-        if body.nil? || body.empty?
-          ['', nil]
-        elsif body.is_a?(Hash) && body[:error].is_a?(Hash)
-          [body[:error][:message], body[:error][:code]]
+        if body.is_a?(Hash)
+          [ body.dig(:error, :message), body.dig(:error, :code) ]
+        else
+          [ '', nil ]
         end
       end
-
     end
 
     # Initializes a new Error object

data/lib/paysafe/profile.rb

@@ -0,0 +1,13 @@
+require 'paysafe/result'
+
+module Paysafe
+  class Profile < Result
+    attributes :id, :status, :merchant_customer_id, :locale,
+      :ip, :first_name, :middle_name, :last_name, :gender,
+      :nationality, :email, :phone, :cell_phone, :payment_token
+
+    object_attribute :BirthDate, :date_of_birth
+    object_attribute :Card, :cards
+    object_attribute :Address, :addresses
+  end
+end

data/lib/paysafe/refinements/camel_case.rb

@@ -0,0 +1,40 @@
+module Paysafe
+  module Refinements
+    module CamelCase
+      refine Hash do
+
+        def to_camel_case(data = self)
+          case data
+          when Array
+            data.map { |value| to_camel_case(value) }
+          when Hash
+            data.map { |key, value| [camel_case_key(key), to_camel_case(value)] }.to_h
+          else
+            data
+          end
+        end
+
+        private
+
+        def camel_case_key(key)
+          case key
+          when Symbol
+            camel_case(key.to_s).to_sym
+          when String
+            camel_case(key).to_sym
+          else
+            key
+          end
+        end
+
+        def camel_case(string)
+          @__memoize_camelcase ||= {}
+          return @__memoize_camelcase[string] if @__memoize_camelcase[string]
+          @__memoize_camelcase[string] = string.gsub(/(?:_+)([a-z])/) { $1.upcase }
+          @__memoize_camelcase[string]
+        end
+
+      end
+    end
+  end
+end

data/lib/paysafe/refinements/snake_case.rb

@@ -0,0 +1,45 @@
+module Paysafe
+  module Refinements
+    module SnakeCase
+      refine Hash do
+
+        def to_snake_case(data = self)
+          case data
+          when Array
+            data.map { |value| to_snake_case(value) }
+          when Hash
+            data.map { |key, value| [underscore_key(key), to_snake_case(value)] }.to_h
+          else
+            data
+          end
+        end
+
+        private
+
+        def underscore_key(key)
+          case key
+          when Symbol
+            underscore(key.to_s).to_sym
+          when String
+            underscore(key).to_sym
+          else
+            key
+          end
+        end
+
+        def underscore(string)
+          @__memoize_underscore ||= {}
+          return @__memoize_underscore[string] if @__memoize_underscore[string]
+          @__memoize_underscore[string] =
+            string.gsub(/::/, '/')
+                  .gsub(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+                  .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                  .tr('-', '_')
+                  .downcase
+          @__memoize_underscore[string]
+        end
+
+      end
+    end
+  end
+end

data/lib/paysafe/rest/client.rb

@@ -1,11 +1,12 @@
 require 'http'
+require 'json'
 
 module Paysafe
   module REST
     class Client
 
-      API_TEST = 'https://api.test.netbanx.com'
-      API_LIVE = 'https://api.netbanx.com'
+      API_TEST = 'https://api.test.paysafe.com'
+      API_LIVE = 'https://api.paysafe.com'
 
       HEADERS = {
         'Content-Type'    => 'application/json',
@@ -14,7 +15,10 @@ module Paysafe
         'X-Ruby-Platform' => RUBY_PLATFORM
       }
 
-      attr_accessor :account_number, :api_key, :api_secret, :test_mode, :timeout_options
+      using Refinements::CamelCase
+      using Refinements::SnakeCase
+
+      attr_accessor :account_number, :api_key, :api_secret, :test_mode, :timeouts
       attr_reader :api_base
 
       # Initializes a new Client object
@@ -23,7 +27,6 @@ module Paysafe
       # @return [Paysafe::REST::Client]
       def initialize(options={})
         @test_mode = true
-        @timeout_options = { write: 2, connect: 5, read: 10 }
 
         options.each do |key, value|
           instance_variable_set("@#{key}", value)
@@ -36,11 +39,7 @@ module Paysafe
 
       # @return [Hash]
       def credentials
-        {
-          account_number: account_number,
-          api_key: api_key,
-          api_secret: api_secret
-        }
+        { api_key: api_key, api_secret: api_secret }
       end
 
       # @return [Boolean]
@@ -48,157 +47,132 @@ module Paysafe
         credentials.values.all?
       end
 
-      def create_profile(merchantCustomerId:, locale:, **args)
-        data = {
-          merchantCustomerId: merchantCustomerId,
-          locale: locale,
-          firstName: args[:firstName],
-          lastName: args[:lastName],
-          email: args[:email],
-          card: args[:card]
-        }
+      def create_single_use_token(data)
+        response = post(path: "/customervault/v1/singleusetokens", data: data.to_camel_case)
+        process_response(response, SingleUseToken)
+      end
+
+      def create_profile_from_token(data)
+        response = post(path: "/customervault/v1/profiles", data: data.to_camel_case)
+        process_response(response, Profile)
+      end
+
+      def create_profile(merchant_customer_id:, locale:, **args)
+        data = args.merge({
+          merchant_customer_id: merchant_customer_id,
+          locale: locale
+        }).to_camel_case
 
         response = post(path: "/customervault/v1/profiles", data: data)
-        response_body = symbolize_keys!(response.parse)
-        fail_or_return_response_body(response.code, response_body)
+        process_response(response, Profile)
       end
 
       def delete_profile(id:)
         response = delete(path: "/customervault/v1/profiles/#{id}")
-        fail_or_return_response_body(response.code, (response.code == 200))
+        process_response(response)
       end
 
       def get_profile(id:, fields: [])
-        fields.keep_if { |field| field == :cards || field == :addresses }
-
         path = "/customervault/v1/profiles/#{id}"
-
-        if !fields.empty?
-          path += "?fields=#{fields.join(',')}"
-        end
+        path += "?fields=#{fields.join(',')}" if !fields.empty?
 
         response = get(path: path)
-        response_body = symbolize_keys!(response.parse)
-        fail_or_return_response_body(response.code, response_body)
+        process_response(response, Profile)
       end
 
-      def update_profile(id:, merchantCustomerId:, locale:, **args)
-        data = {
-          merchantCustomerId: merchantCustomerId,
-          locale: locale,
-          firstName: args[:firstName],
-          lastName: args[:lastName],
-          email: args[:email]
-        }
+      def update_profile(id:, merchant_customer_id:, locale:, **args)
+        data = args.merge({
+          merchant_customer_id: merchant_customer_id,
+          locale: locale
+        }).to_camel_case
 
         response = put(path: "/customervault/v1/profiles/#{id}", data: data)
-        response_body = symbolize_keys!(response.parse)
-        fail_or_return_response_body(response.code, response_body)
+        process_response(response, Profile)
       end
 
       def create_address(profile_id:, country:, zip:, **args)
-        data = {
-          nickName: args[:nickName],
-          street: args[:street],
-          city: args[:city],
-          country: country,
-          state: args[:state],
-          zip: zip
-        }
-
+        data = args.merge({ country: country, zip: zip }).to_camel_case
         response = post(path: "/customervault/v1/profiles/#{profile_id}/addresses", data: data)
-        response_body = symbolize_keys!(response.parse)
-        fail_or_return_response_body(response.code, response_body)
+        process_response(response, Address)
+      end
+
+      def create_card_from_token(profile_id:, token:)
+        data = { single_use_token: token }.to_camel_case
+        response = post(path: "/customervault/v1/profiles/#{profile_id}/cards", data: data)
+        process_response(response, Card)
       end
 
       def create_card(profile_id:, number:, month:, year:, **args)
-        data = {
-          cardNum: number,
-          cardExpiry: {
+        data = args.merge({
+          card_num: number,
+          card_expiry: {
             month: month,
             year: year
-          },
-          nickName: args[:nickName],
-          holderName: args[:holderName],
-          merchantRefNum: args[:merchantRefNum],
-          billingAddressId: args[:billingAddressId],
-          defaultCardIndicator: args[:defaultCardIndicator]
-        }.reject { |key, value| value.nil? }
+          }
+        }).reject { |key, value| value.nil? }.to_camel_case
 
         response = post(path: "/customervault/v1/profiles/#{profile_id}/cards", data: data)
-        response_body = symbolize_keys!(response.parse)
-        fail_or_return_response_body(response.code, response_body)
+        process_response(response, Card)
       end
 
       def delete_card(profile_id:, id:)
         response = delete(path: "/customervault/v1/profiles/#{profile_id}/cards/#{id}")
-        response_body = symbolize_keys!(response.parse)
-        fail_or_return_response_body(response.code, response_body)
+        process_response(response)
       end
 
       def get_card(profile_id:, id:)
         response = get(path: "/customervault/v1/profiles/#{profile_id}/cards/#{id}")
-        response_body = symbolize_keys!(response.parse)
-        fail_or_return_response_body(response.code, response_body)
+        process_response(response, Card)
       end
 
       def update_card(profile_id:, id:, month:, year:, **args)
-        data = {
-          cardExpiry: {
+        data = args.merge({
+          card_expiry: {
             month: month,
             year: year
-          },
-          nickName: args[:nickName],
-          holderName: args[:holderName],
-          merchantRefNum: args[:merchantRefNum],
-          billingAddressId: args[:billingAddressId],
-          defaultCardIndicator: args[:defaultCardIndicator]
-        }.reject { |key, value| value.nil? }
+          }
+        }).reject { |key, value| value.nil? }.to_camel_case
 
         response = put(path: "/customervault/v1/profiles/#{profile_id}/cards/#{id}", data: data)
-        response_body = symbolize_keys!(response.parse)
-        fail_or_return_response_body(response.code, response_body)
+        process_response(response, Card)
       end
 
-      def purchase(amount:, token:, merchantRefNum:, **args)
+      def purchase(amount:, token:, merchant_ref_num:, **args)
         data = {
           amount: amount,
-          merchantRefNum: merchantRefNum,
-          settleWithAuth: true,
+          merchant_ref_num: merchant_ref_num,
+          settle_with_auth: true,
           card: {
-            paymentToken: token
+            payment_token: token
           }
-        }
+        }.to_camel_case
 
         response = post(path: "/cardpayments/v1/accounts/#{account_number}/auths", data: data)
-        response_body = symbolize_keys!(response.parse)
-        fail_or_return_response_body(response.code, response_body)
+        process_response(response, Authorization)
       end
 
-      def verify_card(merchantRefNum:, number:, month:, year:, **args)
-        data = {
-          merchantRefNum: merchantRefNum,
+      def create_verification_from_token(merchant_ref_num:, token:)
+        data = { merchant_ref_num: merchant_ref_num, card: { payment_token: token } }.to_camel_case
+        response = post(path: "/cardpayments/v1/accounts/#{account_number}/verifications", data: data)
+        process_response(response, Verification)
+      end
+
+      def verify_card(merchant_ref_num:, number:, month:, year:, cvv:, address:, **args)
+        data = args.merge({
+          merchant_ref_num: merchant_ref_num,
+          billing_details: address,
           card: {
-            cardNum: number,
-            cardExpiry: {
+            card_num: number,
+            cvv: cvv,
+            card_expiry: {
               month: month,
               year: year
-            },
-            cvv: args[:cvv]
-          },
-          profile: {
-            firstName: args[:firstName],
-            lastName: args[:lastName],
-            email: args[:email]
-          },
-          billingDetails: args[:address],
-          customerIp: args[:customerIp],
-          description: args[:description]
-        }
+            }
+          }
+        }).to_camel_case
 
         response = post(path: "/cardpayments/v1/accounts/#{account_number}/verifications", data: data)
-        response_body = symbolize_keys!(response.parse)
-        fail_or_return_response_body(response.code, response_body)
+        process_response(response, Verification)
       end
 
       private
@@ -206,7 +180,7 @@ module Paysafe
       def http_client
         HTTP
           .headers(HEADERS)
-          .timeout(@timeout_options)
+          .timeout(@timeouts ? @timeouts : :null)
           .basic_auth(user: @api_key, pass: @api_secret)
       end
 
@@ -226,25 +200,20 @@ module Paysafe
         http_client.put("#{api_base}#{path}", json: data)
       end
 
-      def symbolize_keys!(object)
-        if object.is_a?(Array)
-          object.each_with_index do |val, index|
-            object[index] = symbolize_keys!(val)
-          end
-        elsif object.is_a?(Hash)
-          object.keys.each do |key|
-            object[key.to_sym] = symbolize_keys!(object.delete(key))
-          end
+      def process_response(response, klass=nil)
+        data = parse_response_body(response.to_s)
+
+        if response.status.success?
+          klass&.new(data)
+        else
+          fail Error.from_response(data, response.code)
         end
-        object
       end
 
-      def fail_or_return_response_body(code, body)
-        if code < 200 || code >= 206
-          error = Paysafe::Error.error_from_response(body, code)
-          fail(error)
-        end
-        body
+      def parse_response_body(body)
+        return nil if body.strip.empty?
+        JSON.parse(body, symbolize_names: true)&.to_snake_case
+      rescue JSON::ParserError
       end
 
     end

data/lib/paysafe/result.rb

@@ -0,0 +1,86 @@
+module Paysafe
+  class Result
+
+    class << self
+      # Define methods that retrieve the value from attributes
+      #
+      # @param attrs [Array, Symbol]
+      def attributes(*attrs)
+        attrs.each do |attr|
+          define_attribute_method(attr)
+          define_predicate_method(attr)
+        end
+      end
+
+      # Define object methods from attributes
+      #
+      # @param klass [Symbol]
+      # @param key1 [Symbol]
+      def object_attribute(klass, key1)
+        define_attribute_method(key1, klass)
+        define_predicate_method(key1)
+      end
+
+      # Dynamically define a method for an attribute
+      #
+      # @param key1 [Symbol]
+      # @param klass [Symbol]
+      def define_attribute_method(key1, klass = nil)
+        define_method(key1) do
+          if instance_variable_defined?("@#{key1}")
+            return instance_variable_get("@#{key1}")
+          end
+          instance_variable_set("@#{key1}", get_value_by(key1, klass))
+        end
+      end
+
+      # Dynamically define a predicate method for an attribute
+      #
+      # @param key1 [Symbol]
+      # @param key2 [Symbol]
+      def define_predicate_method(key1, key2 = key1)
+        define_method(:"#{key1}?") do
+          !attr_falsey_or_empty?(key2)
+        end
+      end
+    end
+
+    # Initializes a new object
+    #
+    # @param attributes [Hash]
+    # @return [Paysafe::Result]
+    def initialize(attributes={})
+      @attributes = attributes || {}
+    end
+
+    # @return [Hash]
+    attr_reader :attributes
+
+    # @return [Boolean]
+    def empty?
+      @attributes.empty?
+    end
+
+    private
+
+    def attr_falsey_or_empty?(key)
+      !@attributes[key] || @attributes[key].respond_to?(:empty?) && @attributes[key].empty?
+    end
+
+    def get_value_by(key, klass = nil)
+      return @attributes[key] if klass.nil?
+
+      case @attributes[key]
+      when Hash
+        Paysafe.const_get(klass).new(@attributes[key])
+      when Array
+        @attributes[key].map do |value|
+          Paysafe.const_get(klass).new(value)
+        end
+      else
+        @attributes[key]
+      end
+    end
+
+  end
+end

data/lib/paysafe/single_use_token.rb

@@ -0,0 +1,10 @@
+require 'paysafe/result'
+
+module Paysafe
+  class SingleUseToken < Result
+    attributes :id, :payment_token, :time_to_live_seconds
+
+    object_attribute :Card, :card
+    object_attribute :Address, :billing_address
+  end
+end

data/lib/paysafe/verification.rb

@@ -0,0 +1,13 @@
+require 'paysafe/result'
+
+module Paysafe
+  class Verification < Result
+    attributes :id, :merchant_ref_num, :child_account_num,
+      :auth_code, :customer_ip, :dup_check, :description, :txn_time,
+      :currency_code, :avs_response, :cvv_verification, :status
+
+    object_attribute :Profile, :profile
+    object_attribute :Card, :card
+    object_attribute :Address, :billing_details
+  end
+end

data/lib/paysafe/version.rb

@@ -1,3 +1,3 @@
 module Paysafe
-  VERSION = "0.6.2"
+  VERSION = "0.9.0"
 end

data/lib/paysafe.rb

@@ -1,3 +1,13 @@
 require "paysafe/version"
 require "paysafe/error"
+require "paysafe/single_use_token"
+require "paysafe/profile"
+require "paysafe/birth_date"
+require "paysafe/address"
+require "paysafe/card"
+require "paysafe/card_expiry"
+require "paysafe/verification"
+require "paysafe/authorization"
+require "paysafe/refinements/camel_case"
+require "paysafe/refinements/snake_case"
 require "paysafe/rest/client"

data/paysafe.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Javier Julio"]
   spec.email         = ["jjfutbol@gmail.com"]
 
-  spec.summary       = %q{Gem to wrap Paysafe REST API}
-  spec.description   = %q{Gem to wrap Paysafe REST API}
+  spec.summary       = "A Ruby interface to the Paysafe REST API."
+  spec.description   = "A Ruby interface to the Paysafe REST API."
   spec.homepage      = "https://github.com/javierjulio/paysafe"
   spec.license       = "MIT"
 
@@ -19,6 +19,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 2.3.0'
+
+  spec.add_dependency "http", '~> 2.0'
+
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "dotenv"
@@ -27,6 +31,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "vcr"
   spec.add_development_dependency "webmock"
 
-  spec.add_dependency "http", '~> 2.0'
-
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: paysafe
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.9.0
 platform: ruby
 authors:
 - Javier Julio
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-25 00:00:00.000000000 Z
+date: 2017-04-19 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: http
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -108,21 +122,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: http
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-description: Gem to wrap Paysafe REST API
+description: A Ruby interface to the Paysafe REST API.
 email:
 - jjfutbol@gmail.com
 executables: []
@@ -132,6 +132,7 @@ files:
 - ".env.sample"
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -140,8 +141,19 @@ files:
 - bin/console
 - bin/setup
 - lib/paysafe.rb
+- lib/paysafe/address.rb
+- lib/paysafe/authorization.rb
+- lib/paysafe/birth_date.rb
+- lib/paysafe/card.rb
+- lib/paysafe/card_expiry.rb
 - lib/paysafe/error.rb
+- lib/paysafe/profile.rb
+- lib/paysafe/refinements/camel_case.rb
+- lib/paysafe/refinements/snake_case.rb
 - lib/paysafe/rest/client.rb
+- lib/paysafe/result.rb
+- lib/paysafe/single_use_token.rb
+- lib/paysafe/verification.rb
 - lib/paysafe/version.rb
 - paysafe.gemspec
 homepage: https://github.com/javierjulio/paysafe
@@ -156,7 +168,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -164,8 +176,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.0
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: Gem to wrap Paysafe REST API
+summary: A Ruby interface to the Paysafe REST API.
 test_files: []