flowcommerce-activemerchant 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3cf3aa9eacfd0f8e012d25a368434cfdeeadcaba
-  data.tar.gz: 274d8b6630325f87041bc7f3e5d7064fabb3b5f5
+  metadata.gz: fd3cd7c71165eb856d2df8a62f381c4a345216c2
+  data.tar.gz: 2da46342bd287ac1400862e00ab21d61d43b62e7
 SHA512:
-  metadata.gz: d0c0387ad80950fce612a269ae46430f1aa11397e06c96875caac884c307e1d7b2c624979ec8813fb0fc29c866e93af5b710e4888da787b82a44d834231e21be
-  data.tar.gz: 0d5d2f2168cbd65124df94c6aa3378df21364b2ce2ba5a6cf5fbc020c29107684ed189016f6d5b07e45f0f00100ed4fb90e8f4faf383ea53f386a72b1121c3bc
+  metadata.gz: 3531b26248d5a5015dc02786d73176b7e80b1e7ebac09a786a8ff4198fb22f0f478eb61080b643e8c38d16d794a3fd66cacc44477bb1775504731fa913cd7429
+  data.tar.gz: b9c3740fc926e3060403e9adfd64610d45a2534bf1d4ca0fcf19fa833a45fce930a8e8d2af43a477ee7a34dcb2296e823392949700bfee6c75b0f4936b10badc

data/.version

@@ -0,0 +1 @@
+0.1.4

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 - 2018 Flow Commerce Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -1,4 +1,4 @@
-# @Flow.io (2017)
+  # @Flow.io (2017)
 # Active Merchant adapter for Flow api
 
 require 'flowcommerce-reference'
@@ -6,7 +6,15 @@ require 'flowcommerce-reference'
 module ActiveMerchant
   module Billing
     class FlowGateway < Gateway
-      VERSION = '0.1.3' unless defined?(::ActiveMerchant::Billing::FlowGateway::VERSION)
+      unless defined?(::ActiveMerchant::Billing::FlowGateway::VERSION)
+        VERSION = File.read(File.expand_path("../../../../.version", File.dirname(__FILE__))).chomp
+
+        FORM_TYPES = [
+          :authorization_copy_form, :direct_authorization_form, :merchant_of_record_authorization_form,
+          :paypal_authorization_form, :redirect_authorization_form, :inline_authorization_form,
+          :card_authorization_form, :ach_authorization_form
+        ]
+      end
 
       self.display_name        = 'Flow.io Pay'
       self.homepage_url        = 'https://www.flow.io/'
@@ -14,6 +22,7 @@ module ActiveMerchant
       self.supported_countries = FlowCommerce::Reference::Countries::ISO_3166_2
       self.supported_cardtypes = FlowCommerce::Reference::PaymentMethods::SUPPORTED_CREDIT_CARDS
 
+
       def initialize options = {}
         @flow_api_key      = options[:api_key]      || ENV['FLOW_API_KEY']
         @flow_organization = options[:organization] || ENV['FLOW_ORGANIZATION']
@@ -24,153 +33,194 @@ module ActiveMerchant
         super
       end
 
+      # Create a new authorization.
       # https://docs.flow.io/module/payment/resource/authorizations#post-organization-authorizations
-      def authorize amount, payment_method, options={}
-        amount = assert_currency options[:currency], amount
-
-        response = get_flow_cc_token payment_method
-
-        data = {
-          token:    response.token,
-          amount:   amount,
-          currency: options[:currency],
-          cvv:      payment_method.verification_value,
-          customer: {
-            name: {
-              first: payment_method.first_name,
-              last: payment_method.last_name
-            }
-          }
-        }
+      def authorize cc_or_token, order_number, opts={}
+        unless opts[:currency]
+          return error_response('Currency is a required option')
+        end
 
-        begin
-          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
-            else
-              ::Io::Flow::V0::Models::DirectAuthorizationForm.new data
-            end
-
-          response = flow_instance.authorizations.post @flow_organization, authorization_form
-        rescue => exception
-          return Response.new false, exception.message, { exception: exception }
+        unless opts[:discriminator]
+          return error_response 'Discriminator is not defined, please choose one [%s]' % FORM_TYPES.join(', ')
         end
 
-        options = { response: response }
+        unless FORM_TYPES.include?(opts[:discriminator].to_sym)
+          return error_response 'Discriminator [%s] not found, please choose one [%s]' % [opts[:discriminator], FORM_TYPES.join(', ')]
+        end
 
-        if ['review', 'authorized'].include?(response.result.status.value)
-          store = {
-                         key: response.key,
-                      amount: response.amount,
-                    currency: response.currency,
-            authorization_id: response.id
-          }
+        body = {
+          amount:        opts[:amount] || 0.0,
+          currency:      opts[:currency],
+          discriminator: opts[:discriminator],
+          token:         store(cc_or_token),
+          order_number:  order_number
+        }
 
-          Response.new true, 'Flow authorize - Success', options, { authorization: store }
-        else
-          Response.new false, 'Flow authorize - Error', options
-        end
+        response = flow_instance.authorizations.post @flow_organization, body
+
+        Response.new true, 'Flow authorize - Success', { response: response }, { authorization: response.id }
+      rescue => exception
+        error_response exception
+      end
+
+      # https://docs.flow.io/module/payment/resource/authorizations#get-organization-authorizations
+      def flow_get_authorization order_number:
+        response = flow_instance.authorizations.get @flow_organization, order_number: order_number
+        response.last
+      rescue => exception
+        error_response exception
       end
 
       # https://docs.flow.io/module/payment/resource/captures#post-organization-captures
-      def capture _money, authorization, options={}
-        raise ArgumentError, 'No Authorization authorization, please authorize first' unless authorization
+      def capture amount, authorization_key, options={}
+        return error_response('Currency is a required option') unless options[:currency]
+
+        body = {
+          authorization_id: authorization_key,
+          amount:           amount,
+          currency:         options[:currency]
+        }
 
         begin
-          capture_form = ::Io::Flow::V0::Models::CaptureForm.new authorization
+          capture_form = ::Io::Flow::V0::Models::CaptureForm.new body
           response     = flow_instance.captures.post @flow_organization, capture_form
         rescue => exception
           error_response exception
         end
 
-        options = { response: response }
-
-        if response.id
-          Response.new true, 'Flow capture - Success', options
+        if response.try(:id)
+          Response.new true, 'Flow capture - Success', { response: response }
         else
-          Response.new false, 'Flow capture - Error', options
+          Response.new false, 'Flow capture - Error', { response: response }
         end
+      rescue Io::Flow::V0::HttpClient::ServerError => exception
+        error_response exception
       end
 
-      def purchase money, credit_card, options={}
-        response = authorize money, credit_card, options
-        capture money, response.authorization
+      def purchase credit_card, order_number, options={}
+        response = authorize credit_card, order_number, options
+        capture options[:amount], response.authorization, options
       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
+      # https://docs.flow.io/module/payment/resource/reversals#post-organization-reversals
+      # if amount is not provided, reverse the full or remaining amount
+      def void amount, authorization_id, options={}
+        options[:authorization_id] = authorization_id
+
+        if amount
+          options[:amount] = assert_currency options[:currency], amount
+        end
+
+        response = flow_instance.reversals.post @flow_organization, options
+
         Response.new true, 'void success', { response: response }
       rescue Io::Flow::V0::HttpClient::ServerError => exception
-        error_response(exception)
+        error_response exception
       end
 
       # https://docs.flow.io/module/payment/resource/refunds
       # authorization_id - The Id of the authorization against which to issue the refund. If specified, we will look at all captures for this authorization, selecting 1 or more captures against which to issue the refund of the requested amount.
       # capture_id       - The Id of the capture against which to issue the refund. If specified, we will only consider this capture.
       # order_number     - The order number if specified during authorization. If specified, we will lookup all authorizations made against this order number, and then selecting 1 or more authorizations against which to issue the refund of the requested amount.
