killbill-paypal-express 5.0.17 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23314a804c43068e902755d06859b55eb6006daf
-  data.tar.gz: 3d503c8f6b3c951b1b7d9dff42bd6bd15d98c1cd
+  metadata.gz: ef211332b6640d41c9bbd87f64705c56ecec9b10
+  data.tar.gz: 7d7830ee4c7612520817e43fa36dea798fc0ebbe
 SHA512:
-  metadata.gz: 10c7e4aa4501351593a5950b394fe79b56e137b64c9e207915d378634f004ef450083f0b9e7b3ae391e7c0727a43c8442d53a9cb3cf9ab1f446a2f971258aa47
-  data.tar.gz: 4088bb22ce6efbd3d76eed7e7001c4d6c9ccd41ae88ea128a5b91ad09c3c71588c3590d94a737e3934d9db8dcd834c154e2bea1960c5ec2ecdfe5e7fd1ca3e21
+  metadata.gz: 61050da6f063c77bc5f6f092336349ab0fad7a4798d976ed560b8171008409818be031edca47edecc1f73f5d90cae74d13611f96050cea9e8a260418cd2509dd
+  data.tar.gz: 30b3d2eddc0043a449d3edb547bded37078279f31aedc46ffe17858ef395c26bac65dcde8325a9fd0ea00013d058c5895622990809b78fd94988deae9768a89d

data/lib/paypal_express/api.rb

@@ -195,6 +195,7 @@ module Killbill #:nodoc:
 
         kb_account = ::Killbill::Plugin::ActiveMerchant::Utils::LazyEvaluator.new { @kb_apis.account_user_api.get_account_by_id(kb_account_id, jcontext) }
         amount = (options[:amount] || '0').to_f
+        effective_date = options[:effective_date] || Time.now.utc
         currency = options[:currency] || kb_account.currency
 
         response = initiate_express_checkout(kb_account_id, amount, currency, all_properties, context)
@@ -216,7 +217,7 @@ module Killbill #:nodoc:
           payment_external_key = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(options, :payment_external_key)
           transaction_external_key = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(options, :transaction_external_key)
 
-          kb_payment_method = (@kb_apis.payment_api.get_account_payment_methods(kb_account_id, false, [], jcontext).find { |pm| pm.plugin_name == 'killbill-paypal-express' })
+          kb_payment_method = (@kb_apis.payment_api.get_account_payment_methods(kb_account_id, false, false, [], jcontext).find { |pm| pm.plugin_name == 'killbill-paypal-express' })
 
           auth_mode = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(options, :auth_mode)
           # By default, the SALE mode is used.
@@ -227,6 +228,7 @@ module Killbill #:nodoc:
                                                 nil,
                                                 amount,
                                                 currency,
+                                                effective_date,
                                                 payment_external_key,
                                                 transaction_external_key,
                                                 custom_props,
@@ -238,6 +240,7 @@ module Killbill #:nodoc:
                                            nil,
                                            amount,
                                            currency,
+                                           effective_date,
                                            payment_external_key,
                                            transaction_external_key,
                                            custom_props,
@@ -301,59 +304,28 @@ module Killbill #:nodoc:
         response
       end
 
-      def create_billing_aggrement(token,
-                                   kb_account_id,
-                                   kb_tenant_id,
-                                   payment_processor_account_id,
-                                   kb_payment_id = nil,
-                                   kb_payment_transaction_id = nil,
-                                   transaction_type = nil)
-        raise 'Could create billing aggrement: the token is missing' if token.blank?
-
-        # Go to Paypal to create the billing aggrement
-        payment_processor_account_id = payment_processor_account_id || :default
-        gateway                      = lookup_gateway(payment_processor_account_id, kb_tenant_id)
-        gw_response                  = gateway.store(token)
-
-        response = @response_model.create_response(:store, kb_account_id, kb_payment_id, kb_payment_transaction_id, transaction_type, payment_processor_account_id, kb_tenant_id, gw_response)
-
-        raise response.message unless response.success?
-        raise "Could not create billing aggrement for token #{token}" if response.billing_agreement_id.blank?
-
-        response
-      end
-
-      def add_default_options(kb_payment_transaction_id, options)
-        options[:payment_type] ||= 'Any'
-        options[:invoice_id]   ||= kb_payment_transaction_id
-        options[:ip]           ||= @ip
-      end
-
-      def add_payment_method_options(kb_account_id, kb_payment_method_id, context, options, properties_hash)
-        options[:token] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :token) || find_last_token(kb_account_id, context.tenant_id)
-        options[:reference_id] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :baid)
-
+      def add_required_options(kb_payment_transaction_id, kb_payment_method_id, context, options)
         payment_method = @payment_method_model.from_kb_payment_method_id(kb_payment_method_id, context.tenant_id)
 
         options[:payer_id]     ||= payment_method.paypal_express_payer_id.presence
         options[:token]        ||= payment_method.paypal_express_token.presence
         options[:reference_id] ||= payment_method.token.presence # baid
