killbill-payu-latam 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ceae0c30f3e2b84b4be32c80861606a3e5e53bc
-  data.tar.gz: 53615b47bc8b1d96a5f3f606f38f2b337207bc46
+  metadata.gz: 258296e92114a0ad40e4fba3d9863203a278285f
+  data.tar.gz: 915019234f3b2624b2bb889d4c472519fdc809b1
 SHA512:
-  metadata.gz: f29b40651e522f358272cdeff428686f1062c6be21dce87ffb81d65c7619f7d2ad6fb70eab746088be724874170de4b9bea4862bceed465702fd658ff962460e
-  data.tar.gz: 75e50e7b4780c2bfd3aff7b8b29c342485671d09c0bfb0dac3bf087e015b063eb153c4114055c2bdd467321ef22e6087cdba87d72a8d9320336b357445180e32
+  metadata.gz: 82c1a136c316d91ba1cf41b19ce73cc78d2b75cc930cb9ca784e5b57c705249d36f44bb8b120a89c369e74879b9dfbbc778c6bc71d4975af22b01702e0714da7
+  data.tar.gz: 455102e745e66506fba62ac7cce0eaacfe831462251cfeb20d17ea6164e2f223a820ff77c77f903dacb9ea442e7e4d57c7cf407e3af307a163c0837d7c8f67d0

data/NEWS

@@ -1,2 +1,5 @@
+0.0.2
+    HPP support
+
 0.0.1
     Initial release

data/README.md

@@ -1,4 +1,158 @@
 killbill-payu-latam-plugin
 ==========================
 
-Plugin to use PayU Latam as a gateway
+Plugin to use [PayU Latam](http://www.payulatam.com/) as a gateway.
+
+Release builds are available on [Maven Central](http://search.maven.org/#search%7Cga%7C1%7Cg%3A%22org.kill-bill.billing.plugin.ruby%22%20AND%20a%3A%22payu-latam-plugin%22) with coordinates `org.kill-bill.billing.plugin.ruby:payu-latam-plugin`.
+
+Requirements
+------------
+
+The plugin needs a database. The latest version of the schema can be found here: https://raw.github.com/killbill/killbill-payu-latam-plugin/master/db/ddl.sql.
+
+Usage
+-----
+
+### Credit cards
+
+Add a payment method:
+
+```
+curl -v \
+     -u admin:password \
+     -H "X-Killbill-ApiKey: bob" \
+     -H "X-Killbill-ApiSecret: lazar" \
+     -H "Content-Type: application/json" \
+     -H "X-Killbill-CreatedBy: demo" \
+     -X POST \
+     --data-binary '{
+       "pluginName": "killbill-payu-latam",
+       "pluginInfo": {
+         "properties": [
+           {
+             "key": "ccLastName",
+             "value": "APPROVED"
+           },
+           {
+             "key": "ccExpirationMonth",
+             "value": 12
+           },
+           {
+             "key": "ccExpirationYear",
+             "value": 2017
+           },
+           {
+             "key": "ccNumber",
+             "value": 4111111111111111
+           }
+         ]
+       }
+     }' \
+     "http://127.0.0.1:8080/1.0/kb/accounts/<ACCOUNT_ID>/paymentMethods?isDefault=true&pluginProperty=skip_gw=true"
+```
+
+Notes:
+* Make sure to replace *ACCOUNT_ID* with the id of the Kill Bill account
+* Remove `skip_gw=true` to store the credit card in the [PayU vault](http://docs.payulatam.com/en/api-integration/what-you-should-know-about-api-tokenization/)
+
+To trigger a payment:
+
+```
+curl -v \
+     -u admin:password \
+     -H "X-Killbill-ApiKey: bob" \
+     -H "X-Killbill-ApiSecret: lazar" \
+     -H "Content-Type: application/json" \
+     -H "X-Killbill-CreatedBy: demo" \
+     -X POST \
+     --data-binary '{"transactionType":"PURCHASE","amount":"500","currency":"BRL","transactionExternalKey":"INV-'$(uuidgen)'-PURCHASE"}' \
+    "http://127.0.0.1:8080/1.0/kb/accounts/<ACCOUNT_ID>/payments?pluginProperty=security_code=123"
+```
+
+Notes:
+* Make sure to replace *ACCOUNT_ID* with the id of the Kill Bill account
+* Required plugin properties (such as `security_code`) will depend on the [country](http://docs.payulatam.com/en/api-integration/api-payments/4132-2/)
+* To trigger payments in different countries, set `payment_processor_account_id=XXX` where XXX is one of colombia, panama, peru, mexico, argentina or brazil
+
+### HPP
+
+Add a payment method:
+
+```
+curl -v \
+     -u admin:password \
+     -H "X-Killbill-ApiKey: bob" \
+     -H "X-Killbill-ApiSecret: lazar" \
+     -H "Content-Type: application/json" \
+     -H "X-Killbill-CreatedBy: demo" \
+     -X POST \
+     --data-binary '{
+       "pluginName": "killbill-payu-latam",
+       "pluginInfo": {}
+     }' \
+     "http://127.0.0.1:8080/1.0/kb/accounts/<ACCOUNT_ID>/paymentMethods?isDefault=true&pluginProperty=skip_gw=true"
+```
+
+Notes:
+* Make sure to replace *ACCOUNT_ID* with the id of the Kill Bill account
+
+
+To create a voucher:
+
+```
+curl -v \
+     -u admin:password \
+     -H "X-Killbill-ApiKey: bob" \
+     -H "X-Killbill-ApiSecret: lazar" \
+     -H "Content-Type: application/json" \
+     -H "X-Killbill-CreatedBy: demo" \
+     -X POST \
+     --data-binary '{
+       "formFields": [
+         {
+           "key": "paymentMethod",
+           "value": "BALOTO"
+         },
+         {
+           "key": "name",
+           "value": "José Pérez"
+         },
+         {
+           "key": "email",
+           "value": "payu@killbill.io"
+         },
+         {
+           "key": "city",
+           "value": "Bogotá"
+         },
+         {
+           "key": "state",
+           "value": "Cundinamarca"
+         },
+         {
+           "key": "country",
+           "value": "CO"
+         },
+         {
+           "key": "amount",
+           "value": 400000
+         },
+         {
+           "key": "currency",
+           "value": "COP"
+         }
+       ]
+     }' \
+     "http://127.0.0.1:8080/1.0/kb/paymentGateways/hosted/form/<ACCOUNT_ID>"
+```
+
+Notes:
+* Make sure to replace *ACCOUNT_ID* with the id of the Kill Bill account
+
+
+Here is what happens behind the scenes:
+
+* The plugin creates the voucher in PayU.
+* The plugin creates the payment in Kill Bill. During the payment call, Kill Bill will call back the plugin, which will in turn create a row in the `responses` table (to keep track of the created vouchers in PayU). A Kill Bill transaction id will always match a unique voucher in PayU.
+* Kill Bill will start polling the plugin for the payment status, which it will get from PayU using the queries API.
+

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/killbill-payu-latam.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'killbill', '~> 3.2.0'
   s.add_dependency 'aktivemerchant', '~> 2.0.0'
-  s.add_dependency 'offsite_payments', '~> 2.0.1'
+  s.add_dependency 'koffsite_payments', '~> 3.0.0'
   s.add_dependency 'activerecord', '~> 4.1.0'
   s.add_dependency 'actionpack', '~> 4.1.0'
   s.add_dependency 'actionview', '~> 4.1.0'

data/lib/payu_latam.rb

@@ -8,6 +8,7 @@ require 'bigdecimal'
 require 'money'
 require 'monetize'
 require 'offsite_payments'
+require 'offsite_payments/integrations/pay_u_latam'
 require 'pathname'
 require 'sinatra'
 require 'singleton'

data/lib/payu_latam/api.rb

@@ -4,6 +4,7 @@ module Killbill #:nodoc:
 
       def initialize
         gateway_builder = Proc.new do |config|
+          ::OffsitePayments.mode = config[:test] ? :test : :production
           ::ActiveMerchant::Billing::PayULatamGateway.new :api_login          => config[:api_login],
                                                           :api_key            => config[:api_key],
                                                           :country_account_id => config[:country_account_id],
@@ -38,13 +39,32 @@ module Killbill #:nodoc:
       end
 
       def purchase_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
-        # Pass extra parameters for the gateway here
-        options = {}
-
-        add_required_options(properties, options)
-
-        properties = merge_properties(properties, options)
-        super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        # Direct payment?
+        if find_value_from_properties(properties, 'from_hpp') != 'true'
+          options = {}
+          add_required_options(properties, options)
+          properties = merge_properties(properties, options)
+          super(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, amount, currency, properties, context)
+        else
+          # Nope, HPP
+          payu_order_id                = find_value_from_properties(properties, 'payu_order_id')
+          payu_transaction_id          = find_value_from_properties(properties, 'payu_transaction_id')
+          payment_processor_account_id = find_value_from_properties(properties, 'payment_processor_account_id')
+
+          # Record a response row, to keep track of the created vouchers in PayU
+          response                     = @response_model.create(:api_call                     => :build_form_descriptor,
+                                                                :kb_account_id                => kb_account_id,
+                                                                :kb_payment_id                => kb_payment_id,
+                                                                :kb_payment_transaction_id    => kb_payment_transaction_id,
+                                                                :transaction_type             => :PURCHASE,
+                                                                :authorization                => [payu_order_id, payu_transaction_id].join(';'),
+                                                                :payment_processor_account_id => payment_processor_account_id,
+                                                                :kb_tenant_id                 => context.tenant_id,
+                                                                :success                      => true)
+
+          # Get the payment status from PayU (we are required to fetch the status from PayU within 7 minutes of the URL creation)
+          get_payment_transaction_info_from_payu(kb_payment_id, kb_payment_transaction_id, amount, currency, properties_to_hash(properties), context.tenant_id, response)
+        end
       end
 
       def void_payment(kb_account_id, kb_payment_id, kb_payment_transaction_id, kb_payment_method_id, properties, context)
@@ -78,11 +98,11 @@ module Killbill #:nodoc:
       end
 
       def get_payment_info(kb_account_id, kb_payment_id, properties, context)
-        # Pass extra parameters for the gateway here
-        options = {}
+        t_info_plugins = super(kb_account_id, kb_payment_id, properties, context)
 
-        properties = merge_properties(properties, options)
-        super(kb_account_id, kb_payment_id, properties, context)
+        t_info_plugins = get_payment_info_from_payu(kb_payment_id, properties_to_hash(properties), context) if t_info_plugins.empty?
+
+        t_info_plugins
       end
 
       def search_payments(search_key, offset, limit, properties, context)
@@ -146,22 +166,53 @@ module Killbill #:nodoc:
       end
 
       def build_form_descriptor(kb_account_id, descriptor_fields, properties, context)
-        # Pass extra parameters for the gateway here
-        options = {}
-        properties = merge_properties(properties, options)
-
-        # Add your custom static hidden tags here
-        options = {
-            #:token => config[:payu_latam][:token]
-        }
-        descriptor_fields = merge_properties(descriptor_fields, options)
-
-        super(kb_account_id, descriptor_fields, properties, context)
+        payu_hpp_credentials             = payu_hpp_credentials(properties_to_hash(properties))
+
+        # Prepare the PayU request
+        # Available fields:
+        #  * :expiration_date
+        #  * :customer (:name, :email, :phone, :dni_number)
+        #  * :billing_address (:address1, :city, :state, :country)
+        form_fields                      = properties_to_hash(descriptor_fields)
+        payu_reference_code              = form_fields[:externalKey] || SecureRandom.uuid
+        options                          = {
+            # Required fields
+            :order_id       => payu_reference_code,
+            :description    => form_fields['description'] || 'Kill Bill payment',
+            :payment_method => form_fields['paymentMethod'] || 'BALOTO',
+        }.merge(payu_hpp_credentials)
+        descriptor_fields                = merge_properties(descriptor_fields, options)
+
+        # Create the voucher
+        descriptor                       = super(kb_account_id, descriptor_fields, properties, context)
+        payu_response                    = properties_to_hash(descriptor.form_fields)
+        descriptor.form_url              = payu_response[:url]
+
+        # Create the payment in Kill Bill to start the polling
+        kb_account                       = @kb_apis.account_user_api.get_account_by_id(kb_account_id, context)
+        kb_payment_method_id             = (@kb_apis.payment_api.get_account_payment_methods(kb_account_id, false, [], context).find { |pm| pm.plugin_name == 'killbill-payu-latam' }).id
+        kb_payment_id                    = nil
+        payment_external_key             = payu_response[:order_id]
+        payment_transaction_external_key = payu_reference_code
+        # See purchase call above
+        properties                       = hash_to_properties(:from_hpp => true, :payu_order_id => payu_response[:order_id], :payu_transaction_id => payu_response[:transaction_id])
+
+        @kb_apis.payment_api.create_purchase(kb_account,
+                                             kb_payment_method_id,
+                                             kb_payment_id,
+                                             form_fields[:amount],
+                                             form_fields[:currency] || kb_account.currency,
+                                             payment_external_key,
+                                             payment_transaction_external_key,
+                                             properties,
+                                             context)
+
+        descriptor
       end
 
       def process_notification(notification, properties, context)
         # Pass extra parameters for the gateway here
-        options = {}
+        options    = {}
         properties = merge_properties(properties, options)
 
         super(notification, properties, context) do |gw_notification, service|
@@ -175,8 +226,81 @@ module Killbill #:nodoc:
 
       private
 
+      def get_payment_info_from_payu(kb_payment_id, options, context)
+        kb_payment = @kb_apis.payment_api.get_payment(kb_payment_id, false, [], context)
+
+        t_info_plugins = []
+        kb_payment.transactions.each do |transaction|
+          t_info_plugins << get_payment_transaction_info_from_payu(kb_payment_id, transaction.id, transaction.amount, transaction.currency, options, context.tenant_id)
+        end
+        t_info_plugins
+      end
+
+      def get_payment_transaction_info_from_payu(kb_payment_id, kb_payment_transaction_id, amount, currency, options, kb_tenant_id, response=nil)
+        # Guaranteed to have a unique mapping KB transaction <=> PayU HPP creation
+        response = @response_model.where("transaction_type = 'PURCHASE' AND kb_payment_id = '#{kb_payment_id}' AND kb_payment_transaction_id = '#{kb_payment_transaction_id}' AND kb_tenant_id = '#{kb_tenant_id}'").order(:created_at)[0] if response.nil?
+        raise "Unable to retrieve response for kb_payment_id=#{kb_payment_id}, kb_payment_transaction_id=#{kb_payment_transaction_id}, kb_tenant_id=#{kb_tenant_id}" if response.nil?
+
+        # Retrieve the transaction from PayU
+        order_id, transaction_id = response.authorization.split(';')
+        payu_status              = (get_payu_status(transaction_id, options) || {})[:status]
+
+        transaction = nil
+        if payu_status == 'APPROVED'
+          transaction = response.create_payu_latam_transaction(:kb_account_id                => response.kb_account_id,
+                                                               :kb_tenant_id                 => response.kb_tenant_id,
+                                                               :amount_in_cents              => amount,
+                                                               :currency                     => currency,
+                                                               :api_call                     => :purchase,
+                                                               :kb_payment_id                => kb_payment_id,
+                                                               :kb_payment_transaction_id    => kb_payment_transaction_id,
+                                                               :transaction_type             => response.transaction_type,
+                                                               :payment_processor_account_id => response.payment_processor_account_id,
+                                                               :txn_id                       => response.txn_id,
+                                                               :payu_latam_response_id       => response.id)
+        end
+
+        t_info_plugin        = response.to_transaction_info_plugin(transaction)
+        t_info_plugin.status = payu_status_to_plugin_status(payu_status)
+        t_info_plugin
+      end
+
+      def payu_status_to_plugin_status(payu_status)
+        if payu_status == 'APPROVED'
+          :PROCESSED
+        elsif payu_status == 'DECLINED' || payu_status == 'ERROR' || payu_status == 'EXPIRED'
+          :ERROR
+        elsif payu_status == 'PENDING'
+          :PENDING
+        else
+          :UNDEFINED
+        end
+      end
+
+      def get_payu_status(transaction_id, options)
+        options = payu_hpp_credentials(options)
+        helper  = get_active_merchant_module.const_get('Helper').new(nil, options.delete(:account_id), options)
+        helper.transaction_status(transaction_id)
+      end
+
+      def payu_hpp_credentials(options)
+        payment_processor_account_id = options[:payment_processor_account_id] || :default
+        gateway                      = lookup_gateway(payment_processor_account_id)
+
+        {
+            :credential2 => gateway.options[:api_login],
+            :credential3 => gateway.options[:api_key],
+            :credential4 => gateway.options[:country_account_id],
+            :account_id  => gateway.options[:merchant_id]
+        }
+      end
+
+      def get_active_merchant_module
+        ::OffsitePayments::Integrations::PayULatam
+      end
+
       def add_required_options(properties, options)
-        language = find_value_from_properties(properties, 'language') || 'en'
+        language           = find_value_from_properties(properties, 'language') || 'en'
         options[:language] ||= language
       end
     end

data/pom.xml

@@ -25,7 +25,7 @@
     <groupId>org.kill-bill.billing.plugin.ruby</groupId>
     <artifactId>payu-latam-plugin</artifactId>
     <packaging>pom</packaging>
-    <version>0.0.1</version>
+    <version>0.0.2</version>
     <name>payu-latam-plugin</name>
     <url>http://github.com/killbill/killbill-payu-latam-plugin</url>
     <description>Plugin for accessing PayuLatam as a payment gateway</description>

data/spec/payu_latam/base_plugin_spec.rb

@@ -28,34 +28,4 @@ describe Killbill::PayuLatam::PaymentPlugin do
   it 'should start and stop correctly' do
     @plugin.stop_plugin
   end
-
-  # No support for HPP
-
-  #xit 'should generate forms correctly' do
-  #  kb_account_id = SecureRandom.uuid
-  #  kb_tenant_id  = SecureRandom.uuid
-  #  context       = @plugin.kb_apis.create_context(kb_tenant_id)
-  #  fields        = @plugin.hash_to_properties({
-  #                                                 :order_id => '1234',
-  #                                                 :amount   => 10
-  #                                             })
-  #  form          = @plugin.build_form_descriptor kb_account_id, fields, [], context
-
-  #  form.kb_account_id.should == kb_account_id
-  #  form.form_method.should == 'POST'
-  #  form.form_url.should == 'https://payulatam.com'
-
-  #  form_fields = @plugin.properties_to_hash(form.form_fields)
-  #end
-
-  #xit 'should receive notifications correctly' do
-  #  description    = 'description'
-
-  #  kb_tenant_id = SecureRandom.uuid
-  #  context      = @plugin.kb_apis.create_context(kb_tenant_id)
-  #  properties   = @plugin.hash_to_properties({ :description => description })
-
-  #  notification    = ""
-  #  gw_notification = @plugin.process_notification notification, properties, context
-  #end
 end

data/spec/payu_latam/remote/integration_spec.rb

@@ -12,6 +12,17 @@ module ActiveMerchant #:nodoc:
   end
 end
 
+class PayUJavaPaymentApi < ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaPaymentApi
+
+  def get_account_payment_methods(kb_account_id, plugin_info, properties, context)
+    [OpenStruct.new(:plugin_name => 'killbill-payu-latam', :id => SecureRandom.uuid)]
+  end
+
+  def create_purchase(kb_account, kb_payment_method_id, kb_payment_id, amount, currency, payment_external_key, payment_transaction_external_key, properties, context)
+    add_payment(SecureRandom.uuid, SecureRandom.uuid, payment_transaction_external_key, :PURCHASE)
+  end
+end
+
 describe Killbill::PayuLatam::PaymentPlugin do
 
   include ::Killbill::Plugin::ActiveMerchant::RSpec
@@ -23,7 +34,7 @@ describe Killbill::PayuLatam::PaymentPlugin do
     @plugin = Killbill::PayuLatam::PaymentPlugin.new
 
     @account_api    = ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaUserAccountApi.new
-    @payment_api    = ::Killbill::Plugin::ActiveMerchant::RSpec::FakeJavaPaymentApi.new
+    @payment_api    = PayUJavaPaymentApi.new
     svcs            = {:account_user_api => @account_api, :payment_api => @payment_api}
     @plugin.kb_apis = Killbill::Plugin::KillbillApi.new('payu', svcs)
 
@@ -152,6 +163,66 @@ describe Killbill::PayuLatam::PaymentPlugin do
   #  payment_response.transaction_type.should == :VOID
   #end
 
+  # HPP
+  it 'should generate vouchers correctly' do
+    properties         = [create_pm_kv_info('payment_processor_account_id', 'colombia')]
+    nb_payments        = @payment_api.payments.size
+
+    # Generate the voucher
+    payment_properties = {
+        :externalKey => SecureRandom.uuid,
+        :amount      => 6000,
+        :currency    => 'COP'
+    }
+    descriptor_fields  = @plugin.hash_to_properties(payment_properties)
+    descriptor         = @plugin.build_form_descriptor(@pm.kb_account_id, descriptor_fields, properties, @plugin.kb_apis.create_context(@call_context.tenant_id))
+
+    # Verify the descriptor
+    descriptor.kb_account_id.should == @pm.kb_account_id
+    descriptor.form_method.should == 'GET'
+    descriptor.form_url.should_not be_nil
+    # For manual debugging
+    puts "Redirect to: #{descriptor.form_url}"
+    payu_order_id = @plugin.find_value_from_properties(descriptor.form_fields, 'order_id')
+    payu_order_id.should_not be_nil
+    payu_transaction_id = @plugin.find_value_from_properties(descriptor.form_fields, 'transaction_id')
+    payu_transaction_id.should_not be_nil
+
+    # Verify the pending payment has been created in Kill Bill
+    @payment_api.payments.size.should == nb_payments + 1
+    payment = @payment_api.payments[-1]
+    payment.transactions.size.should == 1
+    payment.transactions[0].external_key.should == payment_properties[:externalKey]
+
+    # Trigger manually the purchase call (this is done automatically in a live system)
+    properties << create_pm_kv_info('from_hpp', 'true')
+    properties << create_pm_kv_info('payu_order_id', payu_order_id)
+    properties << create_pm_kv_info('payu_transaction_id', payu_transaction_id)
+    payment_response = @plugin.purchase_payment(@pm.kb_account_id, payment.id, payment.transactions[0].id, @pm.id, payment_properties[:amount], payment_properties[:currency], properties, @plugin.kb_apis.create_context(@call_context.tenant_id))
+    payment_response.status.should == :PENDING
+
+    # Verify the response row was created
+    response = Killbill::PayuLatam::PayuLatamResponse.all[-1]
+    response.kb_account_id.should == @pm.kb_account_id
+    response.kb_payment_id.should == payment.id
+    response.kb_payment_transaction_id.should == payment.transactions[0].id
+    response.transaction_type.should == 'PURCHASE'
+    response.authorization.should == "#{payu_order_id};#{payu_transaction_id}"
+    response.payment_processor_account_id.should == 'colombia'
+    response.kb_tenant_id.should == @call_context.tenant_id
+
+    # Verify the payment in PayU
+    t_info_plugins = @plugin.get_payment_info(@pm.kb_account_id, payment.id, properties, @plugin.kb_apis.create_context(@call_context.tenant_id))
+    t_info_plugins.size.should == 1
+    t_info_plugin = t_info_plugins[0]
+    t_info_plugin.status.should == :PENDING
+    t_info_plugin.kb_payment_id.should == payment.id
+    t_info_plugin.kb_transaction_payment_id.should == payment.transactions[0].id
+    t_info_plugin.transaction_type.should == :PURCHASE
+    #t_info_plugin.amount.should == payment_properties[:amount]
+    #t_info_plugin.currency.should == payment_properties[:currency]
+  end
+
   private
 
   def valid_cc_info

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: killbill-payu-latam
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Kill Bill core team
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-12-01 00:00:00.000000000 Z
+date: 2015-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: killbill
@@ -39,17 +39,17 @@ dependencies:
   prerelease: false
   type: :runtime
 - !ruby/object:Gem::Dependency
-  name: offsite_payments
+  name: koffsite_payments
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: 3.0.0
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.0.1
+        version: 3.0.0
   prerelease: false
   type: :runtime
 - !ruby/object:Gem::Dependency