killbill-paypal-express 1.0.6 → 1.0.8

data/.gitignore

@@ -34,3 +34,6 @@ paypal_express.yml
 test.db
 
 target
+pom.xml.asc
+
+.idea

data/VERSION

@@ -1 +1 @@
-1.0.6
+1.0.8

data/killbill-paypal-express.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |s|
 
   s.rdoc_options << '--exclude' << '.'
 
-  s.add_dependency 'killbill', '~> 1.0.16'
+  s.add_dependency 'killbill', '~> 1.0.17'
   s.add_dependency 'activemerchant', '~> 2.0.0'
   s.add_dependency 'activerecord', '~> 3.2.1'
   s.add_dependency 'sinatra', '~> 1.3.4'

data/lib/paypal_express/api.rb

@@ -16,19 +16,19 @@ module Killbill::PaypalExpress
       ActiveRecord::Base.connection.close
     end
 
-    def process_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount_in_cents, currency, options = {})
+    def process_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount_in_cents, currency, call_context, options = {})
       # If the payment was already made, just return the status
-      paypal_express_transaction = PaypalExpressTransaction.from_kb_payment_id(kb_payment_id) rescue nil
+      paypal_express_transaction = PaypalExpressTransaction.from_kb_payment_id(kb_payment_id.to_s) rescue nil
       return paypal_express_transaction.paypal_express_response.to_payment_response unless paypal_express_transaction.nil?
 
-      options[:currency] ||= currency
+      options[:currency] ||= currency.respond_to?(:enum) ? currency.enum : currency.to_s
       options[:payment_type] ||= 'Any'
-      options[:invoice_id] ||= kb_payment_id
+      options[:invoice_id] ||= kb_payment_id.to_s
       options[:description] ||= "Kill Bill payment for #{kb_payment_id}"
       options[:ip] ||= @ip
 
       if options[:reference_id].blank?
-        payment_method = PaypalExpressPaymentMethod.from_kb_payment_method_id(kb_payment_method_id)
+        payment_method = PaypalExpressPaymentMethod.from_kb_payment_method_id(kb_payment_method_id.to_s)
         options[:reference_id] = payment_method.paypal_express_baid
       end
 
@@ -39,10 +39,10 @@ module Killbill::PaypalExpress
       response.to_payment_response
     end
 
-    def process_refund(kb_account_id, kb_payment_id, amount_in_cents, currency, options = {})
-      paypal_express_transaction = PaypalExpressTransaction.find_candidate_transaction_for_refund(kb_payment_id, amount_in_cents)
+    def process_refund(kb_account_id, kb_payment_id, amount_in_cents, currency, call_context, options = {})
+      paypal_express_transaction = PaypalExpressTransaction.find_candidate_transaction_for_refund(kb_payment_id.to_s, amount_in_cents)
 
-      options[:currency] ||= currency
+      options[:currency] ||= currency.respond_to?(:enum) ? currency.enum : currency.to_s
       options[:refund_type] ||= paypal_express_transaction.amount_in_cents != amount_in_cents ? 'Partial' : 'Full'
 
       identification = paypal_express_transaction.paypal_express_txn_id
@@ -54,25 +54,25 @@ module Killbill::PaypalExpress
       response.to_refund_response
     end
 
-    def get_payment_info(kb_account_id, kb_payment_id, options = {})
-      paypal_express_transaction = PaypalExpressTransaction.from_kb_payment_id(kb_payment_id)
+    def get_payment_info(kb_account_id, kb_payment_id, tenant_context, options = {})
+      paypal_express_transaction = PaypalExpressTransaction.from_kb_payment_id(kb_payment_id.to_s)
 
       begin
         transaction_id = paypal_express_transaction.paypal_express_txn_id
         response = @gateway.transaction_details transaction_id
-        PaypalExpressResponse.from_response(:transaction_details, kb_payment_id, response).to_payment_response
+        PaypalExpressResponse.from_response(:transaction_details, kb_payment_id.to_s, response).to_payment_response
       rescue => e