+
+        options[:payment_type] ||= 'Any'
+        options[:invoice_id]   ||= kb_payment_transaction_id
+        options[:ip]           ||= @ip
       end
 
       def initiate_express_checkout(kb_account_id, amount, currency, properties, context)
         properties_hash = properties_to_hash(properties)
 
+        with_baid = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :with_baid)
+
         options = {}
         options[:return_url] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :return_url)
         options[:cancel_return_url] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :cancel_return_url)
         options[:payment_processor_account_id] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :payment_processor_account_id)
 
-        with_baid = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :with_baid)
-        if with_baid
-          options[:payment_processor_account_id] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :payment_master_processor_account_id)
-          [:billing_agreement_type, :billing_agreement_description].each { |sym| options[sym] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, sym) }
-        end
-
         add_optional_parameters options, properties_hash, currency
 
         amount_in_cents = amount.nil? ? nil : to_cents(amount, currency)
@@ -372,15 +344,7 @@ module Killbill #:nodoc:
 
       def authorize_or_purchase_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context, is_authorize = false)
         properties_hash = properties_to_hash properties
-        with_baid = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :with_baid)
-        logger.info("withBaidFlag=#{with_baid}")
-
         payment_processor_account_id = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :payment_processor_account_id)
-        logger.info("paymentProcessorAccountId=#{payment_processor_account_id}")
-
-        payment_master_processor_account_id = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :payment_master_processor_account_id)
-        logger.info("paymentMasterProcessorAccountId=#{payment_master_processor_account_id}")
-
         transaction_type = is_authorize ? :AUTHORIZE : :PURCHASE
         api_call_type = is_authorize ? :authorize : :purchase
 
@@ -407,79 +371,14 @@ module Killbill #:nodoc:
           transaction
         else
           options = {}
-          add_default_options(kb_payment_transaction_id, options)
-          add_payment_method_options(kb_account_id, kb_payment_method_id, context, options, properties_hash)
+          add_required_options(kb_payment_transaction_id, kb_payment_method_id, context, options)
           options[:token] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :token) || find_last_token(kb_account_id, context.tenant_id)
           # Find the payment_processor_id if not provided
           payment_processor_account_id ||= find_payment_processor_id_from_initial_call(kb_account_id, context.tenant_id, options[:token])
           options[:payment_processor_account_id] = payment_processor_account_id
-          options[:payer_id] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :payer_id)
-
-          if with_baid
-            baid_payment_processor_account_id = payment_master_processor_account_id
-          else
-            baid_payment_processor_account_id = payment_processor_account_id
-          end
-
-          if with_baid
-            if options.has_key?(:token) && options[:reference_id].nil?
-                # Retrieve payer_id and payer_email
-              begin
-
-                payer_info = get_payer_info(options[:token],
-                                            kb_account_id,
-                                            context.tenant_id,
-                                            baid_payment_processor_account_id,
-                                            kb_payment_id,
-                                            kb_payment_transaction_id,
-                                            transaction_type)
-              rescue => e
-                # Maybe invalid token?
-                response = @response_model.create(:api_call                     => api_call_type,
-                                                  :kb_account_id                => kb_account_id,
-                                                  :kb_payment_id                => kb_payment_id,
-                                                  :kb_payment_transaction_id    => kb_payment_transaction_id,
-                                                  :transaction_type             => transaction_type,
-                                                  :authorization                => nil,
-                                                  :payment_processor_account_id => baid_payment_processor_account_id,
-                                                  :kb_tenant_id                 => context.tenant_id,
-                                                  :success                      => false,
-                                                  :created_at                   => Time.now.utc,
-                                                  :updated_at                   => Time.now.utc,
-                                                  :message                      => { :payment_plugin_status => :CANCELED, :exception_class => e.class.to_s, :exception_message => e.message }.to_json)
-                return response.to_transaction_info_plugin(nil)
-              end
-              if options[:payer_id].nil?
-                options[:payer_id] = payer_info.payer_id
-              end
-              options[:payer_email] = payer_info.payer_email
-
-              begin
-                options[:reference_id] = create_billing_aggrement(options[:token],
-                                                                         kb_account_id,
-                                                                         context.tenant_id,
-                                                                  baid_payment_processor_account_id,
-                                                                         kb_payment_id,
-                                                                         kb_payment_transaction_id,
-                                                                         transaction_type).billing_agreement_id
-              rescue => e
-                # Maybe invalid token?
-                response = @response_model.create(:api_call                     => api_call_type,
-                                                  :kb_account_id                => kb_account_id,
-                                                  :kb_payment_id                => kb_payment_id,
-                                                  :kb_payment_transaction_id    => kb_payment_transaction_id,
-                                                  :transaction_type             => transaction_type,
-                                                  :authorization                => nil,
-                                                  :payment_processor_account_id => baid_payment_processor_account_id,
-                                                  :kb_tenant_id                 => context.tenant_id,
-                                                  :success                      => false,
-                                                  :created_at                   => Time.now.utc,
-                                                  :updated_at                   => Time.now.utc,
-                                                  :message                      => { :payment_plugin_status => :CANCELED, :exception_class => e.class.to_s, :exception_message => e.message }.to_json)
-                return response.to_transaction_info_plugin(nil)
-              end
-            end
 
+          # We have a baid on file
+          if options[:reference_id]
             if is_authorize
               gateway_call_proc = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
                 # Can't use default implementation: the purchase signature is for one-off payments only
@@ -492,39 +391,37 @@ module Killbill #:nodoc:
               end
             end
           else
-
-            if options.has_key?(:token)
-              # Retrieve payer_id and payer_email
-              begin
-
-                payer_info = get_payer_info(options[:token],
-                                            kb_account_id,
-                                            context.tenant_id,
-                                            baid_payment_processor_account_id,
-                                            kb_payment_id,
-                                            kb_payment_transaction_id,
-                                            transaction_type)
-              rescue => e
-                # Maybe invalid token?
-                response = @response_model.create(:api_call                     => api_call_type,
-                                                  :kb_account_id                => kb_account_id,
-                                                  :kb_payment_id                => kb_payment_id,
-                                                  :kb_payment_transaction_id    => kb_payment_transaction_id,
-                                                  :transaction_type             => transaction_type,
-                                                  :authorization                => nil,
-                                                  :payment_processor_account_id => baid_payment_processor_account_id,
-                                                  :kb_tenant_id                 => context.tenant_id,
-                                                  :success                      => false,
-                                                  :created_at                   => Time.now.utc,
-                                                  :updated_at                   => Time.now.utc,
-                                                  :message                      => { :payment_plugin_status => :CANCELED, :exception_class => e.class.to_s, :exception_message => e.message }.to_json)
-                return response.to_transaction_info_plugin(nil)
-              end
-              if options[:payer_id].nil?
-                options[:payer_id] = payer_info.payer_id
-              end
-              options[:payer_email] = payer_info.payer_email
+            # One-off payment
+            # Retrieve payer_id and payer_email
+            begin
+              payer_info = get_payer_info(options[:token],
+                                          kb_account_id,
+                                          context.tenant_id,
+                                          payment_processor_account_id,
+                                          kb_payment_id,
+                                          kb_payment_transaction_id,
+                                          transaction_type)
+            rescue => e
+              # Maybe invalid token?
+              response = @response_model.create(:api_call                     => api_call_type,
+                                                :kb_account_id                => kb_account_id,
+                                                :kb_payment_id                => kb_payment_id,
+                                                :kb_payment_transaction_id    => kb_payment_transaction_id,
+                                                :transaction_type             => transaction_type,
+                                                :authorization                => nil,
+                                                :payment_processor_account_id => payment_processor_account_id,
+                                                :kb_tenant_id                 => context.tenant_id,
+                                                :success                      => false,
+                                                :created_at                   => Time.now.utc,
+                                                :updated_at                   => Time.now.utc,
+                                                :message                      => { :payment_plugin_status => :CANCELED, :exception_class => e.class.to_s, :exception_message => e.message }.to_json)
+              return response.to_transaction_info_plugin(nil)
+            end
+            options[:payer_id] = ::Killbill::Plugin::ActiveMerchant::Utils.normalized(properties_hash, :payer_id)
+            if options[:payer_id].nil?
+              options[:payer_id] = payer_info.payer_id
             end
