killbill-stripe 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70736e813db9a21f0144ef12503a5e257978d083
+  data.tar.gz: f620f84e2a4da96f51fbb70a0b1c5c2b39a42303
+SHA512:
+  metadata.gz: 5991a3693fdfb78f398bcde89f8113fed5ad72fe6d58d17ea8bd887a4cc570fafab74d1d43014ef1b16af26732c967a6d3fb9a5992c70d0c9bc206210f49173a
+  data.tar.gz: 8ed1cc06a9801512930f089a1d9e90143c224272c411cea8ff043c93cd90cc89e79d715a498eabf4eac63af6de3a9bae3a16ee904f88ca24e4f3713ed23e0958

data/.gitignore

@@ -0,0 +1,39 @@
+*.gem
+*.rbc
+*.swp
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+.jbundler
+Jarfile.lock
+Gemfile.lock
+
+.DS_Store
+
+# Build directory
+killbill-stripe/
+
+# Config file
+stripe.yml
+
+# Testing database
+test.db
+
+target
+pom.xml.asc
+
+.idea/

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+
+notifications:
+  email:
+    - kill-bill-commits@googlegroups.com
+
+rvm:
+  - jruby-19mode
+  - jruby-20mode
+  - jruby-head
+
+jdk:
+  - openjdk6
+  - openjdk7
+  - oraclejdk7
+
+matrix:
+  allow_failures:
+    - rvm: jruby-head

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Jarfile

@@ -0,0 +1,6 @@
+jar 'org.kill-bill.billing:killbill-api', '0.8.2'
+jar 'org.kill-bill.billing.plugin:killbill-plugin-api-notification', '0.6.4'
+jar 'org.kill-bill.billing.plugin:killbill-plugin-api-payment', '0.6.4'
+jar 'org.kill-bill.billing.plugin:killbill-plugin-api-currency', '0.6.4'
+jar 'org.kill-bill.billing:killbill-util:tests', '0.9.1'
+jar 'javax.servlet:javax.servlet-api', '3.0.1'

data/NEWS

@@ -0,0 +1,2 @@
+0.1.0
+    Initial release

data/README.md

