kaui 1.4.0 → 2.0.3

data/app/controllers/kaui/home_controller.rb

@@ -52,7 +52,7 @@ class Kaui::HomeController < Kaui::EngineController
   def invoice_search(search_query, search_by = nil, fast = 0, options = {})
     if search_by == 'ID'
       begin
-        invoice = Kaui::Invoice.find_by_id(search_query, false, 'NONE', options)
+        invoice = Kaui::Invoice.find_by_id(search_query, 'NONE', options)
         redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id) and return
       rescue KillBillClient::API::NotFound => _
         search_error("No invoice matches \"#{search_query}\"")
@@ -63,7 +63,7 @@ class Kaui::HomeController < Kaui::EngineController
       invoice = Kaui::Invoice.list_or_search(search_query, 0, 1, options).first
       if invoice.blank?
         begin
-          invoice = Kaui::Invoice.find_by_invoice_item_id(search_query, false, false, 'NONE', options)
+          invoice = Kaui::Invoice.find_by_invoice_item_id(search_query, false, 'NONE', options)
           redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id) and return
         rescue KillBillClient::API::NotFound => _
           search_error("No invoice matches \"#{search_query}\"")

data/app/controllers/kaui/invoice_items_controller.rb

@@ -5,7 +5,7 @@ class Kaui::InvoiceItemsController < Kaui::EngineController
     invoice_id = params.require(:invoice_id)
 
     # See https://github.com/killbill/killbill/issues/7
-    invoice = Kaui::Invoice.find_by_id(invoice_id, true, 'NONE', options_for_klient)
+    invoice = Kaui::Invoice.find_by_id(invoice_id, 'NONE', options_for_klient)
     @invoice_item = invoice.items.find { |ii| ii.invoice_item_id == invoice_item_id }
 
     if @invoice_item.nil?

data/app/controllers/kaui/invoices_controller.rb

@@ -18,7 +18,7 @@ class Kaui::InvoicesController < Kaui::EngineController
       if account.nil?
         Kaui::Invoice.list_or_search(search_key, offset, limit, cached_options_for_klient)
       else
-        account.invoices(true, cached_options_for_klient).map! { |invoice| Kaui::Invoice.build_from_raw_invoice(invoice) }
+        account.invoices(cached_options_for_klient).map! { |invoice| Kaui::Invoice.build_from_raw_invoice(invoice) }
       end
     end
 
@@ -47,7 +47,9 @@ class Kaui::InvoicesController < Kaui::EngineController
     # Go to the database once
     cached_options_for_klient = options_for_klient
 
-    @invoice = Kaui::Invoice.find_by_id(params.require(:id), true, 'FULL', cached_options_for_klient)
+    @invoice = Kaui::Invoice.find_by_id(params.require(:id), 'FULL', cached_options_for_klient)
+    # This will put the TAX items at the bottom
+    @invoice.items.sort_by! { |ii| [ii.item_type, ii.description] }
 
     fetch_payments = promise { @invoice.payments(true, true, 'FULL', cached_options_for_klient).map { |payment| Kaui::InvoicePayment.build_from_raw_payment(payment) } }
     fetch_pms = fetch_payments.then { |payments| Kaui::PaymentMethod.payment_methods_for_payments(payments, cached_options_for_klient) }
@@ -78,7 +80,7 @@ class Kaui::InvoicesController < Kaui::EngineController
   end
 
   def restful_show
-    invoice = Kaui::Invoice.find_by_id(params.require(:id), false, 'NONE', options_for_klient)
+    invoice = Kaui::Invoice.find_by_id(params.require(:id), 'NONE', options_for_klient)
     redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id)
   end
 
@@ -88,7 +90,7 @@ class Kaui::InvoicesController < Kaui::EngineController
 
   def commit_invoice
     cached_options_for_klient = options_for_klient
-    invoice = KillBillClient::Model::Invoice.find_by_id(params.require(:id), false, 'NONE', cached_options_for_klient)
+    invoice = KillBillClient::Model::Invoice.find_by_id(params.require(:id), 'NONE', cached_options_for_klient)
     invoice.commit(current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
     redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id), :notice => 'Invoice successfully committed'
   end

data/app/controllers/kaui/payment_methods_controller.rb

