killbill-litle 1.0.1

data/.gitignore

@@ -0,0 +1,36 @@
+*.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-litle/
+
+# Config file
+litle.yml
+
+# Testing database
+test.db
+
+target

data/.travis.yml

@@ -0,0 +1,18 @@
+language: ruby
+
+notifications:
+  email:
+    - killbilling-dev@googlegroups.com
+
+rvm:
+  - jruby-19mode
+  - jruby-head
+
+jdk:
+  - openjdk7
+  - oraclejdk7
+  - openjdk6
+
+matrix:
+  allow_failures:
+    - rvm: jruby-head

data/Gemfile

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

data/Jarfile

@@ -0,0 +1,3 @@
+jar 'com.ning.billing:killbill-api', '0.1.63'
+jar 'com.ning.billing:killbill-util:tests', '0.1.63'
+jar 'javax.servlet:javax.servlet-api', '3.0.1'

data/README.md

@@ -0,0 +1,7 @@
+[![Build Status](https://travis-ci.org/killbill/killbill-litle-plugin.png)](https://travis-ci.org/killbill/killbill-litle-plugin)
+[![Code Climate](https://codeclimate.com/github/killbill/killbill-litle-plugin.png)](https://codeclimate.com/github/killbill/killbill-litle-plugin)
+
+killbill-litle-plugin
+=====================
+
+Plugin to use Litle & Co. as a gateway

data/Rakefile

@@ -0,0 +1,17 @@
+#!/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'
+desc "Run RSpec"
+RSpec::Core::RakeTask.new
+
+# Install tasks to package the plugin for Killbill
+require 'killbill/rake_task'
+Killbill::PluginHelper.install_tasks
+
+# Run tests by default
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+1.0.1

data/config.ru

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

data/db/schema.rb

@@ -0,0 +1,53 @@
+require 'active_record'
+
+ActiveRecord::Schema.define(:version => 20130311153635) do
+  create_table "litle_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   "litle_token",            :null => false
+    t.boolean  "is_deleted",             :null => false, :default => false
+    t.datetime "created_at",             :null => false
+    t.datetime "updated_at",             :null => false
+  end
+
+  create_table "litle_transactions", :force => true do |t|
+    t.integer  "litle_response_id", :null => false
+    t.string   "api_call",          :null => false
+    t.string   "kb_payment_id",     :null => false
+    t.string   "litle_txn_id",      :null => false
+    t.integer  "amount_in_cents",   :null => false
+    t.datetime "created_at",        :null => false
+    t.datetime "updated_at",        :null => false
+  end
+
+  create_table "litle_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_litleonelineresponse_message"
+    t.string   "params_litleonelineresponse_response"
+    t.string   "params_litleonelineresponse_version"
+    t.string   "params_litleonelineresponse_xmlns"
+    t.string   "params_litleonelineresponse_saleresponse_customer_id"
+    t.string   "params_litleonelineresponse_saleresponse_id"
+    t.string   "params_litleonelineresponse_saleresponse_report_group"
+    t.string   "params_litleonelineresponse_saleresponse_litle_txn_id"
+    t.string   "params_litleonelineresponse_saleresponse_order_id"
+    t.string   "params_litleonelineresponse_saleresponse_response"
+    t.string   "params_litleonelineresponse_saleresponse_response_time"
+    t.string   "params_litleonelineresponse_saleresponse_message"
+    t.string   "params_litleonelineresponse_saleresponse_auth_code"
+    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-litle.gemspec

@@ -0,0 +1,45 @@
+version = File.read(File.expand_path('../VERSION', __FILE__)).strip
+
+Gem::Specification.new do |s|
+  s.name        = 'killbill-litle'
+  s.version     = version
+  s.summary     = 'Plugin to use Litle & Co. as a gateway.'
+  s.description = 'Killbill payment plugin for Litle & Co.'
+
+  s.required_ruby_version = '>= 1.9.3'
+
+  s.license = 'Apache License (2.0)'
+
+  s.author   = 'Killbill core team'
+  s.email    = 'killbilling-users@googlegroups.com'
+  s.homepage = 'http://www.killbilling.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', '~> 1.0.12'
+  s.add_dependency 'activemerchant', '~> 1.31.1'
+  s.add_dependency 'activerecord', '~> 3.2.1'
+  s.add_dependency 'sinatra', '~> 1.3.4'
+  # LitleOnline gem dependencies
+  s.add_dependency 'LitleOnline', '~> 8.16.0'
+  s.add_dependency 'xml-mapping', '~> 0.9.1'
+  s.add_dependency 'xml-object', '~> 0.9.93'
+  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::Litle::PaymentPlugin
+require=litle
+pluginType=PAYMENT

data/lib/litle/api.rb

@@ -0,0 +1,119 @@
+module Killbill::Litle
+  class PaymentPlugin < Killbill::Plugin::Payment
+    def start_plugin
+      Killbill::Litle.initialize! "#{@root}/litle.yml", @logger
+      @gateway = Killbill::Litle.gateway
+
+      super
+
+      @logger.info "Killbill::Litle::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_in_cents, currency, options = {})
+      # Required argument
+      # Note! The field is limited to 25 chars, so we convert the UUID (in hex) to base64
+      options[:order_id] ||= Utils.compact_uuid kb_payment_id
+
+      # Set a default report group
+      options[:merchant] ||= report_group_for_currency(currency)
+      # Retrieve the Litle token
+      token = get_token(kb_payment_method_id)
+
+      # Go to Litle
+      litle_response = @gateway.purchase amount_in_cents, token, options
+      response = save_response_and_transaction litle_response, :charge, kb_payment_id, amount_in_cents
+
+      response.to_payment_response
+    end
+
+    def process_refund(kb_account_id, kb_payment_id, amount_in_cents, currency, options = {})
+      # Find one successful charge which amount is at least the amount we are trying to refund
+      litle_transaction = LitleTransaction.where("litle_transactions.amount_in_cents >= ?", amount_in_cents).find_last_by_api_call_and_kb_payment_id(:charge, kb_payment_id)
+      raise "Unable to find Litle transaction id for payment #{kb_payment_id}" if litle_transaction.nil?
+
+      # Set a default report group
+      options[:merchant] ||= report_group_for_currency(currency)
+
+      # Go to Litle
+      litle_response = @gateway.credit amount_in_cents, litle_transaction.litle_txn_id, options
+      response = save_response_and_transaction litle_response, :refund, kb_payment_id, amount_in_cents
+
+      response.to_refund_response
+    end
+
+    def get_payment_info(kb_account_id, kb_payment_id, options = {})
+      # We assume the payment is immutable in Litle and only look at our tables since there
+      # doesn't seem to be a Litle API to fetch details for a given transaction.
+      # TODO How can we support Authorization/Sale Recycling?
+      litle_transaction = LitleTransaction.from_kb_payment_id(kb_payment_id)
+
+      litle_transaction.litle_response.to_payment_response
+    end
+
+    def add_payment_method(kb_account_id, kb_payment_method_id, payment_method_props, set_default, options = {})
+      # Set a default report group
+      options[:merchant] ||= report_group_for_account(kb_account_id)
+
+      cc = ActiveMerchant::Billing::CreditCard.new(:number => payment_method_props.value_string('number'), :description => kb_payment_method_id)
+      litle_response = @gateway.store cc, options
+      response = save_response_and_transaction litle_response, :add_payment_method
+
+      LitlePaymentMethod.create :kb_account_id => kb_account_id, :kb_payment_method_id => kb_payment_method_id, :litle_token => response.litle_token
+    end
+
+    def delete_payment_method(kb_account_id, kb_payment_method_id, options = {})
+      LitlePaymentMethod.mark_as_deleted! kb_payment_method_id
+    end
+
+    def get_payment_method_detail(kb_account_id, kb_payment_method_id, options = {})
+      LitlePaymentMethod.from_kb_payment_method_id(kb_payment_method_id).to_payment_method_response
+    end
+
+    def get_payment_methods(kb_account_id, refresh_from_gateway = false, options = {})
+      LitlePaymentMethod.from_kb_account_id(kb_account_id).collect { |pm| pm.to_payment_method_response }
+    end
+
+    private
+
+    def report_group_for_account(kb_account_id)
+=begin
+      account = account_user_api.get_account_by_id(kb_account_id)
+      currency = account.get_currency
+      report_group_for_currency(currency)
+    rescue APINotAvailableError
+      "Default Report Group"
+=end
+      # STEPH hack until we support making API calls-- with context
+      report_group_for_currency('USD')
+    end
+
+    def report_group_for_currency(currency)
+      "Report Group for #{currency}"
+    end
+
+
+    def get_token(kb_payment_method_id)
+      LitlePaymentMethod.from_kb_payment_method_id(kb_payment_method_id).litle_token
+    end
+
+    def save_response_and_transaction(litle_response, api_call, kb_payment_id=nil, amount_in_cents=0)
+      @logger.warn "Unsuccessful #{api_call}: #{litle_response.message}" unless litle_response.success?
+
+      # Save the response to our logs
+      response = LitleResponse.from_response(api_call, kb_payment_id, litle_response)
+      response.save!
+
+      if response.success and !response.litle_txn_id.blank?
+        # Record the transaction
+        transaction = response.create_litle_transaction!(:amount_in_cents => amount_in_cents, :api_call => api_call, :kb_payment_id => kb_payment_id, :litle_txn_id => response.litle_txn_id)
+        @logger.debug "Recorded transaction: #{transaction.inspect}"
+      end
+      response
+    end
+  end
+end

data/lib/litle/config/application.rb

@@ -0,0 +1,54 @@
+configure do
+  # Usage: rackup -Ilib -E test
+  if development? or test?
+    Killbill::Litle.initialize! unless Killbill::Litle.initialized
+  end
+end
+
+helpers do
+  def plugin
+    Killbill::Litle::PrivatePaymentPlugin.instance
+  end
+end
+
+# http://127.0.0.1:9292/plugins/killbill-litle
+get '/plugins/killbill-litle' do
+  locals = {
+    :secure_page_url => Killbill::Litle.config[:litle][:secure_page_url],
+    :paypage_id => Killbill::Litle.config[:litle][:paypage_id],
+    :kb_account_id => request.GET['kb_account_id'] || '1',
+    :merchant_txn_id => request.GET['merchant_txn_id'] || '1',
+    :order_id => request.GET['order_id'] || '1',
+    :report_group => request.GET['report_group'] || 'Default Report Group',
+  }
+  erb :paypage, :views => File.expand_path(File.dirname(__FILE__) + '/../views'), :locals => locals
+end
+
+post '/plugins/killbill-litle/checkout' do
+  data = request.POST
+
+  begin
+    pm = plugin.register_token! data['kb_account_id'], data['response_paypage_registration_id']
+    redirect "/plugins/killbill-litle/1.0/pms/#{pm.id}"
+  rescue => e
+    halt 500, {'Content-Type' => 'text/plain'}, "Error: #{e}"
+  end
+end
+
+# curl -v http://127.0.0.1:9292/plugins/killbill-litle/1.0/pms/1
+get '/plugins/killbill-litle/1.0/pms/:id', :provides => 'json' do
+  if pm = Killbill::Litle::LitlePaymentMethod.find_by_id(params[:id].to_i)
+    pm.to_json
+  else
+    status 404
+  end
+end
+
+# curl -v http://127.0.0.1:9292/plugins/killbill-litle/1.0/transactions/1
+get '/plugins/killbill-litle/1.0/transactions/:id', :provides => 'json' do
+  if transaction = Killbill::Litle::LitleTransaction.find_by_id(params[:id].to_i)
+    transaction.to_json
+  else
+    status 404
+  end
+end

data/lib/litle/config/configuration.rb

@@ -0,0 +1,30 @@
+require 'logger'
+
+module Killbill::Litle
+  mattr_reader :logger
+  mattr_reader :config
+  mattr_reader :gateway
+  mattr_reader :initialized
+  mattr_reader :test
+
+  def self.initialize!(config_file='litle.yml', logger=Logger.new(STDOUT))
+    @@logger = logger
+
+    @@config = Properties.new(config_file)
+    @@config.parse!
+    @@test = @@config[:litle][:test]
+
+    @@gateway = Killbill::Litle::Gateway.instance
+    @@gateway.configure(@@config[:litle])
+
+    if defined?(JRUBY_VERSION)
+      # See https://github.com/jruby/activerecord-jdbc-adapter/issues/302
+      require 'jdbc/mysql'
+      Jdbc::MySQL.load_driver(:require) if Jdbc::MySQL.respond_to?(:load_driver)
+    end
+
+    ActiveRecord::Base.establish_connection(@@config[:database])
+
+    @@initialized = true
+  end
+end

data/lib/litle/config/properties.rb

@@ -0,0 +1,23 @@
+module Killbill::Litle
+  class Properties
+    def initialize(file = 'litle.yml')
+      @config_file = Pathname.new(file).expand_path
+    end
+
+    def parse!
+      raise "#{@config_file} is not a valid file" unless @config_file.file?
+      @config = YAML.load_file(@config_file.to_s)
+      validate!
+    end
+
+    def [](key)
+      @config[key]
+    end
+
+    private
+
+    def validate!
+      raise "Bad configuration for Litle plugin. Config is #{@config.inspect}" if @config.blank? || !@config[:litle] || !@config[:litle][:merchant_id] || !@config[:litle][:password]
+    end
+  end
+end

data/lib/litle/litle/gateway.rb

@@ -0,0 +1,25 @@
+module Killbill::Litle
+  class Gateway
+    include Singleton
+
+    def configure(config)
+      if config[:test]
+        ActiveMerchant::Billing::Base.mode = :test
+      end
+
+      if config[:log_file]
+        ActiveMerchant::Billing::LitleGateway.wiredump_device = File.open(config[:log_file], 'w')
+        ActiveMerchant::Billing::LitleGateway.wiredump_device.sync = true
+      end
+
+      @gateway = ActiveMerchant::Billing::LitleGateway.new({ :user => config[:username],
+                                                             :merchant_id => config[:merchant_id],
+                                                             :password => config[:password]
+                                                           })
+    end
+
+    def method_missing(m, *args, &block)
+      @gateway.send(m, *args, &block)
+    end
+  end
+end

data/lib/litle/litle_utils.rb

@@ -0,0 +1,22 @@
+class Integer
+  def base(b)
+    self < b ? [self] : (self/b).base(b) + [self%b]
+  end
+end
+
+module Killbill::Litle
+  class Utils
+    # Use base 62 to be safe on the Litle side
+    BASE62 = ('0'..'9').to_a + ('A'..'Z').to_a + ('a'..'z').to_a
+
+    def self.compact_uuid(uuid)
+      uuid = uuid.gsub(/-/, '')
+      uuid.hex.base(62).map{ |i| BASE62[i].chr } * ''
+    end
+
+    def self.unpack_uuid(base62_uuid)
+      as_hex = base62_uuid.split(//).inject(0) { |i,e| i*62 + BASE62.index(e[0]) }
+      ("%x" % as_hex).insert(8, "-").insert(13, "-").insert(18, "-").insert(23, "-")
+    end
+  end
+end

data/lib/litle/models/litle_payment_method.rb

@@ -0,0 +1,32 @@
+module Killbill::Litle
+  class LitlePaymentMethod < ActiveRecord::Base
+    attr_accessible :kb_account_id, :kb_payment_method_id, :litle_token
+
+    def self.from_kb_account_id(kb_account_id)
+      find_all_by_kb_account_id_and_is_deleted(kb_account_id, false)
+    end
+
+    def self.from_kb_payment_method_id(kb_payment_method_id)
+      payment_methods = find_all_by_kb_payment_method_id_and_is_deleted(kb_payment_method_id, false)
+      raise "No payment method found for payment method #{kb_payment_method_id}" if payment_methods.empty?
+      raise "Killbill payment method mapping to multiple active Litle tokens for payment method #{kb_payment_method_id}" if payment_methods.size > 1
+      payment_methods[0]
+    end
+
+    def self.mark_as_deleted!(kb_payment_method_id)
+      payment_method = from_kb_payment_method_id(kb_payment_method_id)
+      payment_method.is_deleted = true
+      payment_method.save!
+    end
+
+    def to_payment_method_response
+      external_payment_method_id = litle_token
+      # No concept of default payment method in Litle
+      is_default = false
+      # No extra information is stored in Litle
+      properties = []
+
+      Killbill::Plugin::PaymentMethodResponse.new external_payment_method_id, is_default, properties
+    end
+  end
+end

data/lib/litle/models/litle_response.rb

@@ -0,0 +1,122 @@
+
+
+module Killbill::Litle
+  class LitleResponse < ActiveRecord::Base
+    has_one :litle_transaction
+    attr_accessible :api_call,
+                    :kb_payment_id,
+                    :message,
+                    # Either litleToken (registerToken call) or litleTxnId
+                    :authorization,
+                    :fraud_review,
+                    :test,
+                    :params_litleonelineresponse_message,
+                    :params_litleonelineresponse_response,
+                    :params_litleonelineresponse_version,
+                    :params_litleonelineresponse_xmlns,
+                    :params_litleonelineresponse_saleresponse_customer_id,
+                    :params_litleonelineresponse_saleresponse_id,
+                    :params_litleonelineresponse_saleresponse_report_group,
+                    :params_litleonelineresponse_saleresponse_litle_txn_id,
+                    :params_litleonelineresponse_saleresponse_order_id,
+                    :params_litleonelineresponse_saleresponse_response,
+                    :params_litleonelineresponse_saleresponse_response_time,
+                    :params_litleonelineresponse_saleresponse_message,
+                    :params_litleonelineresponse_saleresponse_auth_code,
+                    :avs_result_code,
+                    :avs_result_message,
+                    :avs_result_street_match,
+                    :avs_result_postal_match,
+                    :cvv_result_code,
+                    :cvv_result_message,
+                    :success
+
+    def litle_token
+      authorization
+    end
+
+    def litle_txn_id
+      potential_litle_txn_id = params_litleonelineresponse_saleresponse_litle_txn_id || authorization
+      if potential_litle_txn_id.blank?
+        nil
+      else
+        # Litle seems to return the precision sometimes along with the txnId (e.g. 053499651324799+19)
+        ("%f" % potential_litle_txn_id.split('+')[0]).to_i
+      end
+    end
+
+    def self.from_response(api_call, kb_payment_id, response)
+      LitleResponse.new({
+                          :api_call => api_call,
+                          :kb_payment_id => kb_payment_id,
+                          :message => response.message,
+                          :authorization => response.authorization,
+                          :fraud_review => response.fraud_review?,
+                          :test => response.test?,
+                          :params_litleonelineresponse_message => extract(response, "litleOnlineResponse", "message"),
+                          :params_litleonelineresponse_response => extract(response, "litleOnlineResponse", "response"),
+                          :params_litleonelineresponse_version => extract(response, "litleOnlineResponse", "version"),
+                          :params_litleonelineresponse_xmlns => extract(response, "litleOnlineResponse", "xmlns"),
+                          :params_litleonelineresponse_saleresponse_customer_id => extract(response, "litleOnlineResponse", "saleResponse", "customerId"),
+                          :params_litleonelineresponse_saleresponse_id => extract(response, "litleOnlineResponse", "saleResponse", "id"),
+                          :params_litleonelineresponse_saleresponse_report_group => extract(response, "litleOnlineResponse", "saleResponse", "reportGroup"),
+                          :params_litleonelineresponse_saleresponse_litle_txn_id => extract(response, "litleOnlineResponse", "saleResponse", "litleTxnId"),
+                          :params_litleonelineresponse_saleresponse_order_id => extract(response, "litleOnlineResponse", "saleResponse", "orderId"),
+                          :params_litleonelineresponse_saleresponse_response => extract(response, "litleOnlineResponse", "saleResponse", "response"),
+                          :params_litleonelineresponse_saleresponse_response_time => extract(response, "litleOnlineResponse", "saleResponse", "responseTime"),
+                          :params_litleonelineresponse_saleresponse_message => extract(response, "litleOnlineResponse", "saleResponse", "message"),
+                          :params_litleonelineresponse_saleresponse_auth_code => extract(response, "litleOnlineResponse", "saleResponse", "authCode"),
+                          :avs_result_code => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.code : response.avs_result['code'],
+                          :avs_result_message => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.message : response.avs_result['message'],
+                          :avs_result_street_match => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.street_match : response.avs_result['street_match'],
+                          :avs_result_postal_match => response.avs_result.kind_of?(ActiveMerchant::Billing::AVSResult) ? response.avs_result.postal_match : response.avs_result['postal_match'],
+                          :cvv_result_code => response.cvv_result.kind_of?(ActiveMerchant::Billing::CVVResult) ? response.cvv_result.code : response.cvv_result['code'],
+                          :cvv_result_message => response.cvv_result.kind_of?(ActiveMerchant::Billing::CVVResult) ? response.cvv_result.message : response.cvv_result['message'],
+                          :success => response.success?
+                       })
+    end
+
+    def to_payment_response
+      to_killbill_response Killbill::Plugin::PaymentResponse
+    end
+
+    def to_refund_response
+      to_killbill_response Killbill::Plugin::RefundResponse
+    end
+
+    private
+
+    def to_killbill_response(klass)
+      if litle_transaction.nil?
+        amount_in_cents = nil
+        created_date = created_at
+      else
+        amount_in_cents = litle_transaction.amount_in_cents
+        created_date = litle_transaction.created_at
+      end
+
+      effective_date = params_litleonelineresponse_saleresponse_response_time || created_date
+      status = message == 'Approved' ? Killbill::Plugin::PaymentStatus::SUCCESS : Killbill::Plugin::PaymentStatus::ERROR
+      gateway_error = params_litleonelineresponse_saleresponse_message
+      gateway_error_code = params_litleonelineresponse_saleresponse_response
+
+      klass.new(amount_in_cents, created_date, effective_date, status, gateway_error, gateway_error_code)
+    end
+
+    def self.extract(response, key1, key2=nil, key3=nil)
+      return nil if response.nil? || response.params.nil?
+      level1 = response.params[key1]
+
+      if level1.nil? or (key2.nil? and key3.nil?)
+        return level1
+      end
+      level2 = level1[key2]
+
+      if level2.nil? or key3.nil?
+        return level2
+      else
+        return level2[key3]
+      end
+    end
+  end
+end

data/lib/litle/models/litle_transaction.rb

@@ -0,0 +1,13 @@
+module Killbill::Litle
+  class LitleTransaction < ActiveRecord::Base
+    belongs_to :litle_response
+    attr_accessible :amount_in_cents, :api_call, :kb_payment_id, :litle_txn_id
+
+    def self.from_kb_payment_id(kb_payment_id)
+      litle_transactions = find_all_by_api_call_and_kb_payment_id(:charge, kb_payment_id)
+      raise "Unable to find Litle transaction id for payment #{kb_payment_id}" if litle_transactions.empty?
+      raise "Killbill payment mapping to multiple Litle transactions for payment #{kb_payment_id}" if litle_transactions.size > 1
+      litle_transactions[0]
+    end
+  end
+end