-        @logger.warn("Exception while retrieving Paypal Express transaction detail for payment #{kb_payment_id}, defaulting to cached response: #{e}")
+        @logger.warn("Exception while retrieving Paypal Express transaction detail for payment #{kb_payment_id.to_s}, defaulting to cached response: #{e}")
         paypal_express_transaction.paypal_express_response.to_payment_response
       end
     end
 
-    def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default=false, options = {})
-      token = payment_method_props.value('token')
+    def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, call_context, options = {})
+      token = (payment_method_props.properties.find { |kv| kv.key == 'token' }).value
       return false if token.nil?
 
       # The payment method should have been created during the setup step (see private api)
-      payment_method = PaypalExpressPaymentMethod.from_kb_account_id_and_token(kb_account_id, token)
+      payment_method = PaypalExpressPaymentMethod.from_kb_account_id_and_token(kb_account_id.to_s, token)
 
       # Go to Paypal to get the Payer id (GetExpressCheckoutDetails call)
       paypal_express_details_response = @gateway.details_for token
@@ -86,29 +86,29 @@ module Killbill::PaypalExpress
         response = save_response_and_transaction paypal_express_baid_response, :create_billing_agreement
         return false unless response.success?
 
-        payment_method.kb_payment_method_id = kb_payment_method_id
+        payment_method.kb_payment_method_id = kb_payment_method_id.to_s
         payment_method.paypal_express_payer_id = payer_id
         payment_method.paypal_express_baid = response.billing_agreement_id
         payment_method.save!
 
-        logger.info "Created BAID #{payment_method.paypal_express_baid} for payment method #{kb_payment_method_id} (account #{kb_account_id})"
+        logger.info "Created BAID #{payment_method.paypal_express_baid} for payment method #{kb_payment_method_id.to_s} (account #{kb_account_id.to_s})"
         true
       else
-        logger.warn "Unable to retrieve Payer id details for token #{token} (account #{kb_account_id})"
+        logger.warn "Unable to retrieve Payer id details for token #{token} (account #{kb_account_id.to_s})"
         false
       end
     end
 
-    def delete_payment_method(kb_account_id, kb_payment_method_id, options = {})
-      PaypalExpressPaymentMethod.mark_as_deleted! kb_payment_method_id
+    def delete_payment_method(kb_account_id, kb_payment_method_id, call_context, options = {})
+      PaypalExpressPaymentMethod.mark_as_deleted! kb_payment_method_id.to_s
     end
 
-    def get_payment_method_detail(kb_account_id, kb_payment_method_id, options = {})
-      PaypalExpressPaymentMethod.from_kb_payment_method_id(kb_payment_method_id).to_payment_method_response
+    def get_payment_method_detail(kb_account_id, kb_payment_method_id, tenant_context, options = {})
+      PaypalExpressPaymentMethod.from_kb_payment_method_id(kb_payment_method_id.to_s).to_payment_method_response
     end
 
-    def get_payment_methods(kb_account_id, refresh_from_gateway = false, options = {})
-      PaypalExpressPaymentMethod.from_kb_account_id(kb_account_id).collect { |pm| pm.to_payment_method_response }
+    def get_payment_methods(kb_account_id, refresh_from_gateway, call_context, options = {})
+      PaypalExpressPaymentMethod.from_kb_account_id(kb_account_id.to_s).collect { |pm| pm.to_payment_method_response }
     end
 
     private
@@ -117,12 +117,12 @@ module Killbill::PaypalExpress
       @logger.warn "Unsuccessful #{api_call}: #{paypal_express_response.message}" unless paypal_express_response.success?
 
       # Save the response to our logs
-      response = PaypalExpressResponse.from_response(api_call, kb_payment_id, paypal_express_response)
+      response = PaypalExpressResponse.from_response(api_call, kb_payment_id.to_s, paypal_express_response)
       response.save!
 
       if response.success and !kb_payment_id.blank? and !response.authorization.blank?
         # Record the transaction