+            options[:payer_email] = payer_info.payer_email
 
             if is_authorize
               gateway_call_proc  = Proc.new do |gateway, linked_transaction, payment_source, amount_in_cents, options|
@@ -717,19 +614,15 @@ module Killbill #:nodoc:
       end
 
       def get_raw_payment_info(kb_payment_id, context)
+        ignored_api_calls = [:details_for]
         responses = @response_model.from_kb_payment_id(@transaction_model, kb_payment_id, context.tenant_id)
-        details_for_response = responses.select {|r| r.api_call.to_sym == :details_for}.last
-        details_for_plugin_info = details_for_response.nil? ? nil : details_for_response.to_transaction_info_plugin
-
         responses = responses.reject do |response|
-          response == details_for_response
+          ignored_api_calls.include?(response.api_call.to_sym)
         end
         t_info_plugins = responses.collect do |response|
           response.to_transaction_info_plugin(response.send("#{@identifier}_transaction"))
         end
 
-        merge_selected_properties_from_details_call(t_info_plugins, details_for_plugin_info, [:payerEmail])
-
         # Completed purchases/authorizations will have two rows in the responses table (one for api_call 'build_form_descriptor', one for api_call 'purchase/authorize')
         # Other transaction types don't support the :PENDING state
         target_transaction_types = [:PURCHASE, :AUTHORIZE]
@@ -737,25 +630,7 @@ module Killbill #:nodoc:
 
         # Filter out the pending transaction if there is already a response tied with the same transaction but indicating a final state
         t_info_plugins_without_pending = t_info_plugins.reject { |t_info_plugin| target_transaction_types.include?(t_info_plugin.transaction_type) && t_info_plugin.status == :PENDING }
-        result = [with_only_pending_trx ? t_info_plugins : t_info_plugins_without_pending, t_info_plugins, with_only_pending_trx]
-        result
-      end
-
-      def merge_selected_properties_from_details_call(plugin_infos, to_merge_plugin_info, merge_properties)
-        unless to_merge_plugin_info.nil?
-          plugin_infos.each do |trx_plugin_info|
-            merge_properties.each do |p|
-              p_value = find_value_from_properties(to_merge_plugin_info.properties, p)
-              unless p_value.blank?
-                if trx_plugin_info.properties.detect {|mp| mp.key.to_s == p.to_s}.nil?
-                  trx_plugin_info.properties << create_plugin_property(p.to_s, p_value)
-                else
-                  trx_plugin_info.properties.detect {|mp| mp.key.to_s == p.to_s} .value = p_value
-                end
-              end
-            end
-          end
-        end
+        [with_only_pending_trx ? t_info_plugins : t_info_plugins_without_pending, t_info_plugins, with_only_pending_trx]
       end
     end
   end

data/lib/paypal_express/models/response.rb

@@ -98,6 +98,7 @@ module Killbill #:nodoc:
 
       def self.sensitive_fields
         [:payer_name,
+         :payer_email,
          :contact_phone,
          :ship_to_address_name,
          :ship_to_address_company,

data/lib/paypal_express/private_api.rb

@@ -25,8 +25,8 @@ module Killbill #:nodoc:
 
         if with_baid
           options[:billing_agreement]               ||= {}
-          options[:billing_agreement][:type]        ||= options[:billing_agreement_type] || 'MerchantInitiatedBilling'
-          options[:billing_agreement][:description] ||= options[:billing_agreement_description] || 'Kill Bill billing agreement'
+          options[:billing_agreement][:type]        ||= 'MerchantInitiatedBilling'
+          options[:billing_agreement][:description] ||= 'Kill Bill billing agreement'
         end
 
         # Go to Paypal (SetExpressCheckout call)

metadata

@@ -1,21 +1,21 @@
 --- !ruby/object:Gem::Specification
 name: killbill-paypal-express
 version: !ruby/object:Gem::Version
-  version: 5.0.17
+  version: 6.0.0
 platform: ruby
 authors:
 - Kill Bill core team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-27 00:00:00.000000000 Z
+date: 2018-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.4'
   name: killbill
   prerelease: false
   type: :runtime
@@ -23,7 +23,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: '9.4'
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -237,7 +237,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: 3.5.0
   name: rspec
   prerelease: false
   type: :development
@@ -245,7 +245,7 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.12.0
+        version: 3.5.0
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -260,6 +260,26 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.53.0
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 1.2.4
+  name: websocket
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: 1.2.4
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements: