killbill-chartmogul 0.0.1

data/NEWS

@@ -0,0 +1,2 @@
+0.0.1
+    Initial release for Kill Bill 0.17.x

data/README.md

@@ -0,0 +1,37 @@
+killbill-chartmogul-plugin
+==========================
+
+Plugin to mirror Kill Bill data into ChartMogul.
+
+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%22chartmogul-plugin%22) with coordinates `org.kill-bill.billing.plugin.ruby:chartmogul-plugin`.
+
+Kill Bill compatibility
+-----------------------
+
+| Plugin version | Kill Bill version |
+| -------------: | ----------------: |
+| 0.0.y          | 0.18.z            |
+
+Configuration
+-------------
+
+```
+curl -v \
+     -X POST \
+     -u admin:password \
+     -H 'X-Killbill-ApiKey: bob' \
+     -H 'X-Killbill-ApiSecret: lazar' \
+     -H 'X-Killbill-CreatedBy: admin' \
+     -H 'Content-Type: text/plain' \
+     -d ':chartmogul:
+  :account_token: 'account_token'
+  :secret_key: 'secret_key'' \
+     http://127.0.0.1:8080/1.0/kb/tenants/uploadPluginConfig/killbill-chartmogul
+```
+
+Your Account Token and Secret Key are available from the administration section of your ChartMogul account.
+
+Usage
+-----
+
+The plugin will automatically listen to all events, and create or update the associated data in ChartMogul.

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.0.1

data/chartmogul.yml

@@ -0,0 +1,3 @@
+:chartmogul:
+  :account_token: <%= ENV['ACCOUNT_TOKEN'] %>
+  :secret_key: <%= ENV['SECRET_KEY'] %>

data/config.ru

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

data/killbill-chartmogul.gemspec

@@ -0,0 +1,52 @@
+version = File.read(File.expand_path('../VERSION', __FILE__)).strip
+
+Gem::Specification.new do |s|
+  s.name        = 'killbill-chartmogul'
+  s.version     = version
+  s.summary     = 'Plugin to mirror Kill Bill data into ChartMogul'
+  s.description = 'Kill Bill notification plugin for ChartMogul.'
+
+  s.required_ruby_version = '>= 2'
+
+  s.license = 'Apache License (2.0)'
+
+  s.author   = 'Kill Bill core team'
+  s.email    = 'killbilling-users@googlegroups.com'
+  s.homepage = 'http://killbill.io'
+
+  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', '~> 8.1'
+
+  s.add_dependency 'chartmogul-ruby', '~> 0.1'
+
+  s.add_dependency 'sinatra', '~> 1.3.4'
+  s.add_dependency 'thread_safe', '~> 0.3.4'
+  s.add_dependency 'activerecord', '~> 4.1.0'
+  if defined?(JRUBY_VERSION)
+    s.add_dependency 'activerecord-bogacs', '~> 0.3'
+    s.add_dependency 'activerecord-jdbc-adapter', '~> 1.3'
+    # Required to avoid errors like java.lang.NoClassDefFoundError: org/bouncycastle/asn1/DERBoolean
+    s.add_dependency 'jruby-openssl', '~> 0.9.6'
+  end
+  s.add_dependency 'actionpack', '~> 4.1.0'
+  s.add_dependency 'actionview', '~> 4.1.0'
+  s.add_dependency 'monetize', '~> 1.1.0'
+  s.add_dependency 'money', '~> 6.5.1'
+
+  s.add_development_dependency 'jbundler', '~> 0.9.2'
+  s.add_development_dependency 'rake', '>= 10.0.0'
+  s.add_development_dependency 'rspec', '~> 2.12.0'
+  if defined?(JRUBY_VERSION)
+    s.add_development_dependency 'jdbc-sqlite3', '~> 3.7'
+    s.add_development_dependency 'jdbc-mariadb', '~> 1.1'
+  else
+    s.add_development_dependency 'sqlite3', '~> 1.3.7'
+  end
+end

data/killbill.properties

@@ -0,0 +1,3 @@
+mainClass=Killbill::Chartmogul::ChartmogulPlugin
+require=chart_mogul
+pluginType=NOTIFICATION

data/lib/chart_mogul.rb

@@ -0,0 +1,42 @@
+require 'sinatra'
+
+require 'killbill'
+
+require 'chart_mogul/updater'
+require 'chart_mogul/updater_initializer'
+
+module Killbill::Chartmogul
+  class ChartmogulPlugin < Killbill::Plugin::Notification
+
+    # For testing
+    attr_reader :initializer
+
+    def initialize
+      super
+
+      @config_key_name = 'PLUGIN_CONFIG_killbill-chartmogul'.to_sym
+    end
+
+    def start_plugin
+      @logger.progname = 'chartmogul-plugin'
+
+      super
+
+      @initializer = Killbill::Chartmogul::UpdaterInitializer.instance
+      @initializer.initialize!(@config_key_name, "#{@conf_dir}/chartmogul.yml", @kb_apis, @logger)
+    end
+
+    def on_event(event)
+      if (event.event_type == :TENANT_CONFIG_CHANGE || event.event_type == :TENANT_CONFIG_DELETION) &&
+          event.meta_data.to_sym == @config_key_name
+        @logger.info("Invalidating plugin key='#{@config_key_name}', tenant='#{event.tenant_id}'")
+        @initializer.recycle_updater(event.tenant_id)
+      elsif !@initializer.nil?
+        updater = @initializer.updater(event.tenant_id)
+        updater.update(event.event_type, event.object_id, event.account_id, event.tenant_id) unless updater.nil?
+      else
+        @logger.warn "ChartMogul wasn't started properly - check logs"
+      end
+    end
+  end
+end

data/lib/chart_mogul/application.rb

@@ -0,0 +1,9 @@
+configure do
+  # Usage: rackup -Ilib -E test
+  if development? or test?
+    require 'logger'
+    Killbill::Chartmogul::UpdaterInitializer.instance.initialize! 'PLUGIN_CONFIG_killbill-chartmogul'.to_sym,
+                                                                  nil,
+                                                                  Logger.new(STDOUT)
+  end
+end

data/lib/chart_mogul/updater.rb

@@ -0,0 +1,248 @@
+# BUG NoMethodError: undefined method `prepend' for ChartMogul::Metrics::ARPAs:Class
+module ChartMogul
+  class Object
+  end
+
+  class APIResource < Object
+    def self.prepend(*args)
+    end
+  end
+end
+
+require 'chartmogul'
+
+# Enable some logging...
+module ChartMogul
+  class APIResource
+    def self.connection
+      @connection ||= Faraday.new(url: ChartMogul::API_BASE) do |faraday|
+        faraday.use Faraday::Request::BasicAuthentication, ChartMogul.account_token, ChartMogul.secret_key
+        faraday.use Faraday::Response::RaiseError
+        faraday.use Faraday::Adapter::NetHttp
+
+        faraday.response :logger
+      end
+    end
+  end
+end
+
+require 'monetize'
+require 'thread_safe'
+
+module Killbill::Chartmogul
+  class Updater
+
+    def initialize(config, kb_apis, logger)
+      # TODO Won't work well in multi-tenant mode
+      ::ChartMogul.account_token = config[:account_token]
+      ::ChartMogul.secret_key = config[:secret_key]
+
+      @kb_apis = kb_apis
+      @logger = logger
+
+      @plan_cache = ThreadSafe::Cache.new
+    end
+
+    def update(event_type, object_id, account_id, tenant_id)
+      # Listen to invoice payment events
+      if event_type == :INVOICE_PAYMENT_SUCCESS || event_type == :INVOICE_PAYMENT_FAILED
+        first_or_create_invoice(object_id, account_id, tenant_id)
+      end
+
+      # TODO future work:
+      # * Subscription events (cancellation)
+      # * Refund events
+      # * Tags and custom fields events
+    end
+
+    # For testing
+    #private
+
+    # TODO Should probably be configurable on a per tenant basis
+    def first_or_create_datasource(name = 'killbill')
+      sources = ::ChartMogul::Import::DataSource.all
+      ds = sources.find { |ds| ds.name == name }
+
+      ds || ::ChartMogul::Import::DataSource.create!(:name => name)
+    end
+
+    def first_or_create_customer(kb_account, ds = first_or_create_datasource)
+      customer = ::ChartMogul::Import::Customer.all(:page => 1,
+                                                    :per_page => 1,
+                                                    :data_source_uuid => ds.uuid,
+                                                    :external_id => kb_account.external_key).first
+
+      customer || ::ChartMogul::Import::Customer.create!(:data_source_uuid => ds.uuid,
+                                                         :external_id => kb_account.external_key,
+                                                         :name => kb_account.name,
+                                                         :email => kb_account.email,
+                                                         :company => kb_account.company_name,
+                                                         :country => kb_account.country,
+                                                         :state => kb_account.state_or_province,
+                                                         :city => kb_account.city,
+                                                         :zip => kb_account.postal_code)
+    end
+
+    def first_or_create_plan(kb_plan_phase, ds = first_or_create_datasource)
+      return @plan_cache[kb_plan_phase.name] unless @plan_cache[kb_plan_phase.name].nil?
+
+      if kb_plan_phase.phase_type != :EVERGREEN
+        # TODO It doesn't look like there is support for trials, etc.
+        return nil
+      end
+
+      if kb_plan_phase.recurring.nil?
+        # TODO It doesn't look like there is support for non-recurring phases
+        return nil
+      end
+
+      interval_count = nil
+      interval_unit = nil
+      case kb_plan_phase.recurring.billing_period
+        when :DAILY
+          interval_count = 1
+          interval_unit = 'day'
+        when :WEEKLY
+          interval_count = 7
+          interval_unit = 'day'
+        when :BIWEEKLY
+          interval_count = 14
+          interval_unit = 'day'
+        when :THIRTY_DAYS
+          interval_count = 30
+          interval_unit = 'day'
+        when :MONTHLY
+          interval_count = 1
+          interval_unit = 'month'
+        when :QUARTERLY
+          interval_count = 3
+          interval_unit = 'month'
+        when :BIANNUAL
+          interval_count = 6
+          interval_unit = 'month'
+        when :ANNUAL
+          interval_count = 1
+          interval_unit = 'year'
+        when :BIENNIAL
+          interval_count = 2
+          interval_unit = 'year'
+        else
+          return nil
+      end
+
+      plan = ::ChartMogul::Import::Plan.all(:page => 1,
+                                            :per_page => 1,
+                                            :data_source_uuid => ds.uuid,
+                                            :external_id => kb_plan_phase.name).first
+
+      @plan_cache[kb_plan_phase.name] = plan || ::ChartMogul::Import::Plan.create!(:data_source_uuid => ds.uuid,
+                                                                                   :external_id => kb_plan_phase.name,
+                                                                                   :name => kb_plan_phase.name,
+                                                                                   :interval_count => interval_count,
+                                                                                   :interval_unit => interval_unit)
+      @plan_cache[kb_plan_phase.name]
+    end
+
+    def first_or_create_invoice(kb_invoice_id, kb_account_id, kb_tenant_id, ds = first_or_create_datasource)
+      kb_context = @kb_apis.create_context(kb_tenant_id)
+      # Note that the get_invoice API won't populate the payments
+      kb_invoices = @kb_apis.invoice_user_api.get_invoices_by_account(kb_account_id, true, kb_context)
+      kb_invoice = kb_invoices.find { |kb_invoice| kb_invoice.id == kb_invoice_id }
+      return if kb_invoice.nil?
+
+      kb_account = @kb_apis.account_user_api.get_account_by_id(kb_invoice.account_id, kb_context)
+      customer = first_or_create_customer(kb_account, ds)
+
+      # TODO There is no support for adjustments
+      invoices = customer.invoices
+      return if invoices.find { |invoice| invoice.external_id == kb_invoice.id }
+
+      line_items = []
+      transactions = []
+
+      kb_invoice.invoice_items.each do |kb_invoice_item|
+        amount_in_cents = kb_invoice_item.amount.nil? ? nil : ::Monetize.from_numeric(kb_invoice_item.amount, kb_invoice_item.currency).cents.to_i
+
+        if kb_invoice_item.invoice_item_type == :RECURRING
+          kb_static_catalog = @kb_apis.catalog_user_api.get_current_catalog('unused', kb_context)
+          kb_plan_phase = find_current_phase(kb_invoice_item.phase_name, kb_static_catalog)
+          plan = kb_plan_phase.nil? ? nil : first_or_create_plan(kb_plan_phase, ds)
+          next if plan.nil?
+
+          rate_in_cents = kb_invoice_item.rate.nil? ? nil : ::Monetize.from_numeric(kb_invoice_item.rate, kb_invoice_item.currency).cents.to_i
+          prorated = amount_in_cents != rate_in_cents
+
+          line_items << ::ChartMogul::Import::LineItems::Subscription.new(:external_id => kb_invoice_item.id,
+                                                                          :plan_uuid => plan.uuid,
+                                                                          :subscription_external_id => kb_invoice_item.subscription_id,
+                                                                          :service_period_start => kb_invoice_item.start_date,
+                                                                          :service_period_end => kb_invoice_item.end_date,
+                                                                          :amount_in_cents => amount_in_cents,
+                                                                          :prorated => prorated,
+                                                                          :quantity => 1,
+                                                                          :discount_code => nil,
+                                                                          :discount_amount_in_cents => nil,
+                                                                          # TODO
+                                                                          :tax_amount_in_cents => nil)
+        elsif kb_invoice_item.invoice_item_type == :FIXED || kb_invoice_item.invoice_item_type == :EXTERNAL_CHARGE
+          line_items << ::ChartMogul::Import::LineItems::OneTime.new(:external_id => kb_invoice_item.id,
+                                                                     :description => kb_invoice_item.description,
+                                                                     :amount_in_cents => amount_in_cents,
+                                                                     :quantity => 1,
+                                                                     :discount_code => nil,
+                                                                     :discount_amount_in_cents => nil,
+                                                                     # TODO
+                                                                     :tax_amount_in_cents => nil)
+        else
+          # TODO It seems that other types aren't supported
+        end
+      end
+
+      kb_invoice.payments.each do |kb_invoice_payment|
+        if kb_invoice_payment.type == :ATTEMPT
+          transactions << ::ChartMogul::Import::Transactions::Payment.new(:external_id => kb_invoice_payment.id,
+                                                                          :date => kb_invoice_payment.payment_date,
+                                                                          :result => kb_invoice_payment.is_success)
+        elsif kb_invoice_payment.type == :REFUND
+          transactions << ::ChartMogul::Import::Transactions::Refund.new(:external_id => kb_invoice_payment.id,
+                                                                         :date => kb_invoice_payment.payment_date,
+                                                                         :result => kb_invoice_payment.is_success)
+        else
+          # TODO There is no support for chargebacks
+        end
+      end
+
+      return if line_items.empty?
+
+      invoice = ::ChartMogul::Import::Invoice.new(:external_id => kb_invoice.id,
+                                                  :date => kb_invoice.invoice_date,
+                                                  :currency => kb_invoice.currency.to_s,
+                                                  :due_date => kb_invoice.invoice_date,
+                                                  :line_items => line_items,
+                                                  :transactions => transactions)
+
+      begin
+        ::ChartMogul::Import::CustomerInvoices.create!(:customer_uuid => customer.uuid,
+                                                       :invoices => [invoice])
+      rescue => e
+        @logger.warn "Unable to create invoice #{invoice.inspect}: #{e.message}\n#{e.backtrace.join("\n")}"
+      end
+    end
+
+    def find_current_phase(phase_name, catalog)
+      plan_name = nil
+      %w(trial discount fixedterm evergreen).each do |type|
+        if phase_name.end_with?(type)
+          plan_name = phase_name[0..phase_name.size - type.size - 2]
+          break
+        end
+      end
+      return nil if plan_name.nil?
+
+      kb_plan = catalog.current_plans.find { |plan| plan.name == plan_name }
+      return nil if kb_plan.nil?
+
+      kb_plan.all_phases.find { |phase| phase.name == phase_name }
+    end
+  end
+end

data/lib/chart_mogul/updater_initializer.rb

@@ -0,0 +1,60 @@
+require 'active_support/core_ext/string'
+require 'erb'
+require 'pathname'
+require 'thread_safe'
+
+module Killbill::Chartmogul
+  class UpdaterInitializer
+    include Singleton
+
+    def initialize!(config_key_name, config_file, kb_apis, logger)
+      @config_key_name = config_key_name
+      @kb_apis = kb_apis
+      @logger = logger
+
+      @per_tenant_config_cache = ThreadSafe::Cache.new
+
+      # Look for global config
+      if !config_file.blank? && Pathname.new(config_file).file?
+        path = Pathname.new(config_file).expand_path
+        @glob_config = YAML.load(ERB.new(File.read(path.to_s)).result)
+      else
+        @glob_config = {}
+      end
+    end
+
+    def recycle_updater(kb_tenant_id)
+      @per_tenant_config_cache[kb_tenant_id] = nil
+    end
+
+    def updater(kb_tenant_id)
+      config = get_tenant_config(kb_tenant_id)
+      if config.nil?
+        @logger.warn "ChartMogul wasn't configured properly for kbTenantId='#{kb_tenant_id}'"
+        return nil
+      else
+        ::Killbill::Chartmogul::Updater.new(config[:chartmogul], @kb_apis, @logger)
+      end
+    end
+
+    private
+
+    def get_tenant_config(kb_tenant_id)
+      if @per_tenant_config_cache[kb_tenant_id].nil?
+        # Make the api api to verify if there is a per tenant value
+        context = @kb_apis.create_context(kb_tenant_id) if kb_tenant_id
+        values = @kb_apis.tenant_user_api.get_tenant_values_for_key(@config_key_name, context) if context
+        # If we have a per tenant value, insert it into the cache
+        if values && values[0]
+          parsed_config = YAML.load(values[0])
+          @per_tenant_config_cache[kb_tenant_id] = parsed_config
+        else
+          # Otherwise, add global config so we don't have to make the tenant call on each operation
+          @per_tenant_config_cache[kb_tenant_id] = @glob_config
+        end
+      end
+      # Return value from cache in any case
+      @per_tenant_config_cache[kb_tenant_id]
+    end
+  end
+end