-        transaction = response.create_paypal_express_transaction!(:amount_in_cents => amount_in_cents, :api_call => api_call, :kb_payment_id => kb_payment_id, :paypal_express_txn_id => response.authorization)
+        transaction = response.create_paypal_express_transaction!(:amount_in_cents => amount_in_cents, :api_call => api_call, :kb_payment_id => kb_payment_id.to_s, :paypal_express_txn_id => response.authorization)
         @logger.debug "Recorded transaction: #{transaction.inspect}"
       end
       response

data/pom.xml

@@ -25,7 +25,7 @@
     <groupId>com.ning.killbill.ruby</groupId>
     <artifactId>paypal-express-plugin</artifactId>
     <packaging>pom</packaging>
-    <version>1.0.6</version>
+    <version>1.0.8</version>
     <name>paypal-express-plugin</name>
     <url>http://github.com/killbill/killbill-paypal-express-plugin</url>
     <description>Plugin for accessing paypal as a payment gateway</description>

data/spec/paypal_express/remote/integration_spec.rb

@@ -15,6 +15,15 @@ describe Killbill::PaypalExpress::PaymentPlugin do
     @plugin.start_plugin
 
     @pm = create_payment_method
+    @call_context = Killbill::Plugin::Model::CallContext.new(SecureRandom.uuid,
+                                                             'token',
+                                                             'rspec tester',
+                                                             'TEST',
+                                                             'user',
+                                                             'testing',
+                                                             'this is from a test',
+                                                             Time.now,
+                                                             Time.now)
   end
 
   after(:each) do
@@ -26,9 +35,9 @@ describe Killbill::PaypalExpress::PaymentPlugin do
     currency = 'USD'
     kb_payment_id = SecureRandom.uuid
 
-    payment_response = @plugin.process_payment @pm.kb_account_id, kb_payment_id, @pm.kb_payment_method_id, amount_in_cents, currency
-    payment_response.amount_in_cents.should == amount_in_cents
-    payment_response.status.should == "Success"
+    payment_response = @plugin.process_payment @pm.kb_account_id, kb_payment_id, @pm.kb_payment_method_id, amount_in_cents, currency, @call_context
+    payment_response.amount.should == amount_in_cents
+    payment_response.status.should == Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
 
     # Verify our table directly
     response = Killbill::PaypalExpress::PaypalExpressResponse.find_by_api_call_and_kb_payment_id :charge, kb_payment_id
@@ -37,16 +46,16 @@ describe Killbill::PaypalExpress::PaymentPlugin do
     response.message.should == "Success"
 
     # Check we can retrieve the payment
-    payment_response = @plugin.get_payment_info @pm.kb_account_id, kb_payment_id
-    payment_response.amount_in_cents.should == amount_in_cents
-    payment_response.status.should == "Success"
+    payment_response = @plugin.get_payment_info @pm.kb_account_id, kb_payment_id, @call_context
+    payment_response.amount.should == amount_in_cents
+    payment_response.status.should == Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
 
     # Check we cannot refund an amount greater than the original charge
-    lambda { @plugin.process_refund @pm.kb_account_id, kb_payment_id, amount_in_cents + 1, currency }.should raise_error RuntimeError
+    lambda { @plugin.process_refund @pm.kb_account_id, kb_payment_id, amount_in_cents + 1, currency, @call_context }.should raise_error RuntimeError
 
-    refund_response = @plugin.process_refund @pm.kb_account_id, kb_payment_id, amount_in_cents, currency
-    refund_response.amount_in_cents.should == amount_in_cents
-    refund_response.status.should == "Success"
+    refund_response = @plugin.process_refund @pm.kb_account_id, kb_payment_id, amount_in_cents, currency, @call_context
+    refund_response.amount.should == amount_in_cents
+    refund_response.status.should == Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
 
     # Verify our table directly
     response = Killbill::PaypalExpress::PaypalExpressResponse.find_by_api_call_and_kb_payment_id :refund, kb_payment_id
@@ -56,29 +65,29 @@ describe Killbill::PaypalExpress::PaymentPlugin do
     # Try another payment to verify the BAID
     second_amount_in_cents = 9423
     second_kb_payment_id = SecureRandom.uuid
