spook_and_pay 0.2.0.alpha → 0.2.1.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 91f5461e5cc5382b312c2e0d9c7a1ddf576a14e2
-  data.tar.gz: 78f8ef0364586a4f8d22283b8ccbf79925068d66
+  metadata.gz: 34eb9c68d6931c91d5d0be37818b988f83d395e4
+  data.tar.gz: a68f338050ffb6aa11c063c2d1b787361b9f6410
 SHA512:
-  metadata.gz: 6061677abfdec2995ad03ef6de15d48308f2685f2cd91cbfff58f4a7fc19ef04a2a1adbf626efa3df1af88d951855661af4f49a24d634d21102965376ea479ea
-  data.tar.gz: 4b34cc7037809402145583ee019751230ebd3b4bbe04903d9794486c92530236a80a9d2e95c2318c44cdbaad565dd4b5b7e7da1ff56633c2ae8cc2e22d961fb9
+  metadata.gz: f4fb560546d25e2ea6a2922a242465ba2b4cdcc38e57f6c34d6b577f4563c8a2a355ba57a4b605ba5ad6fc02f6e9d9a63197038148b6f50f8c57a048e2e139d6
+  data.tar.gz: 862c7cf15b3399fd43feda4618c99de2bd7dabb25c6cadcbf4c1c36837eb0c604c142ff722ba3bf8e01663add6e0512d80abd3677cbfc596359fd68961102a03

data/lib/spook_and_pay/providers/base.rb

@@ -151,7 +151,7 @@ module SpookAndPay
       # provided by a CreditCard instance.
       #
       # @param [SpookAndPay::CreditCard, String] id
-      # @param [String, Numeric] amount
+      # @param [String, Numeric] amount in dollars
       # @return SpookAndPay::Result
       # @api private
       # @abstract Subclass to implement
@@ -188,6 +188,18 @@ module SpookAndPay
 
       private
 
+      # Extracts the credit card id from it's argument. This is is to help with
+      # methods that accept either a card instance of an id.
+      #
+      # @param [SpookAndPay::CreditCard, String]
+      # @return String
+      def credit_card_id(id)
+        case id
+        when SpookAndPay::CreditCard then id.id
+        else id
+        end
+      end
+
       # Extracts a transaction ID from it's target.
       #
       # @param [SpookAndPay::Transaction, String]

data/lib/spook_and_pay/providers/braintree.rb

@@ -33,15 +33,15 @@ module SpookAndPay
       # Because Braintree accepts payment details and processes payment in a 
       # single step, this method must also be provided with an amount.
       #
-      # @param [:purchase, :authorize] type
       # @param String redirect_url
-      # @param [String, Numeric] amount
       # @param Hash opts
       # @option opts [true, false] :vault
+      # @option opts [:purchase, :authorize] :type
+      # @option opts [String, Numeric] :amount
       # @return Hash
-      def prepare_payment_submission(type, redirect_url, amount, opts = {})
+      def prepare_payment_submission(redirect_url, opts = {})
         payload = {
-          :transaction  => {:type => 'sale', :amount => amount},
+          :transaction  => {:type => 'sale', :amount => opts[:amount]},
           :redirect_url => redirect_url
         }
 
@@ -49,7 +49,7 @@ module SpookAndPay
           (payload[:transaction][:options] ||= {})[:store_in_vault] = true
         end
 
-        if type == :purchase
+        if opts[:type] == :purchase
           (payload[:transaction][:options] ||= {})[:submit_for_settlement] = true
         end
 