@@ -0,0 +1,21 @@
+killbill-stripe-plugin
+======================
+
+Killbill payment plugin for Stripe.
+
+Getting started
+---------------
+
+1. Make sure you can build the project by running the smoke tests: `mvn clean test`
+2. Go to [stripe.com](http://stripe.com/) and create an account. This account will be used as a sandbox environment for testing.
+3. In your Stripe account, click on **Your Account** (top right), then click on **Account Settings** and then on the **API Keys** tab. Write down your Test Secret Key.
+4. Verify the setup by running the killbill-stripe-plugin integration tests (make sure to update your API Key): `mvn clean test -Pintegration -Dkillbill.payment.stripe.apiKey=1234567689abcdef`
+5. Go to your Stripe account, you should see some data (e.g. account created).
+6. Congrats! You're all set!
+
+Build
+-----
+
+To build the project, use maven:
+
+    mvn clean install

data/Rakefile

@@ -0,0 +1,30 @@
+#!/usr/bin/env rake
+
+# Install tasks to build and release the plugin
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+
+# Install test tasks
+require 'rspec/core/rake_task'
+namespace :test do
+  desc "Run RSpec tests"
+  RSpec::Core::RakeTask.new do |task|
+    task.name = 'spec'
+    task.pattern = './spec/*/*_spec.rb'
+  end
+
+  namespace :remote do
+    desc "Run RSpec remote tests"
+    RSpec::Core::RakeTask.new do |task|
+      task.name = 'spec'
+      task.pattern = './spec/*/remote/*_spec.rb'
+    end
+  end
+end
+
+# Install tasks to package the plugin for Killbill
+require 'killbill/rake_task'
+Killbill::PluginHelper.install_tasks
+
+# Run tests by default
+task :default => 'test:spec'

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/config.ru

@@ -0,0 +1,4 @@
+require 'stripe'
+require 'stripe/config/application'
+
+run Sinatra::Application

data/db/ddl.sql

@@ -0,0 +1,99 @@
+CREATE TABLE `stripe_payment_methods` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `kb_account_id` varchar(255) NOT NULL,
+  `kb_payment_method_id` varchar(255) DEFAULT NULL,
+  `stripe_customer_id` varchar(255) DEFAULT NULL,
+  `stripe_card_id_or_token` varchar(255) NOT NULL,
+  `cc_first_name` varchar(255) DEFAULT NULL,
+  `cc_last_name` varchar(255) DEFAULT NULL,
+  `cc_type` varchar(255) DEFAULT NULL,
+  `cc_exp_month` int(11) DEFAULT NULL,
+  `cc_exp_year` int(11) DEFAULT NULL,
+  `cc_last_4` int(11) DEFAULT NULL,
+  `address1` varchar(255) DEFAULT NULL,
+  `address2` varchar(255) DEFAULT NULL,
+  `city` varchar(255) DEFAULT NULL,
+  `state` varchar(255) DEFAULT NULL,
+  `zip` varchar(255) DEFAULT NULL,
+  `country` varchar(255) DEFAULT NULL,
+  `is_deleted` tinyint(1) NOT NULL DEFAULT '0',
+  `created_at` datetime NOT NULL,
+  `updated_at` datetime NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `index_stripe_payment_methods_on_kb_account_id` (`kb_account_id`),
+  KEY `index_stripe_payment_methods_on_kb_payment_method_id` (`kb_payment_method_id`)
+) ENGINE=InnoDB CHARACTER SET utf8 COLLATE utf8_bin;
+
+CREATE TABLE `stripe_transactions` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `stripe_response_id` int(11) NOT NULL,
+  `api_call` varchar(255) NOT NULL,
+  `kb_payment_id` varchar(255) NOT NULL,
+  `stripe_txn_id` varchar(255) NOT NULL,
+  `amount_in_cents` int(11) NOT NULL,
+  `currency` char(3) NOT NULL,
+  `created_at` datetime NOT NULL,
+  `updated_at` datetime NOT NULL,
+  PRIMARY KEY (`id`),
+  KEY `index_stripe_transactions_on_kb_payment_id` (`kb_payment_id`)
+) ENGINE=InnoDB CHARACTER SET utf8 COLLATE utf8_bin;
+
+CREATE TABLE `stripe_responses` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `api_call` varchar(255) NOT NULL,
+  `kb_payment_id` varchar(255) DEFAULT NULL,
+  `message` varchar(255) DEFAULT NULL,
+  `authorization` varchar(255) DEFAULT NULL,
+  `fraud_review` tinyint(1) DEFAULT NULL,
+  `test` tinyint(1) DEFAULT NULL,
+  `params_id` varchar(255) DEFAULT NULL,
+  `params_object` varchar(255) DEFAULT NULL,
+  `params_created` varchar(255) DEFAULT NULL,
+  `params_livemode` varchar(255) DEFAULT NULL,
+  `params_paid` varchar(255) DEFAULT NULL,
+  `params_amount` varchar(255) DEFAULT NULL,
+  `params_currency` varchar(255) DEFAULT NULL,
+  `params_refunded` varchar(255) DEFAULT NULL,
+  `params_card_id` varchar(255) DEFAULT NULL,
+  `params_card_object` varchar(255) DEFAULT NULL,
+  `params_card_last4` varchar(255) DEFAULT NULL,
+  `params_card_type` varchar(255) DEFAULT NULL,
+  `params_card_exp_month` varchar(255) DEFAULT NULL,
+  `params_card_exp_year` varchar(255) DEFAULT NULL,
+  `params_card_fingerprint` varchar(255) DEFAULT NULL,
+  `params_card_customer` varchar(255) DEFAULT NULL,
+  `params_card_country` varchar(255) DEFAULT NULL,
+  `params_card_name` varchar(255) DEFAULT NULL,
+  `params_card_address_line1` varchar(255) DEFAULT NULL,
+  `params_card_address_line2` varchar(255) DEFAULT NULL,
+  `params_card_address_city` varchar(255) DEFAULT NULL,
+  `params_card_address_state` varchar(255) DEFAULT NULL,
+  `params_card_address_zip` varchar(255) DEFAULT NULL,
+  `params_card_address_country` varchar(255) DEFAULT NULL,
+  `params_card_cvc_check` varchar(255) DEFAULT NULL,
+  `params_card_address_line1_check` varchar(255) DEFAULT NULL,
+  `params_card_address_zip_check` varchar(255) DEFAULT NULL,
+  `params_captured` varchar(255) DEFAULT NULL,
+  `params_refunds` varchar(255) DEFAULT NULL,
+  `params_balance_transaction` varchar(255) DEFAULT NULL,
+  `params_failure_message` varchar(255) DEFAULT NULL,
+  `params_failure_code` varchar(255) DEFAULT NULL,
+  `params_amount_refunded` varchar(255) DEFAULT NULL,
+  `params_customer` varchar(255) DEFAULT NULL,
+  `params_invoice` varchar(255) DEFAULT NULL,
+  `params_description` varchar(255) DEFAULT NULL,
+  `params_dispute` varchar(255) DEFAULT NULL,
+  `params_metadata` varchar(255) DEFAULT NULL,
+  `params_error_type` varchar(255) DEFAULT NULL,
+  `params_error_message` varchar(255) DEFAULT NULL,
+  `avs_result_code` varchar(255) DEFAULT NULL,
+  `avs_result_message` varchar(255) DEFAULT NULL,
+  `avs_result_street_match` varchar(255) DEFAULT NULL,
+  `avs_result_postal_match` varchar(255) DEFAULT NULL,
+  `cvv_result_code` varchar(255) DEFAULT NULL,
+  `cvv_result_message` varchar(255) DEFAULT NULL,
+  `success` tinyint(1) DEFAULT NULL,
+  `created_at` datetime NOT NULL,
+  `updated_at` datetime NOT NULL,
+  PRIMARY KEY (`id`)
+) ENGINE=InnoDB CHARACTER SET utf8 COLLATE utf8_bin;

data/db/schema.rb

@@ -0,0 +1,99 @@
+require 'active_record'
+
+ActiveRecord::Schema.define(:version => 20130311153635) do
+  create_table "stripe_payment_methods", :force => true do |t|
+    t.string   "kb_account_id",          :null => false
+    t.string   "kb_payment_method_id"    # NULL before Killbill knows about it
+    t.string   "stripe_customer_id"
+    t.string   "stripe_card_id_or_token",:null => false
+    t.string   "cc_first_name"
+    t.string   "cc_last_name"
+    t.string   "cc_type"
+    t.integer  "cc_exp_month"
+    t.integer  "cc_exp_year"
+    t.integer  "cc_last_4"
+    t.string   "address1"
+    t.string   "address2"
+    t.string   "city"
+    t.string   "state"
+    t.string   "zip"
+    t.string   "country"
+    t.boolean  "is_deleted",             :null => false, :default => false
+    t.datetime "created_at",             :null => false
+    t.datetime "updated_at",             :null => false
+  end
+
+  add_index(:stripe_payment_methods, :kb_account_id)
+  add_index(:stripe_payment_methods, :kb_payment_method_id)
+
+  create_table "stripe_transactions", :force => true do |t|
+    t.integer  "stripe_response_id",  :null => false
+    t.string   "api_call",            :null => false
+    t.string   "kb_payment_id",       :null => false
+    t.string   "stripe_txn_id",       :null => false
+    t.integer  "amount_in_cents",     :null => false
+    t.string   "currency",            :null => false
+    t.datetime "created_at",          :null => false
+    t.datetime "updated_at",          :null => false
+  end
+
+  add_index(:stripe_transactions, :kb_payment_id)
+
+  create_table "stripe_responses", :force => true do |t|
+    t.string   "api_call",         :null => false
+    t.string   "kb_payment_id"
+    t.string   "message"
+    t.string   "authorization"
+    t.boolean  "fraud_review"
+    t.boolean  "test"
+    t.string   "params_id"
+    t.string   "params_object"
+    t.string   "params_created"
+    t.string   "params_livemode"
+    t.string   "params_paid"
+    t.string   "params_amount"
+    t.string   "params_currency"
+    t.string   "params_refunded"
+    t.string   "params_card_id"
+    t.string   "params_card_object"
+    t.string   "params_card_last4"
+    t.string   "params_card_type"
+    t.string   "params_card_exp_month"
+    t.string   "params_card_exp_year"
+    t.string   "params_card_fingerprint"
+    t.string   "params_card_customer"
+    t.string   "params_card_country"
+    t.string   "params_card_name"
+    t.string   "params_card_address_line1"
+    t.string   "params_card_address_line2"
+    t.string   "params_card_address_city"
+    t.string   "params_card_address_state"
+    t.string   "params_card_address_zip"
+    t.string   "params_card_address_country"
+    t.string   "params_card_cvc_check"
+    t.string   "params_card_address_line1_check"
+    t.string   "params_card_address_zip_check"
+    t.string   "params_captured"
+    t.string   "params_refunds"
+    t.string   "params_balance_transaction"
+    t.string   "params_failure_message"
+    t.string   "params_failure_code"
+    t.string   "params_amount_refunded"
+    t.string   "params_customer"
+    t.string   "params_invoice"
+    t.string   "params_description"
+    t.string   "params_dispute"
+    t.string   "params_metadata"
+    t.string   "params_error_type"
+    t.string   "params_error_message"
+    t.string   "avs_result_code"
+    t.string   "avs_result_message"
+    t.string   "avs_result_street_match"
+    t.string   "avs_result_postal_match"
+    t.string   "cvv_result_code"
+    t.string   "cvv_result_message"
+    t.boolean  "success"
+    t.datetime "created_at",       :null => false
+    t.datetime "updated_at",       :null => false
+  end
+end

data/killbill-stripe.gemspec

@@ -0,0 +1,42 @@
+version = File.read(File.expand_path('../VERSION', __FILE__)).strip
+
+Gem::Specification.new do |s|
+  s.name        = 'killbill-stripe'
+  s.version     = version
+  s.summary     = 'Plugin to use Stripe as a gateway.'
+  s.description = 'Kill Bill payment plugin for Stripe.'
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.license = 'Apache License (2.0)'
+
+  s.author   = 'Kill Bill core team'
+  s.email    = 'killbilling-users@googlegroups.com'
+  s.homepage = 'http://kill-bill.org'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.bindir        = 'bin'
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.rdoc_options << '--exclude' << '.'
+
+  s.add_dependency 'killbill', '~> 3.0.0'
+  s.add_dependency 'activemerchant', '~> 1.42.3'
+  s.add_dependency 'activerecord', '~> 3.2.1'
+  s.add_dependency 'money', '~> 6.0.0'
+  s.add_dependency 'sinatra', '~> 1.3.4'
+  if defined?(JRUBY_VERSION)
+    s.add_dependency 'activerecord-jdbcmysql-adapter', '~> 1.2.9'
+  end
+
+  s.add_development_dependency 'jbundler', '~> 0.4.1'
+  s.add_development_dependency 'rake', '>= 10.0.0'
+  s.add_development_dependency 'rspec', '~> 2.12.0'
+  if defined?(JRUBY_VERSION)
+    s.add_development_dependency 'activerecord-jdbcsqlite3-adapter', '~> 1.2.6'
+  else
+    s.add_development_dependency 'sqlite3', '~> 1.3.7'
+  end
+end

data/killbill.properties

