flowcommerce-activemerchant 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d29bf5f67b0955bc68f14c89e83523e0ab89c007
-  data.tar.gz: 25b73be18f38b4c1f86a6c5c8af51415b037c7b3
+  metadata.gz: 6a5a5d4dbb7606be2ac9f63c228fd94ed0423f0c
+  data.tar.gz: eb6da18efdf964e1ee6bdf5dbc37851515bc8013
 SHA512:
-  metadata.gz: 70cb88748bdfc1393182c9e82c6e9c54a89a6281c48d4caf7420bcd5633ce447032b57beb9744c0d6b367ea070d8bb8633e1c3c23151ca910db7ab60c016a1a5
-  data.tar.gz: 62ca15c0557d47f791f63cd00d9b7612684ce4aeac230b9f8620fb8324e8313a42c7e78bbaf80da698cf17c932fb5ded4208af4278fd02e34f0dde2caaf1db3b
+  metadata.gz: 52f6e5e19df430125645ebab00069d664e4d296302ed068b5ba250c55b59764f80767c761e41842737ded97ba0ce0f66913fe5c7948ab31316ec5043b734bca5
+  data.tar.gz: 3336fde40352290d319c85c31663343cd87b242ea3666e6a5164cbe84b6078fc15d0216a2dbe6d223cc08621cfa4beed8fe31655d5bfc6a8b09340501e26bcc6

data/lib/active_merchant/billing/gateways/flow.rb

@@ -6,7 +6,7 @@ require 'flow-reference'
 module ActiveMerchant
   module Billing
     class FlowGateway < Gateway
-      VERSION = '0.0.6' unless defined?(::ActiveMerchant::Billing::FlowGateway::VERSION)
+      VERSION = '0.0.7' unless defined?(::ActiveMerchant::Billing::FlowGateway::VERSION)
 
       self.display_name        = 'Flow.io Pay'
       self.homepage_url        = 'https://www.flow.io/'
@@ -14,7 +14,7 @@ module ActiveMerchant
       self.supported_countries = Flow::Reference::Countries::ISO_3166_2
       self.supported_cardtypes = Flow::Reference::PaymentMethods::SUPPORTED_CREDIT_CARDS
 
-      def initialize(options = {})
+      def initialize options = {}
         @flow_api_key      = options[:api_key]      || ENV['FLOW_API_KEY']
         @flow_organization = options[:organization] || ENV['FLOW_ORGANIZATION']
 
@@ -25,13 +25,13 @@ module ActiveMerchant
       end
 
       # https://docs.flow.io/module/payment/resource/authorizations#post-organization-authorizations
-      def authorize(amount, payment_method, options={})
-        amount = assert_currency(options[:currency], amount)
+      def authorize amount, payment_method, options={}
+        amount = assert_currency options[:currency], amount
 
-        get_flow_cc_token payment_method
+        response = get_flow_cc_token payment_method
 
         data = {
-          token:    @flow_cc_token,
+          token:    response.token,
           amount:   amount,
           currency: options[:currency],
           cvv:      payment_method.verification_value,
@@ -47,59 +47,59 @@ module ActiveMerchant
           authorization_form = if options[:order_id]
             # order_number allready present at flow
             data[:order_number] = options[:order_id]
-            ::Io::Flow::V0::Models::MerchantOfRecordAuthorizationForm.new(data)
+            ::Io::Flow::V0::Models::MerchantOfRecordAuthorizationForm.new data
           else
-            ::Io::Flow::V0::Models::DirectAuthorizationForm.new(data)
+            ::Io::Flow::V0::Models::DirectAuthorizationForm.new data
           end
-          response = flow_instance.authorizations.post(@flow_organization, authorization_form)
+          response = flow_instance.authorizations.post @flow_organization, authorization_form
         rescue => exception
-          return Response.new(false, exception.message, { exception: exception })
+          return Response.new false, exception.message, { exception: exception }
         end
 
         options = { response: response }
 
         if response.result.status.value == 'authorized'
-          store = {}
-          store[:authorization_id] = response.id
-          store[:currency]         = response.currency
-          store[:amount]           = response.amount
-          store[:key]              = response.key
+          store = {      key: response.key,
+                      amount: response.amount,
+                    currency: response.currency,
+            authorization_id: response.id
+          }
 
-          Response.new(true, 'Flow authorize - Success', options, { authorization: store })
+          Response.new true, 'Flow authorize - Success', options, { authorization: store }
         else
-          Response.new(false, 'Flow authorize - Error', options)
+          Response.new false, 'Flow authorize - Error', options
         end
       end
 
       # https://docs.flow.io/module/payment/resource/captures#post-organization-captures
-      def capture(_money, authorization, options={})
+      def capture _money, authorization, options={}
         raise ArgumentError, 'No Authorization authorization, please authorize first' unless authorization
 
         begin
-          capture_form = ::Io::Flow::V0::Models::CaptureForm.new(authorization)
-          response     = flow_instance.captures.post(@flow_organization, capture_form)
+          capture_form = ::Io::Flow::V0::Models::CaptureForm.new authorization
+          response     = flow_instance.captures.post @flow_organization, capture_form
         rescue => exception
-          error_response(exception)
+          error_response exception
         end
 
         options = { response: response }
 
         if response.id
-          Response.new(true, 'Flow capture - Success', options)
+          Response.new true, 'Flow capture - Success', options
         else
-          Response.new(false, 'Flow capture - Error', options)
+          Response.new false, 'Flow capture - Error', options
         end
       end
 
-      def purchase(money, credit_card, options={})
+      def purchase money, credit_card, options={}
         response = authorize money, credit_card, options
         capture money, response.authorization
       end
 
       # https://docs.flow.io/module/payment/resource/authorizations#delete-organization-authorizations-key
-      def void(money, authorization_key, options={})
-        response = flow_instance.authorizations.delete_by_key(@flow_organization, authorization_key)
-        Response.new(true, 'void success', { response: response })
+      def void money, authorization_key, options={}
+        response = flow_instance.authorizations.delete_by_key @flow_organization, authorization_key
+        Response.new true, 'void success', { response: response }
       rescue Io::Flow::V0::HttpClient::ServerError => exception
         error_response(exception)
       end
@@ -112,7 +112,7 @@ module ActiveMerchant
       # amount           - The amount to refund, in the currency of the associated capture. Defaults to the value of the capture minus any prior refunds.
       # currency         - The ISO 4217-3 code for the currency. Required if amount is specified. Case insensitive. Note you will get an error if the currency does not match the related authrization's currency. See https://api.flow.io/reference/currencies
       # rma_key          - The RMA key, if available. If specified, this will udpate the RMA status as refunded.
-      def refund(amount, capture_id, options={})
+      def refund amount, capture_id, options={}
         refund_form = {}
         refund_form[:amount]     = amount if amount
         refund_form[:capture_id] = capture_id if capture_id
@@ -123,44 +123,40 @@ module ActiveMerchant
 
         if refund_form[:amount]
           raise ArgumentError, 'Currency is required if amount is provided' unless refund_form[:currency]
-          refund_form[:amount] = assert_currency(refund_form[:currency], refund_form[:amount])
+          refund_form[:amount] = assert_currency refund_form[:currency], refund_form[:amount]
         end
 
-        refund_form = ::Io::Flow::V0::Models::RefundForm.new(refund_form)
-        flow_instance.refunds.post(@flow_organization, refund_form)
+        refund_form = ::Io::Flow::V0::Models::RefundForm.new refund_form
+        flow_instance.refunds.post @flow_organization, refund_form
       end
 
       # store credit card with flow and get reference token
-      def store(credit_card, options={})
-        token = get_flow_cc_token(credit_card)
-        Response.new(true, 'Credit card stored', { token: token })
+      def store credit_card, options={}
+        response = get_flow_cc_token credit_card
+        Response.new true, 'Credit card stored', { response: response, token: response.token }
       rescue Io::Flow::V0::HttpClient::ServerError => exception
-        error_response(exception)
+        error_response exception
       end
 
       private
 
       def flow_instance
-        FlowCommerce.instance(token: @flow_api_key)
+        FlowCommerce.instance token: @flow_api_key
       end
 
-      def get_flow_cc_token(credit_card)
-        return if @flow_cc_token
-
-        data = {}
-        data[:number]           = credit_card.number
-        data[:name]             = '%s %s' % [credit_card.first_name, credit_card.last_name]
-        data[:cvv]              = credit_card.verification_value
-        data[:expiration_year]  = credit_card.year.to_i
-        data[:expiration_month] = credit_card.month.to_i
-
-        card_form = ::Io::Flow::V0::Models::CardForm.new(data)
-        result    = flow_instance.cards.post(@flow_organization, card_form)
+      def get_flow_cc_token credit_card
+        data = {    number: credit_card.number,
+                      name: '%s %s' % [credit_card.first_name, credit_card.last_name],
+                       cvv: credit_card.verification_value,
+           expiration_year: credit_card.year.to_i,
+          expiration_month: credit_card.month.to_i
+        }
 
-        @flow_cc_token = result.token
+        card_form = ::Io::Flow::V0::Models::CardForm.new data
+        flow_instance.cards.post @flow_organization, card_form
       end
 
-      def error_response(exception_object)
+      def error_response exception_object
         message = if exception_object.respond_to?(:body) && exception_object.body.length > 0
           description  = JSON.load(exception_object.body)['messages'].to_sentence
           '%s: %s (%s)' % [exception_object.details, description, exception_object.code]
@@ -168,12 +164,12 @@ module ActiveMerchant
           exception_object.message
         end
 
-        Response.new(false, message, exception: exception_object)
+        Response.new false, message, exception: exception_object
       end
 
-      def assert_currency(currency, amount)
+      def assert_currency currency, amount
         raise ArgumentError, 'currency not provided' unless currency
-        currency_model = Flow::Reference::Currencies.find!(currency)
+        currency_model = Flow::Reference::Currencies.find! currency
         currency_model.to_cents(amount).to_f
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flowcommerce-activemerchant
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Dino Reic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-26 00:00:00.000000000 Z
+date: 2017-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemerchant