kaui 2.0.0 → 2.1.0

data/app/controllers/kaui/audit_logs_controller.rb

@@ -65,7 +65,7 @@ class Kaui::AuditLogsController < Kaui::EngineController
         elsif object_type == 'CUSTOM_FIELD'
           audit_logs_with_history = Kaui::CustomField.new({:custom_field_id => object_id}).audit_logs_with_history(cached_options_for_klient)
         elsif object_type == 'INVOICE'
-          invoice = Kaui::Invoice::find_by_id(object_id, false, "NONE", cached_options_for_klient)
+          invoice = Kaui::Invoice::find_by_id(object_id, "NONE", cached_options_for_klient)
           audit_logs_with_history = invoice.audit_logs_with_history(cached_options_for_klient)
         elsif object_type == 'INVOICE_ITEM'
           invoice_item = Kaui::InvoiceItem.new
@@ -74,8 +74,8 @@ class Kaui::AuditLogsController < Kaui::EngineController
 =begin See https://github.com/killbill/killbill/issues/1104
         elsif object_type == 'INVOICE_PAYMENT'
           invoice_payment = Kaui::InvoicePayment::find_by_id(object_id, false, false, cached_options_for_klient)
-=end
           audit_logs_with_history = invoice_payment.audit_logs_with_history(cached_options_for_klient)
+=end
         elsif object_type == 'PAYMENT_ATTEMPT'
           audit_logs_with_history = Kaui::Payment::attempt_audit_logs_with_history(object_id, cached_options_for_klient)
         elsif object_type == 'PAYMENT'
@@ -113,4 +113,4 @@ class Kaui::AuditLogsController < Kaui::EngineController
       OBJECT_WITH_HISTORY.include?(object_type)
     end
 
-end
+end

data/app/controllers/kaui/bundles_controller.rb

@@ -31,6 +31,10 @@ class Kaui::BundlesController < Kaui::EngineController
     @available_tags = wait(fetch_available_tags)
     @available_subscription_tags = wait(fetch_available_subscription_tags)
 
+    # TODO This doesn't take into account catalog versions
+    catalogs = Kaui::Catalog.get_account_catalog_json(@account.account_id, nil, cached_options_for_klient) || []
+    @catalog = catalogs[-1]
+
     @subscription = {}
     @bundles.each do |bundle|
       bundle.subscriptions.each do |sub|

data/app/controllers/kaui/engine_controller_util.rb

@@ -41,7 +41,7 @@ module Kaui::EngineControllerUtil
       b = data_extractor.call(b, ordering_column)
       sort = a <=> b
       sort.nil? ? -1 : sort
-    end unless search_key.nil? # Keep DB ordering when listing all entries
+    end unless search_key.nil? # Keep DB ordering when listing all entries (note! make sure to set "ordering": false in DataTables config as the client-side sort behavior can be confusing)
     pages.reverse! if ordering_dir == 'desc' && limit >= 0 || ordering_dir == 'asc' && limit < 0
 
     pages.each { |page| json[:data] << formatter.call(page) }
@@ -51,24 +51,29 @@ module Kaui::EngineControllerUtil
     end
   end
 
-  def promise(execute = true, &block)
-    promise = Concurrent::Promise.new({:executor => Kaui.thread_pool}, &block)
-    promise.execute if execute
-    promise
+  def promise
+    # Evaluation starts immediately
+    ::Concurrent::Promises.future do
+      # https://github.com/rails/rails/issues/26847
+      Rails.application.executor.wrap do
+        yield
+      end
+    end
   end
 
   def wait(promise)
-    # If already executed, no-op
-    promise.execute
-
-    # Make sure to set a timeout to avoid infinite wait
-    value = promise.value!(60)
-    raise promise.reason unless promise.reason.nil?
-    if value.nil? && promise.state != :fulfilled
-      Rails.logger.warn("Unable to run promise #{promise_as_string(promise)}")
-      raise Timeout::Error
+    # https://github.com/rails/rails/issues/26847
+    ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+      # Make sure to set a timeout to avoid infinite wait
+      value = promise.value!(60)
+      raise promise.reason unless promise.reason.nil?
+      if value.nil? && promise.state != :fulfilled
+        # Could be https://github.com/ruby-concurrency/concurrent-ruby/issues/585
+        Rails.logger.warn("Unable to run promise #{promise_as_string(promise)}")
+        raise Timeout::Error
+      end
+      value
     end
-    value
   end
 
   def promise_as_string(promise)
@@ -81,7 +86,9 @@ module Kaui::EngineControllerUtil
   # Used to format flash error messages
   def as_string(e)
     if e.is_a?(KillBillClient::API::ResponseError)