@@ -0,0 +1,3 @@
+mainClass=Killbill::Stripe::PaymentPlugin
+require=stripe
+pluginType=PAYMENT

data/lib/stripe/api.rb

@@ -0,0 +1,248 @@
+module Killbill::Stripe
+  class PaymentPlugin < Killbill::Plugin::Payment
+    def start_plugin
+      Killbill::Stripe.initialize! @logger, @conf_dir, @kb_apis
+
+      super
+
+      @logger.info 'Killbill::Stripe::PaymentPlugin started'
+    end
+
+    # return DB connections to the Pool if required
+    def after_request
+      ActiveRecord::Base.connection.close
+    end
+
+    def process_payment(kb_account_id, kb_payment_id, kb_payment_method_id, amount, currency, call_context = nil, options = {})
+      # Use Money to compute the amount in cents, as it depends on the currency (1 cent of BTC is 1 Satoshi, not 0.01 BTC)
+      amount_in_cents = Money.new_with_amount(amount, currency).cents.to_i
+
+      # If the payment was already made, just return the status
+      stripe_transaction = StripeTransaction.from_kb_payment_id(kb_payment_id) rescue nil
+      return stripe_transaction.stripe_response.to_payment_response unless stripe_transaction.nil?
+
+      options[:order_id] ||= kb_payment_id
+      options[:currency] ||= currency.to_s.upcase
+      options[:description] ||= Killbill::Stripe.stripe_payment_description || "Kill Bill payment for #{kb_payment_id}"
+
+      # Retrieve the Stripe payment method
+      pm = StripePaymentMethod.from_kb_payment_method_id(kb_payment_method_id)
+      options[:customer] ||= pm.stripe_customer_id
+
+      # Go to Stripe
+      stripe_response = Killbill::Stripe.gateway.purchase amount_in_cents, pm.stripe_card_id_or_token, options
+      response = save_response_and_transaction stripe_response, :charge, kb_payment_id, amount_in_cents, currency
+
+      response.to_payment_response
+    end
+
+    def get_payment_info(kb_account_id, kb_payment_id, tenant_context = nil, options = {})
+      # We assume the payment is immutable in Stripe and only look at our tables
+      stripe_transaction = StripeTransaction.from_kb_payment_id(kb_payment_id)
+      stripe_transaction.stripe_response.to_payment_response
+    end
+
+    def process_refund(kb_account_id, kb_payment_id, amount, currency, call_context = nil, options = {})
+      # Use Money to compute the amount in cents, as it depends on the currency (1 cent of BTC is 1 Satoshi, not 0.01 BTC)
+      amount_in_cents = Money.new_with_amount(amount, currency).cents.to_i
+
+      stripe_transaction = StripeTransaction.find_candidate_transaction_for_refund(kb_payment_id, amount_in_cents)
+
+      # Go to Stripe
+      stripe_response = Killbill::Stripe.gateway.refund amount_in_cents, stripe_transaction.stripe_txn_id, options
+      response = save_response_and_transaction stripe_response, :refund, kb_payment_id, amount_in_cents, currency
+
+      response.to_refund_response
+    end
+
+    def get_refund_info(kb_account_id, kb_payment_id, tenant_context = nil, options = {})
+      # We assume the refund is immutable in Stripe and only look at our tables
+      stripe_transactions = StripeTransaction.refunds_from_kb_payment_id(kb_payment_id)
+
+      stripe_transactions.map { |t| t.stripe_response.to_refund_response }
+    end
+
+    def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, call_context = nil, options = {})
+      # Do we have a customer for that account already?
+      stripe_customer_id = StripePaymentMethod.stripe_customer_id_from_kb_account_id(kb_account_id)
+
+      # This will either update the current customer if present, or create a new one
+      options[:customer] ||= stripe_customer_id
+      options[:set_default] ||= set_default
+
+      # Magic field, see also private_api.rb (works only when creating an account)
+      if options[:customer].blank?
+        options[:description] ||= kb_account_id
+      else
+        options[:description] = nil
+      end
+
+      # Registering a card or a token from Stripe.js?
+      cc_or_token = find_value_from_payment_method_props(payment_method_props, 'token') || find_value_from_payment_method_props(payment_method_props, 'cardId')
+      if cc_or_token.blank?
+        # Nope - real credit card
+        cc_or_token = ActiveMerchant::Billing::CreditCard.new(
+              :number             => find_value_from_payment_method_props(payment_method_props, 'ccNumber'),
+              :month              => find_value_from_payment_method_props(payment_method_props, 'ccExpirationMonth'),
+              :year               => find_value_from_payment_method_props(payment_method_props, 'ccExpirationYear'),
+              :verification_value => find_value_from_payment_method_props(payment_method_props, 'ccVerificationValue'),
+              :first_name         => find_value_from_payment_method_props(payment_method_props, 'ccFirstName'),
+              :last_name          => find_value_from_payment_method_props(payment_method_props, 'ccLastName')
+        )
+      end
+
+      options[:billing_address] ||= {
+              :address1           => find_value_from_payment_method_props(payment_method_props, 'address1'),
+              :address2           => find_value_from_payment_method_props(payment_method_props, 'address2'),
+              :city               => find_value_from_payment_method_props(payment_method_props, 'city'),
+              :zip                => find_value_from_payment_method_props(payment_method_props, 'zip'),
+              :state              => find_value_from_payment_method_props(payment_method_props, 'state'),
+              :country            => find_value_from_payment_method_props(payment_method_props, 'country')
+      }
+
+      # Go to Stripe
+      stripe_response = Killbill::Stripe.gateway.store cc_or_token, options
+      response = save_response_and_transaction stripe_response, :add_payment_method
+
+      if response.success
+        unless stripe_customer_id.blank?
+          card_response = stripe_response.responses.first.params
+          customer_response = stripe_response.responses.last.params
+        else
+          card_response = stripe_response.params['cards']['data'][0]
+          customer_response = stripe_response.params
+        end
+
+        StripePaymentMethod.create :kb_account_id => kb_account_id,
+                                   :kb_payment_method_id => kb_payment_method_id,
+                                   :stripe_customer_id => customer_response['id'],
+                                   :stripe_card_id_or_token => card_response['id'],
+                                   :cc_first_name => card_response['name'],
+                                   :cc_last_name => nil,
+                                   :cc_type => card_response['type'],
+                                   :cc_exp_month => card_response['exp_month'],
+                                   :cc_exp_year => card_response['exp_year'],
+                                   :cc_last_4 => card_response['last4'],
+                                   :address1 => card_response['address_line1'],
+                                   :address2 => card_response['address_line2'],
+                                   :city => card_response['address_city'],
+                                   :state => card_response['address_state'],
+                                   :zip => card_response['address_zip'],
+                                   :country => card_response['address_country']
+      else
+        raise response.message
+      end
+    end
+
+    def delete_payment_method(kb_account_id, kb_payment_method_id, call_context = nil, options = {})
+      pm = StripePaymentMethod.from_kb_payment_method_id(kb_payment_method_id)
+
+      # Delete the card on the customer object
+      stripe_response = Killbill::Stripe.gateway.unstore(pm.stripe_customer_id, pm.stripe_card_id_or_token)
+      response = save_response_and_transaction stripe_response, :delete_payment_method
+
+      if response.success
+        StripePaymentMethod.mark_as_deleted! kb_payment_method_id
+      else
+        raise response.message
+      end
+    end
+
+    def get_payment_method_detail(kb_account_id, kb_payment_method_id, tenant_context = nil, options = {})
+      StripePaymentMethod.from_kb_payment_method_id(kb_payment_method_id).to_payment_method_response
+    end
+
+    def set_default_payment_method(kb_account_id, kb_payment_method_id, call_context = nil, options = {})
+      pm = StripePaymentMethod.from_kb_payment_method_id(kb_payment_method_id)
+
+      # Update the default payment method on the customer object
+      stripe_response = Killbill::Stripe.gateway.update_customer(pm.stripe_customer_id, :default_card => pm.stripe_card_id_or_token)
+      response = save_response_and_transaction stripe_response, :set_default_payment_method
+
+      if response.success
+        # TODO Update our records
+      else
+        raise response.message
+      end
+    end
+
+    def get_payment_methods(kb_account_id, refresh_from_gateway = false, call_context = nil, options = {})
+      StripePaymentMethod.from_kb_account_id(kb_account_id).collect { |pm| pm.to_payment_method_info_response }
+    end
+
+    def reset_payment_methods(kb_account_id, payment_methods)
+      return if payment_methods.nil?
+
+      stripe_pms = StripePaymentMethod.from_kb_account_id(kb_account_id)
+
+      payment_methods.delete_if do |payment_method_info_plugin|
+        should_be_deleted = false
+        stripe_pms.each do |stripe_pm|
+          # Do stripe_pm and payment_method_info_plugin represent the same Stripe payment method?
+          if stripe_pm.external_payment_method_id == payment_method_info_plugin.external_payment_method_id
+            # Do we already have a kb_payment_method_id?
+            if stripe_pm.kb_payment_method_id == payment_method_info_plugin.payment_method_id
+              should_be_deleted = true
+              break
+            elsif stripe_pm.kb_payment_method_id.nil?
+              # We didn't have the kb_payment_method_id - update it
+              stripe_pm.kb_payment_method_id = payment_method_info_plugin.payment_method_id
+              should_be_deleted = stripe_pm.save
+              break
+              # Otherwise the same card points to 2 different kb_payment_method_id. This should never happen,
+              # but we cowardly will insert a second row below
+            end
+          end
+        end
+
+        should_be_deleted
+      end
+
+      # The remaining elements in payment_methods are not in our table (this should never happen?!)
+      payment_methods.each do |payment_method_info_plugin|
+        StripePaymentMethod.create :kb_account_id => kb_account_id,
+                                   :kb_payment_method_id => payment_method_info_plugin.payment_method_id,
+                                   :stripe_card_id_or_token => payment_method_info_plugin.external_payment_method_id
+      end
+    end
+
+    def search_payments(search_key, offset = 0, limit = 100, call_context = nil, options = {})
+      StripeResponse.search(search_key, offset, limit, :payment)
+    end
+
+    def search_refunds(search_key, offset = 0, limit = 100, call_context = nil, options = {})
+      StripeResponse.search(search_key, offset, limit, :refund)
+    end
+
+    def search_payment_methods(search_key, offset = 0, limit = 100, call_context = nil, options = {})
+      StripePaymentMethod.search(search_key, offset, limit)
+    end
+
+    private
+
+    def find_value_from_payment_method_props(payment_method_props, key)
+      return payment_method_props[key] if payment_method_props.is_a? Hash
+      prop = (payment_method_props.properties.find { |kv| kv.key == key })
+      prop.nil? ? nil : prop.value
+    end
+
+    def save_response_and_transaction(stripe_response, api_call, kb_payment_id=nil, amount_in_cents=0, currency=nil)
+      @logger.warn "Unsuccessful #{api_call}: #{stripe_response.message}" unless stripe_response.success?
+
+      # Save the response to our logs
+      response = StripeResponse.from_response(api_call, kb_payment_id, stripe_response)
+      response.save!
+
+      if response.success and !kb_payment_id.blank? and !response.stripe_txn_id.blank?
+        # Record the transaction
+        transaction = response.create_stripe_transaction!(:amount_in_cents => amount_in_cents,
+                                                          :currency => currency,
+                                                          :api_call => api_call,
+                                                          :kb_payment_id => kb_payment_id,
+                                                          :stripe_txn_id => response.stripe_txn_id)
+        @logger.debug "Recorded transaction: #{transaction.inspect}"
+      end
+      response
+    end
+  end
+end