@@ -128,13 +128,13 @@ module SpookAndPay
       # second is the type of error and the third is the field — if any — it 
       # applies to.
       ERROR_CODE_MAPPING = {
-        "81715" => [:credit_card, :invalid_number, :number],
-        "81725" => [:credit_card, :number_required, :number],
+        "81715" => [:credit_card, :invalid, :number],
+        "81725" => [:credit_card, :required, :number],
         "81703" => [:credit_card, :type_not_accepted, :card_type],
-        "81716" => [:credit_card, :wrong_length, :number],
-        "81712" => [:credit_card, :invalid_expiration_month, :expiration_month],
-        "81713" => [:credit_card, :invalid_expiration_year, :expiration_year],
-        "81707" => [:credit_card, :invalid_cvv, :cvv],
+        "81716" => [:credit_card, :too_short, :number],
+        "81712" => [:credit_card, :invalid, :expiration_month],
+        "81713" => [:credit_card, :invalid, :expiration_year],
+        "81707" => [:credit_card, :invalid, :cvv],
         "91507" => [:transaction, :cannot_capture, :status],
         "91506" => [:transaction, :cannot_refund, :status],
         "91504" => [:transaction, :cannot_void, :status]

data/lib/spook_and_pay/providers/spreedly.rb

@@ -0,0 +1,237 @@
+module SpookAndPay
+  module Providers
+    class Spreedly < Base
+      # The map of generic field names to what is specifically required by
+      # Spreedly.
+      FORM_FIELD_NAMES = {
+        :name             => "credit_card[full_name]",
+        :number           => "credit_card[number]",
+        :expiration_month => "credit_card[month]",
+        :expiration_year  => "credit_card[year]",
+        :cvv              => "credit_card[verification_value]"
+      }.freeze
+
+      # The which refers to a specific gateway. 
+      #
+      # @attr_reader String
+      attr_reader :gateway_token
+
+      # An instance of the spreedly spreedly.
+      #
+      # @attr_reader Spreedly::Environment
+      attr_reader :spreedly
+
+      # Generate a new instance of the Spreedly provider.
+      #
+      # @param Hash config
+      # @option config String :environment_key
+      # @option config String :access_secret
+      # @option config String :gateway_token
+      def initialize(env, config)
+        @gateway_token = config[:gateway_token]
+        @spreedly = ::Spreedly::Environment.new(config[:environment_key], config[:access_secret])
+
+        super(env, config)
+      end
+
+      # @param String redirect_url
+      # @param Hash opts
+      # @return Hash
+      def prepare_payment_submission(redirect_url, opts = {})
+        {
+          :url            => spreedly.transparent_redirect_form_action,
+          :field_names    => self.class::FORM_FIELD_NAMES,
+          :hidden_fields  => {:redirect_url => redirect_url, :environment_key => spreedly.key}
+        }
+      end
+
+      # Confirms the submission of payment details to Spreedly Core.
+      #
+      # @param String query_string
+      # @return SpookAndPay::Result
+      def confirm_payment_submission(query_string)
+        token = Rack::Utils.parse_nested_query(query_string)["token"]
+        credit_card = spreedly.find_payment_method(token)
+
+        if credit_card.valid?
+          SpookAndPay::Result.new(
+            true, 
+            credit_card, 
+            :credit_card => coerce_credit_card(credit_card)
+          )
+        else
+          SpookAndPay::Result.new(
+            false, 
+            credit_card, 
+            :credit_card => coerce_credit_card(credit_card),
+            :errors => extract_card_errors(credit_card)
+          )
+        end
+      end
+
+      def credit_card(id)
+        result = spreedly.find_payment_method(id)
+        coerce_credit_card(result)
+      end
+
+      def credit_card_from_transaction(id)
+        result = spreedly.find_transaction(transaction_id(id))
+        coerce_credit_card(result.payment_method)
+      end
+
+      def transaction(id)
+        result = spreedly.find_transaction(id)
+        coerce_transaction(result)
+      end
+
+      def capture_transaction(id)
+        result = spreedly.capture_transaction(transaction_id(id))
+        coerce_result(result)
+      end
+
+      def refund_transaction(id)
+        result = spreedly.refund_transaction(transaction_id(id))
+        coerce_result(result)
+      end
+
+      def void_transaction(id)
+        result = spreedly.void_transaction(transaction_id(id))
+        coerce_result(result)
+      end
+
+      def authorize_via_credit_card(id, amount)
+        result = spreedly.authorize_on_gateway(gateway_token, credit_card_id(id), amount.to_f * 100)
+        coerce_result(result)
+      end
+
+      def purchase_via_credit_card(id, amount)
+        result = spreedly.purchase_on_gateway(gateway_token, credit_card_id(id), amount.to_f * 100)
+        coerce_result(result)
+      end
+
+      def delete_credit_card(id)
+        result = spreedly.redact_payment_method(credit_card_id(id))
+        coerce_result(result)
+      end
+
+      private
+
+      # Takes the result of running a transaction against a Spreedly gateway
+      # and coerces it into a SpookAndPay::Result
+      #
+      # @param Spreedly::Transaction result
+      # @return SpookAndPay::Result
+      def coerce_result(result)
+        opts = {
+          :transaction  => coerce_transaction(result),
+          :errors       => extract_transaction_errors(result)
+        }
+
+        if result.respond_to?(:payment_method)
+          opts[:card] = coerce_credit_card(result.payment_method)
+        end
+
+        SpookAndPay::Result.new(result.succeeded, result, opts)
+      end
+
+      # A mapping from the names used by Spreedly to the names SpookAndPay uses
+      # internally.
+      CARD_FIELDS = {
+        "full_name" => :name, 
+        "number" => :number,
+        "year" => :expiration_year,
+        "month" => :expiration_month,
+        "verification_value" => :cvv
+      }.freeze
+
+      # Maps the error types from Spreedly's to the names used internally.
+      ERRORS = {
+        "errors.invalid" => :invalid,
+        "errors.blank" => :blank,
+        "errors.expired" => :expired
+      }.freeze
+
+      # Extracts/coerces errors from a Spreedly response into SubmissionError
+      # instances.
+      #
+      # @param Spreedly::CreditCard result
+      # @return Array<SpookAndPay::SubmissionError>
+      # @todo If the Spreedly API behaves later, the check for first/last 
+      #       name might not be needed anymore.
+      def extract_card_errors(result)
+        # This gnarly bit of code transforms errors on the first_name or 
+        # last_name attributes into an error on full_name. This is because
+        # Spreedly accepts input for full_name, but propogates errors to the 
+        # separate attributes.
+        errors = result.errors.map do |e|
+          case e[:attribute]
+          when 'first_name' then e.merge(:attribute => "full_name")
+          when 'last_name' then nil
+          else e
+          end
+        end.compact
+
+        errors.map do |e|
+          name = CARD_FIELDS[e[:attribute]]
+          error = ERRORS[e[:key]]
+
+          if name and error
+            SubmissionError.new(:credit_card, error, name, e)
+          else
+            SubmissionError.new(:unknown, :unknown, :unknown, e)
+          end
+        end
+      end
+
+      # Extracts/coerces errors from a Spreedly transaction into 
+      # SubmissionError instances.
+      #
+      # @param Spreedly::Transaction result
+      # @return Array<SpookAndPay::SubmissionError>
+      def extract_transaction_errors(result)
+        []
+      end
+
+      # Takes the response generated by the Spreedly lib and coerces it into a
+      # SpookAndPay::CreditCard
+      #
+      # @param Spreedly::CreditCard
+      # @return SpookAndPay::CreditCard
+      def coerce_credit_card(card)
+        fields = {
+          :card_type        => card.card_type,
+          :number           => card.number,
+          :name             => card.full_name,
+          :expiration_month => card.month,
+          :expiration_year  => card.year
+        }
+
+        SpookAndPay::CreditCard.new(self, card.token, fields)
+      end
+
+      # Takes a transaction generated by the Spreedly lib and coerces it into a
+      # SpookAndPay::Transaction
+      #
+      # @param Spreedly::Transaction transaction
+      # @return SpookAndPay::Transaction
+      # @todo extract created_at and status from the transaction.response
+      def coerce_transaction(transaction)
+        fields = {}
+
+        fields[:type], status = case transaction
+        when ::Spreedly::Authorization  then [:authorize, :authorized]
+        when ::Spreedly::Purchase       then [:purchase, :settled]
+        when ::Spreedly::Capture        then [:capture, :settled]
+        when ::Spreedly::Refund         then [:credit, :refunded]
+        when ::Spreedly::Void           then [:void, :voided]
+        end
+
+        if transaction.respond_to?(:amount)
+          fields[:amount] = transaction.amount
+        end
+
+        SpookAndPay::Transaction.new(self, transaction.token, status, transaction, fields)
+      end
+    end
+  end
+end

data/lib/spook_and_pay/providers.rb

@@ -1,2 +1,3 @@
 require 'spook_and_pay/providers/base'
 require 'spook_and_pay/providers/braintree'
+require 'spook_and_pay/providers/spreedly'

data/lib/spook_and_pay/result.rb

@@ -43,6 +43,7 @@ module SpookAndPay
     # 
     # @param Symbol target
     # @return Hash
+    # @return Hash<Symbol, Array<SpookAndPay::SubmissionError>>
     def errors_for(target)
       errors.select{|e| e.target == target}.reduce({}) do |h, e|
         h[e.field] ||= []
@@ -51,6 +52,15 @@ module SpookAndPay
       end
     end
 
+    # Returns the errors for a specific target and field.
+    #
+    # @param Symbol target
+    # @param Symbol field
+    # @return Array<SpookAndPay::SubmissionError>
+    def errors_for_field(target, field)
+      errors.select {|e| e.target == target and e.field == field}
+    end
+
     # A nice alias for checking for success.
     #
     # @return [true, false]

data/lib/spook_and_pay/submission_error.rb

@@ -14,12 +14,14 @@ module SpookAndPay
     ERROR_MESSAGES = {
       :credit_card => {
         :number_required          => "number is required",
-        :invalid_number           => "number is invalid",
+        :number_invalid           => "number is invalid",
+        :number_too_short         => "number must be between 12 and 19 digits",
         :type_not_accepted        => "card type is not accepted by this merchant",
-        :wrong_length             => "number must be between 12 and 19 digits",
-        :invalid_expiration_month => "expiration month is invalid",
-        :invalid_expiration_year  => "expiration year is invalid",
-        :invalid_cvv              => "CVV must be three digits"
+        :expiration_month_invalid => "expiration month is invalid",
+        :expiration_month_expired => "expiration month has expired",
+        :expiration_year_invalid  => "expiration year is invalid",
+        :expiration_year_expired  => "expiration year has expired",
+        :cvv_invalid              => "CVV must be three digits"
       },
       :transaction => {
         :cannot_capture => "must be authorized in order to capture funds",
@@ -37,8 +39,8 @@ module SpookAndPay
     # Generates a new error. Based on the target and error type, it can
     # generate the appropriate error messages or otherwise fall back.
     #
-    # @param Symbol error_type
     # @param Symbol target
+    # @param Symbol error_type
     # @param [Symbol, nil] field
     # @param Class raw
     def initialize(target, error_type, field, raw)
@@ -60,7 +62,7 @@ module SpookAndPay
     #
     # @return String
     def message
-      ERROR_MESSAGES[target][error_type]
+      ERROR_MESSAGES[target][error_type] || ERROR_MESSAGES[target][:"#{field}_#{error_type}"]
     end
   end
 end

data/lib/spook_and_pay.rb

@@ -8,6 +8,8 @@ require 'openssl'
 require 'net/http'
 
 require 'braintree'
+require 'spreedly'
+require 'rack/utils'
 
 require 'spook_and_pay/submission_error'
 require 'spook_and_pay/missing_value_error'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spook_and_pay
 version: !ruby/object:Gem::Version
-  version: 0.2.0.alpha
+  version: 0.2.1.alpha
 platform: ruby
 authors:
 - Luke Sutton
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-26 00:00:00.000000000 Z
+date: 2013-11-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: braintree
@@ -26,47 +26,61 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.25.0
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: spreedly
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.14.1
-  type: :development
+        version: 2.0.6
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.14.1
+        version: 2.0.6
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 2.14.1
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: httparty
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.5.2
+        version: 0.11.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.5.2
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: debugger
   requirement: !ruby/object:Gem::Requirement
@@ -95,6 +109,7 @@ files:
 - lib/spook_and_pay/missing_value_error.rb
 - lib/spook_and_pay/providers/base.rb
 - lib/spook_and_pay/providers/braintree.rb
+- lib/spook_and_pay/providers/spreedly.rb
 - lib/spook_and_pay/providers.rb
 - lib/spook_and_pay/result.rb
 - lib/spook_and_pay/submission_error.rb