-      # key              - Your unique identifier for this transaction, which if provided is used to implement idempotency. If not provided, we will assign.
       # 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={}
-        refund_form = {}
-        refund_form[:amount]     = amount if amount
-        refund_form[:capture_id] = capture_id if capture_id
+        options[:capture_id] = capture_id if capture_id
 
-        [:authorization_id, :currency, :order_number, :key, :rma_key].each do |key|
-          refund_form[key] = options[key] if options[key]
+        if amount
+          options[:amount] = assert_currency options[:currency], amount
         end
 
-        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]
-        end
+        response = flow_instance.refunds.post @flow_organization, options
 
-        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={}
-        response = get_flow_cc_token credit_card
-        Response.new true, 'Credit card stored', { response: response, token: response.token }
+        if response.try(:id)
+          Response.new true, 'Flow refund - Success', { response: response }
+        else
+          Response.new false, 'Flow refund - Error', { response: response }
+        end
       rescue Io::Flow::V0::HttpClient::ServerError => exception
         error_response exception
       end
 
-      private
-
-      def flow_instance
-        FlowCommerce.instance token: @flow_api_key
-      end
+      # stores credit card and returns credit card Flow token String id
+      def store input
+        credit_card =
+        case input
+          when Hash
+            ActiveMerchant::Billing::CreditCard.new input
+          when ActiveMerchant::Billing::CreditCard
+            input
+          when String
+            return input
+          else
+            raise 'Unsuported store method input type [%s]' % input.class
+        end
 
-      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
+                   address: credit_card.address
         }
 
-        card_form = ::Io::Flow::V0::Models::CardForm.new data
-        flow_instance.cards.post @flow_organization, card_form
+        response  = flow_instance.cards.post @flow_organization, data
+
+        if response.respond_to?(:token)
+          Response.new true, 'Flow refund - Success', { response: response }
+        else
+          Response.new false, 'Flow POST /:organization/cards - Failure', { response: response }
+        end
+      rescue Io::Flow::V0::HttpClient::ServerError => exception
+        error_response exception
+      end
+
+      # Creates and order
+      # https://docs.flow.io/module/localization/resource/orders#post-organization-orders
+      def flow_create_order body, query_string={}
+        flow_instance.orders.post @flow_organization, body, query_string
+      rescue => exception
+        error_response exception
+      end
+
+      # Submits an order and
+      # pushes all subsequent authorizations from status "review" to "authorized"
+      # takes ~ 60 seconds
+      def flow_submission_by_number order_number
+        flow_instance.orders.put_submissions_by_number @flow_organization, order_number
+      rescue => exception
+        error_response exception
+      end
+
+      private
+
+      def flow_instance
+        FlowCommerce.instance token: @flow_api_key
       end
 
       def error_response exception_object
-        message = if exception_object.respond_to?(:body) && exception_object.body.length > 0
+        message =
+        if exception_object.is_a?(String)
+          exception_object
+        elsif 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]
-        else
+        elsif exception_object.respond_to?(:message)
           exception_object.message
+        else
+          raise ArgumentError.new('Unsuported exception_object [%s]' % exception_object.class)
         end
 
+        msg = 'ERROR: %s' % message
+        msg = msg.yellow if msg.respond_to?(:yellow)
+
+        puts msg
+
         Response.new false, message, exception: exception_object
       end
 
       def assert_currency currency, amount
-        raise ArgumentError, 'currency not provided' unless currency
         FlowCommerce::Reference::Currencies.find! currency
         amount.to_f
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: flowcommerce-activemerchant
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Dino Reic
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-07 00:00:00.000000000 Z
+date: 2018-11-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemerchant
@@ -59,6 +59,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- "./.version"
+- "./LICENSE"
 - "./lib/active_merchant/billing/gateways/flow.rb"
 - "./lib/flowcommerce-activemerchant.rb"
 homepage: https://www.flow.io