-      "Error #{e.response.code}: #{as_string_from_response(e.response.body)}"
+      as_string_from_response(e.response.body)
+    elsif e.respond_to?(:cause) && !e.cause.nil?
+      as_string(e.cause)
     else
       log_rescue_error(e)
       e.message
@@ -103,6 +110,7 @@ module Kaui::EngineControllerUtil
     if error_message.respond_to? :[] and error_message['message'].present?
       # Likely BillingExceptionJson
       error_message = error_message['message']
+      error_message += " (code=#{error_message['code']})" unless error_message['code'].blank?
     end
     # Limit the error size to avoid ActionDispatch::Cookies::CookieOverflow
     error_message[0..1000]
@@ -125,7 +133,7 @@ module Kaui::EngineControllerUtil
       response = yield
       response_status = 200
     rescue KillBillClient::API::ResponseError => e
-      response = e.response.message
+      response = as_string_from_response(e.response.body)
       response_status = e.code
     rescue Exception => e
       response = e.message

data/app/controllers/kaui/invoice_tags_controller.rb

@@ -0,0 +1,28 @@
+class Kaui::InvoiceTagsController < Kaui::EngineController
+
+  def edit
+    @invoice_id = params.require(:invoice_id)
+
+    cached_options_for_klient = options_for_klient
+    fetch_tag_names = promise { (Kaui::Tag.all_for_invoice(@invoice_id, false, 'NONE', cached_options_for_klient).map { |tag| tag.tag_definition_name }).sort }
+    fetch_available_tags = promise { Kaui::TagDefinition.all_for_invoice(cached_options_for_klient) }
+
+    @tag_names = wait(fetch_tag_names)
+    @available_tags = wait(fetch_available_tags)
+  end
+
+  def update
+    account_id = params.require(:account_id)
+    invoice_id = params.require(:invoice_id)
+
+    tags = []
+    params.each do |tag, tag_name|
+      tag_info = tag.split('_')
+      next if tag_info.size != 2 or tag_info[0] != 'tag'
+      tags << tag_info[1]
+    end
+
+    Kaui::Tag.set_for_invoice(invoice_id, tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    redirect_to kaui_engine.invoice_path(invoice_id, :account_id => account_id), :notice => 'Invoice tags successfully set'
+  end
+end

data/app/controllers/kaui/invoices_controller.rb

@@ -18,26 +18,39 @@ class Kaui::InvoicesController < Kaui::EngineController
       if account.nil?
         Kaui::Invoice.list_or_search(search_key, offset, limit, cached_options_for_klient)
       else
-        account.invoices(cached_options_for_klient).map! { |invoice| Kaui::Invoice.build_from_raw_invoice(invoice) }
+        account.invoices(cached_options_for_klient.merge({ :params => { :includeVoidedInvoices => true } })).map! { |invoice| Kaui::Invoice.build_from_raw_invoice(invoice) }
       end
     end
 
-    data_extractor = lambda do |invoice, column|
-      [
+    account_id = (params[:search] || {})[:value]
+    if account_id.blank?
+      # Don't show amount and balance, and they will not be populated
+      data_extractor = lambda do |invoice, column|
+        [
+          invoice.invoice_number.to_i,
+          invoice.invoice_date
+        ][column]
+      end
+      formatter = lambda do |invoice|
+        row = [view_context.link_to(invoice.invoice_number, view_context.url_for(:controller => :invoices, :action => :show, :account_id => invoice.account_id, :id => invoice.invoice_id))]
+        row += Kaui.invoice_search_columns.call(invoice, view_context)[1]
+        row
+      end
+    else
+      data_extractor = lambda do |invoice, column|
+        [
           invoice.invoice_number.to_i,
           invoice.invoice_date,
           invoice.amount,
-          invoice.balance
-      ][column]
-    end
-
-    formatter = lambda do |invoice|
-      [
-          view_context.link_to(invoice.invoice_number, view_context.url_for(:controller => :invoices, :action => :show, :account_id => invoice.account_id, :id => invoice.invoice_id)),
-          invoice.invoice_date,
-          view_context.humanized_money_with_symbol(invoice.amount_to_money),
-          view_context.humanized_money_with_symbol(invoice.balance_to_money)
-      ]
+          invoice.balance,
+          invoice.status
+        ][column]
+      end
+      formatter = lambda do |invoice|
+        row = [view_context.link_to(invoice.invoice_number, view_context.url_for(:controller => :invoices, :action => :show, :account_id => invoice.account_id, :id => invoice.invoice_id))]
+        row += Kaui.account_invoices_columns.call(invoice, view_context)[1]
+        row
+      end
     end
 
     paginate searcher, data_extractor, formatter
@@ -48,6 +61,26 @@ class Kaui::InvoicesController < Kaui::EngineController
     cached_options_for_klient = 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
+    precedence = {
+        'EXTERNAL_CHARGE' => 0,
+        'FIXED' => 1,
+        'RECURRING' => 2,
+        'REPAIR_ADJ' => 3,
+        'USAGE' => 4,
+        'PARENT_SUMMARY' => 5,
+        'ITEM_ADJ' => 6,
+        'CBA_ADJ' => 7,
+        'CREDIT_ADJ' => 8,
+        'TAX' => 9
+    }
+    # TODO The pretty description has to be shared with the view
+    @invoice.items.sort_by! do |ii|
+      # Make sure not to compare nil (ArgumentError comparison of Array with Array failed)
+      a = precedence[ii.item_type] || 100
+      b = (ii.pretty_plan_name.blank? || !ii.item_type.in?(%w{USAGE RECURRING}) ? ii.description : ii.pretty_plan_name) || ''
+      [a, b]
+    end
 
     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) }
@@ -68,6 +101,9 @@ class Kaui::InvoicesController < Kaui::EngineController
       custom_fields_per_invoice_item.inject({}) { |hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh }
     }
 
+    fetch_invoice_tags = promise { @invoice.tags(false, 'NONE', cached_options_for_klient).sort { |tag_a, tag_b| tag_a <=> tag_b } }
+    fetch_available_invoice_tags = promise { Kaui::TagDefinition.all_for_invoice(cached_options_for_klient) }
+
     @payments = wait(fetch_payments)
     @payment_methods = wait(fetch_pms)
     @custom_fields = wait(fetch_invoice_fields)
@@ -75,6 +111,21 @@ class Kaui::InvoicesController < Kaui::EngineController
     @custom_fields_per_invoice_item = wait(fetch_custom_fields_per_invoice_item)
     @tags_per_invoice_item = wait(fetch_tags_per_invoice_item)
     @available_invoice_item_tags = wait(fetch_available_invoice_item_tags)
+    @invoice_tags = wait(fetch_invoice_tags)
+    @available_invoice_tags = wait(fetch_available_invoice_tags)
+    @available_invoice_tags.reject! { |td| td.name == 'WRITTEN_OFF' } if @invoice.status == 'VOID'
+  end
+
+  def void_invoice
+    cached_options_for_klient = options_for_klient
+    invoice = KillBillClient::Model::Invoice.find_by_id(params.require(:id), 'NONE', cached_options_for_klient)
+    begin
+      invoice.void(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 voided'
+    rescue => e
+      flash[:error] = "Unable to void invoice: #{as_string(e)}"
+      redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id)
+    end
   end
 
   def restful_show

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],
@@ -95,6 +101,11 @@ class Kaui::PaymentMethodsController < Kaui::EngineController
     end
   end
 
+  def refresh
+    Kaui::PaymentMethod.refresh(params.require(:account_id), current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    redirect_to kaui_engine.account_path(params.require(:account_id)), :notice => 'Payment methods successfully refreshed'
+  end
+
   private
 
   def find_value_from_properties(properties, key)

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
@@ -212,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/account_helper.rb

@@ -3,7 +3,7 @@ module Kaui
 
     def pretty_account_identifier
       return nil if @account.nil?
-      @account.name.presence || @account.email.presence || truncate_uuid(@account.external_key)
+      Kaui.pretty_account_identifier.call(@account)
     end
 
     def email_notifications_plugin_available?
@@ -12,9 +12,17 @@ module Kaui
       return false
     end
 
+    def deposit_plugin_available?
+      Killbill::Deposit::DepositClient.deposit_plugin_available?(Kaui.current_tenant_user_options(current_user, session)).first
+    rescue
+      return false
+    end
+
     def account_closed?
       return false if @account.nil?
-      blocking_states = @account.blocking_states('ACCOUNT','account-service','NONE', Kaui.current_tenant_user_options(current_user, session))
+      # Note: we ignore errors here, so that the call doesn't prevent the screen to load. While the error isn't surfaced, if there is an error with the catalog for instance,
+      # the AJAX call to compute the next invoice date should hopefully trigger a flash error.
+      blocking_states = @account.blocking_states('ACCOUNT', 'account-service', 'NONE', Kaui.current_tenant_user_options(current_user, session)) rescue []
 
       is_account_closed = false
       blocking_states.each do |blocking_state|

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,59 +1,30 @@
 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 || []
+        plugins_info = nodes_info.empty? ? [] : (nodes_info.first.plugins_info || [])
 
         plugins_info.each do |plugin|
           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