@@ -45,9 +45,15 @@ class Kaui::PaymentMethodsController < Kaui::EngineController
     }
 
     @plugin_properties = params[:plugin_properties].values.select{ |item| !(item['value'].blank? || item['key'].blank?) } rescue @plugin_properties = nil
-    @plugin_properties.map! do |property|
-      KillBillClient::Model::PluginPropertyAttributes.new(property)
-    end unless @plugin_properties.blank?
+    if @plugin_properties.blank?
+      # In case of error, we want the view to receive nil, not [], so that at least the first row is populated (required to make the JS work)
+      # See https://github.com/killbill/killbill-admin-ui/issues/258
+      @plugin_properties = nil
+    else
+      @plugin_properties.map! do |property|
+        KillBillClient::Model::PluginPropertyAttributes.new(property)
+      end
+    end
 
     begin
       @payment_method = @payment_method.create(@payment_method.is_default, current_user.kb_username, params[:reason], params[:comment],

data/app/controllers/kaui/payments_controller.rb

@@ -74,7 +74,7 @@ class Kaui::PaymentsController < Kaui::EngineController
 
   def new
     cached_options_for_klient = options_for_klient
-    fetch_invoice = promise { Kaui::Invoice.find_by_id(params.require(:invoice_id), true, 'NONE', cached_options_for_klient) }
+    fetch_invoice = promise { Kaui::Invoice.find_by_id(params.require(:invoice_id), 'NONE', cached_options_for_klient) }
     fetch_payment_methods = promise { Kaui::PaymentMethod.find_all_by_account_id(params.require(:account_id), false, cached_options_for_klient) }
 
     @invoice = wait(fetch_invoice)

data/app/controllers/kaui/refunds_controller.rb

@@ -3,7 +3,7 @@ class Kaui::RefundsController < Kaui::EngineController
   def new
     cached_options_for_klient = options_for_klient
 
-    fetch_invoice = promise { Kaui::Invoice.find_by_id(params.require(:invoice_id), true, 'NONE', cached_options_for_klient) }
+    fetch_invoice = promise { Kaui::Invoice.find_by_id(params.require(:invoice_id), 'NONE', cached_options_for_klient) }
     fetch_payment = promise { Kaui::InvoicePayment::find_by_id(params.require(:payment_id), false, false, cached_options_for_klient) }
     fetch_bundles = promise { @account.bundles(cached_options_for_klient) }
 
@@ -15,7 +15,7 @@ class Kaui::RefundsController < Kaui::EngineController
   end
 
   def create
-    invoice = Kaui::Invoice.find_by_id(params.require(:invoice_id), true, 'NONE', options_for_klient)
+    invoice = Kaui::Invoice.find_by_id(params.require(:invoice_id), 'NONE', options_for_klient)
 
     if params[:adjustment_type] == 'invoiceItemAdjustment'
       items = []

data/app/controllers/kaui/sessions_controller.rb

@@ -18,5 +18,11 @@ module Kaui
     def after_sign_out_path_for(resource)
       kaui_path
     end
+
+    def require_no_authentication
+      super
+      # Remove the somewhat confusing message "You are already signed in."
+      flash.discard(:alert) if flash[:alert] == I18n.t("devise.failure.already_authenticated")
+    end
   end
 end

data/app/controllers/kaui/subscriptions_controller.rb

@@ -11,9 +11,9 @@ class Kaui::SubscriptionsController < Kaui::EngineController
 
     if @plans.empty?
       if @subscription.product_category == 'BASE'
-        flash[:error] = 'No available plan'
+        flash[:error] = 'No plan available in the catalog'
       else
-        flash[:error] = "No available add-on for product #{@base_product_name}"
+        flash[:error] = "No add-on available in the catalog for product #{@base_product_name}"
       end
       redirect_to kaui_engine.account_bundles_path(@subscription.account_id), :error => 'No available plan'
     end
@@ -46,6 +46,16 @@ class Kaui::SubscriptionsController < Kaui::EngineController
       redirect_to kaui_engine.account_bundles_path(@subscription.account_id), :notice => 'Subscription was successfully created'
     rescue => e
       @plans = plans_details.nil? ? [] : plans_details.map { |p| p.plan }
+
+      if e.is_a?(::KillBillClient::API::BadRequest) && !e.response.nil? && !e.response.body.nil?
+        error_message = JSON.parse(e.response.body) rescue nil
+        if !error_message.nil? & !error_message['code'].nil? && error_message['code'] == 2010 # CAT_NO_PRICE_FOR_CURRENCY
+          # Hack for lack of proper Kill Bill messaging (https://github.com/killbill/killbill-admin-ui/issues/266)
+          flash.now[:error] = "Unable to create the subscription: a price for this currency hasn't been specified in the catalog"
+          render :new and return
+        end
+      end
+
       flash.now[:error] = "Error while creating the subscription: #{as_string(e)}"
       render :new
     end
@@ -141,7 +151,7 @@ class Kaui::SubscriptionsController < Kaui::EngineController
     redirect_to kaui_engine.account_bundles_path(subscription.account_id)
   end
 
-  def validate_external_key
+  def validate_bundle_external_key
     json_response do
       external_key = params.require(:external_key)
 
@@ -155,6 +165,21 @@ class Kaui::SubscriptionsController < Kaui::EngineController
     end
   end
 
+
+  def validate_external_key
+    json_response do
+      external_key = params.require(:external_key)
+
+      begin
+        subscription = Kaui::Subscription.find_by_external_key(external_key, options_for_klient)
+      rescue KillBillClient::API::NotFound
+        subscription = nil
+      end
+
+      { :is_found => !subscription.nil? }
+    end
+  end
+
   def update_tags
     subscription_id = params.require(:id)
     subscription = Kaui::Subscription.find_by_id(subscription_id, options_for_klient)
@@ -197,8 +222,7 @@ class Kaui::SubscriptionsController < Kaui::EngineController
     else
       options = options_for_klient
 
-      catalog = Kaui::Catalog.get_tenant_catalog_json( DateTime.now.to_s, options)
-
+      catalog = Kaui::Catalog.get_tenant_catalog_json(DateTime.now.to_s, options)
       return [] if catalog.blank?
 
       plans = []

data/app/helpers/kaui/payment_method_helper.rb

@@ -1,9 +1,11 @@
 module Kaui
   module PaymentMethodHelper
 
-    def is_json?(string)
-      !string.blank? && !!JSON.parse(string) rescue false
+    def is_json?(value)
+      result = JSON.parse(value)
+      result.is_a?(Hash) || result.is_a?(Array)
+    rescue JSON::ParserError, TypeError
+      false
     end
-
   end
 end

data/app/helpers/kaui/plugin_helper.rb

@@ -1,46 +1,13 @@
 module Kaui
   module PluginHelper
-    # including plugin that are installed
-    def plugin_repository
-      plugins = []
-      plugin_repository = Kaui::AdminTenant.get_plugin_repository
-      plugin_repository.each_pair do |key, info|
-        plugins << {
-          plugin_key: plugin_key(key.to_s, info),
-          plugin_name: plugin_name(key.to_s, info),
-          plugin_type: info[:type],
-          installed: false
-        }
-      end
-
-      installed_plugins = installed_plugins(plugins)
-
-      plugins.sort! { |a, b| a[:plugin_key] <=> b[:plugin_key] }
-      plugins.each { |plugin| installed_plugins << plugin }
 
+    def plugin_repository
       installed_plugins
     end
 
     private
 
-      def plugin_name(key, info)
-        if info[:artifact_id].nil?
-          "killbill-#{key}"
-        else
-          "killbill-#{info[:artifact_id].gsub('killbill-','').gsub('-plugin','')}"
-        end
-      end
-
-      def plugin_key(key, info)
-        # hack:: replace paypal key with paypal_express, to set configuration and allow the ui to find the right configuration inputs
-        if key.eql?('paypal')
-          'paypal_express'
-        else
-          "#{key}"
-        end
-      end
-
-      def installed_plugins(plugins)
+      def installed_plugins
         installed_plugins = []
         nodes_info = KillBillClient::Model::NodesInfo.nodes_info(Kaui.current_tenant_user_options(current_user, session)) || []
         plugins_info = nodes_info.first.plugins_info || []
@@ -49,11 +16,15 @@ module Kaui
           next if plugin.version.nil?
           # do not allow duplicate
           next if installed_plugins.any? { |p| p[:plugin_name].eql?(plugin.plugin_name) }
-          plugin_key = Kaui::AdminTenant.rewrite_plugin_key(plugin.plugin_key) unless plugin.plugin_key.nil?
+          plugin_key = plugin.plugin_key
           installed_plugins << {
+              # Unique identifier chosen by the user and used for kpm operations
               plugin_key: plugin_key,
-              plugin_name: plugin.plugin_name,
-              plugin_type: find_plugin_type(plugins, plugin_key),
+              # Notes:
+              #   * plugin.plugin_name comes from kpm and is arbitrary (see Utils.get_plugin_name_from_file_path in the kpm codebase for instance)
+              #   * plugin_name here is the plugin name as seen by Kill Bill and is typically defined in the Activator.java (this value is the one that matters for plugin configuration)
+              #   * The mapping here is a convention we've used over the years and is no way enforced anywhere - it likely won't work for proprietary plugins (the user would need to specify it by toggling the input on the UI)
+              plugin_name: "killbill-#{plugin_key}",
               installed: true
           }
         end
@@ -61,15 +32,5 @@ module Kaui
         # to_s to handle nil
         installed_plugins.sort! { |a,b| a[:plugin_key].to_s <=> b[:plugin_key].to_s }
       end
-
-      def find_plugin_type(plugins, plugin_key_to_search)
-        plugins.each do |plugin|
-          if plugin[:plugin_key] == plugin_key_to_search
-            return plugin[:plugin_type]
-          end
-        end
-
-        return nil
-      end
   end
 end

data/app/helpers/kaui/subscription_helper.rb

@@ -10,12 +10,12 @@ module Kaui
     end
 
     def humanized_product_category(product_category)
-      if product_category == 'BASE'
+      if product_category.to_s == 'BASE'
         'Base'
-      elsif product_category == 'ADD_ON'
+      elsif product_category.to_s == 'ADD_ON'
         'Add-on'
       else
-        product_category.downcase.capitalize
+        product_category.to_s.downcase.capitalize
       end
     end
 
@@ -28,7 +28,8 @@ module Kaui
     end
 
     def humanized_product_name(product_name)
-        product_name.downcase.capitalize
+      # Don't change the casing to avoid confusions (could lead to different products with different casing)
+      product_name
     end
 
     def humanized_subscription_billing_period(sub)

data/app/models/kaui/admin_tenant.rb

@@ -26,81 +26,21 @@ class Kaui::AdminTenant < KillBillClient::Model::Tenant
       KillBillClient::Model::Tenant.upload_tenant_plugin_config(plugin_name, plugin_config, user, reason, comment, options)
     end
 
-    def get_plugin_repository
-      require 'open-uri'
-      require 'yaml'
-
-      source = URI.parse('https://raw.githubusercontent.com/killbill/killbill-cloud/master/kpm/lib/kpm/plugins_directory.yml').read
-      YAML.load(source)
-    rescue
-      # Ignore gracefully
-      {}
-    end
-
-    def get_oss_plugin_info(plugin_directory)
-      # Serialize the plugin state for the view:
-      #  plugin_name#plugin_type:prop1,prop2,prop3;plugin_name#plugin_type:prop1,prop2,prop3;...
-      #
-      plugin_config = plugin_directory.inject({}) do |hsh, (k,v)|
-        hsh["#{k}##{v[:type]}"] = v[:require] || []
-        hsh
-      end
-      plugin_config.map { |e,v| "#{e}:#{v.join(",")}" }.join(";")
-    end
-
-    def get_tenant_plugin_config(plugin_directory, options)
-      require 'yaml'
-
+    # Return a map of plugin_name => config
+    def get_tenant_plugin_config(options)
       raw_tenant_config = KillBillClient::Model::Tenant::search_tenant_config("PLUGIN_CONFIG_", options)
 
       tenant_config = raw_tenant_config.inject({}) do |hsh, e|
         # Strip prefix '/PLUGIN_CONFIG_'
-        killbill_key = e.key.gsub!(/PLUGIN_CONFIG_/, '')
-
-        # Extract killbill key for oss plugins based on convention 'killbill-KEY'
-        plugin_key = killbill_key.gsub(/killbill-/, '') if killbill_key.start_with?('killbill-')
-
-        # hack:: rewrite key, to allow the ui to find the right configuration inputs
-        plugin_key = rewrite_plugin_key(plugin_key) unless plugin_key.nil?
-        # If such key exists, lookup in plugin directory to see if is an official plugin
-        is_an_official_plugin = !plugin_key.nil? && !plugin_directory[plugin_key.to_sym].blank?
-        # Deserialize config based on string possible format, if exist in the official repository
-        if is_an_official_plugin && is_yaml?(e.values[0])
-          yml = YAML.load(e.values[0])
-          # Hash of properties
-          # is plugin key part of the yaml?
-          if yml[plugin_key.to_sym].blank?
-            # if not set it as raw
-            hsh[plugin_key] = {:raw_config => e.values[0]}
-          else
-            hsh[plugin_key] = yml[plugin_key.to_sym]
-          end
-          hsh[plugin_key][:_raw] = e.values[0]
-        elsif is_an_official_plugin && is_kv?(e.values[0])
-          # Construct hash of properties based on java properties (k1=v1\nk2=v2\n...)
-          hsh[plugin_key] = e.values[0].split("\n").inject({}) do |h, p0|
-            k, v = p0.split('=');
-            h[k] = v;
-            h
-          end
-          hsh[plugin_key][:_raw] = e.values[0]
-        else
-          # Construct simple hash with one property :raw_config
-          hsh[killbill_key] = {:raw_config => e.values[0], :_raw => e.values[0]}
-        end
+        plugin_name = e.key.gsub!(/PLUGIN_CONFIG_/, '')
+
+        # Construct simple hash with one property (first value)
+        hsh[plugin_name] = e.values[0]
+
         hsh
       end
 
-      # Serialize the whole thing a as string of the form:
-      # plugin_key1::key1=value1|key2=value2|..;plugin_key2::...
-      tenant_config.map do |plugin_key, props|
-        serialized_props = props.inject("") do |s, (k, v)|
-          e="#{k.to_s}=#{v.to_s}";
-          s == "" ? s="#{e}" : s="#{s}|#{e}";
-          s
-        end
-        "#{plugin_key}::#{serialized_props}"
-      end.join(";")
+      tenant_config
     end
 
     def format_plugin_config(plugin_key, plugin_type, props)
@@ -142,22 +82,6 @@ class Kaui::AdminTenant < KillBillClient::Model::Tenant
       props
     end
 
-    # hack when the plugin name after killbill is not the same as the plugin key, this mainly affects ruby plugin configuration,
-    # as it use the key to retrieve the configuration.
-    def rewrite_plugin_key(plugin_key)
-      if plugin_key.start_with?('paypal')
-        'paypal_express'
-      elsif plugin_key.start_with?('firstdata')
-        'firstdata_e4'
-      elsif plugin_key.start_with?('bridge')
-        'payment_bridge'
-      elsif plugin_key.start_with?('payu-latam')
-        'payu_latam'
-      else
-        "#{plugin_key}"
-      end
-    end
-
     # checks if string could be parse as yaml
     def is_yaml?(candidate_string)
       is_yaml = false

data/app/models/kaui/catalog.rb

@@ -4,9 +4,21 @@ class Kaui::Catalog < KillBillClient::Model::Catalog
 
   class << self
 
-    def get_catalog_json(latest, requested_date, options)
+    def get_tenant_catalog_json(requested_date = nil, options = {})
+      super
+    rescue ::KillBillClient::API::InternalServerError => e
+      if !e.response.nil? && !e.response.body.nil?
+        error_message = JSON.parse(e.response.body) rescue nil
+        raise e if error_message.nil? || error_message['message'].nil?
+
+        # Hack for lack of proper Kill Bill messaging (see https://github.com/killbill/killbill-admin-ui/issues/265)
+        return [] if error_message['message'].starts_with?('No existing versions')
+      end
+      raise e
+    end
 
-      catalogs = KillBillClient::Model::Catalog.get_tenant_catalog_json(requested_date, options)
+    def get_catalog_json(latest, requested_date, options)
+      catalogs = get_tenant_catalog_json(requested_date, options)
       return catalogs.length > 0 ? catalogs[catalogs.length - 1] : nil if latest
 
       # Order by latest