-    payment_response = @plugin.process_payment @pm.kb_account_id, second_kb_payment_id, @pm.kb_payment_method_id, second_amount_in_cents, currency
-    payment_response.amount_in_cents.should == second_amount_in_cents
-    payment_response.status.should == "Success"
+    payment_response = @plugin.process_payment @pm.kb_account_id, second_kb_payment_id, @pm.kb_payment_method_id, second_amount_in_cents, currency, @call_context
+    payment_response.amount.should == second_amount_in_cents
+    payment_response.status.should == Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
 
     # Check we can refund it as well
-    refund_response = @plugin.process_refund @pm.kb_account_id, second_kb_payment_id, second_amount_in_cents, currency
-    refund_response.amount_in_cents.should == second_amount_in_cents
-    refund_response.status.should == "Success"
+    refund_response = @plugin.process_refund @pm.kb_account_id, second_kb_payment_id, second_amount_in_cents, currency, @call_context
+    refund_response.amount.should == second_amount_in_cents
+    refund_response.status.should == Killbill::Plugin::Model::PaymentPluginStatus.new(:PROCESSED)
 
     # it "should be able to create and retrieve payment methods"
     # This should be in a separate scenario but since it's so hard to create a payment method (need manual intervention),
     # we can't easily delete it
-    pms = @plugin.get_payment_methods @pm.kb_account_id
+    pms = @plugin.get_payment_methods @pm.kb_account_id, false, @call_context
     pms.size.should == 1
     pms[0].external_payment_method_id.should == @pm.paypal_express_baid
 
-    pm_details = @plugin.get_payment_method_detail(@pm.kb_account_id, @pm.kb_payment_method_id)
+    pm_details = @plugin.get_payment_method_detail(@pm.kb_account_id, @pm.kb_payment_method_id, @call_context)
     pm_details.external_payment_method_id.should == @pm.paypal_express_baid
 
-    @plugin.delete_payment_method @pm.kb_account_id, @pm.kb_payment_method_id
+    @plugin.delete_payment_method @pm.kb_account_id, @pm.kb_payment_method_id, @call_context
 
-    @plugin.get_payment_methods(@pm.kb_account_id).size.should == 0
-    lambda { @plugin.get_payment_method_detail(@pm.kb_account_id, @pm.kb_payment_method_id) }.should raise_error RuntimeError
+    @plugin.get_payment_methods(@pm.kb_account_id, false, @call_context).size.should == 0
+    lambda { @plugin.get_payment_method_detail(@pm.kb_account_id, @pm.kb_payment_method_id, @call_context) }.should raise_error RuntimeError
   end
 
   private
@@ -98,8 +107,8 @@ Note: you need to log-in with a paypal sandbox account (create one here: https:/
 
     # Complete the setup process
     kb_payment_method_id = SecureRandom.uuid
-    info = Killbill::Plugin::PaymentMethodResponse.new nil, nil, [Killbill::Plugin::PaymentMethodProperty.new("token", token, false)]
-    response = @plugin.add_payment_method kb_account_id, kb_payment_method_id, info
+    info = Killbill::Plugin::Model::PaymentMethodPlugin.new nil, nil, [Killbill::Plugin::Model::PaymentMethodKVInfo.new(false, "token", token)], nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil
+    response = @plugin.add_payment_method kb_account_id, kb_payment_method_id, info, true, @call_context
     response.should be_true
 
     # Verify our table directly

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: killbill-paypal-express
 version: !ruby/object:Gem::Version
+  version: 1.0.8
   prerelease:
-  version: 1.0.6
 platform: ruby
 authors:
 - Killbill core team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-05-22 00:00:00.000000000 Z
+date: 2013-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: killbill
@@ -17,13 +17,13 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.16
+        version: 1.0.17
     none: false
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.16
+        version: 1.0.17
     none: false
   prerelease: false
   type: :runtime
@@ -210,9 +210,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       segments:
       - 0
-      hash: 2
       version: !binary |-
         MA==
+      hash: 2
   none: false
 requirements: []
 rubyforge_project: