kaui 2.0.4 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 062f8cf3943a8a8cae8f80490cac4c2545ed68bd
-  data.tar.gz: 398c6df309bdd8bf44eaddcac3273e9cfc394d17
+  metadata.gz: e5d858912d18a92b6d29b430c5abcef292407e21
+  data.tar.gz: c9fb2496bc22b4c176cbf491d914be4f2ff794fa
 SHA512:
-  metadata.gz: df121d5c0caa28f819c2678c7abf61a4ed161ee16dc6f047f7e6ca0279348f682de5dd8ce57e6bd31ad70f164892a44d911f22da2eaaa3689c4bf06dd560b302
-  data.tar.gz: 405d0913456d27232ee1518fb1637efc35423f62f5a948e3312e817c2547fe8f04f38029b5e8d4785522480ef261853640bddf728143e3f84a45408ff26b1219
+  metadata.gz: 1b9de048f13170e6ca37fd7656f5c4524e6c72f1820efb4c16d9778f61890fd613a4ab31daa25216792396d636d4df9215638e153f411f7e49fc1f3a17d479cc
+  data.tar.gz: c1f5fca064ec6d5e671f69ab21fccc35d63f02f24c9b05ff897b20466a2980f1c470a3bc11b14df8060b368dc77646d03307ed87b21eac94f828033cae40e295

data/README.md

@@ -91,22 +91,6 @@ Alternatively, you can run the `kaui` script under `bin` by setting your loadpat
 
     ruby -Ilib bin/kaui /path/to/rails/app --path=$PWD --skip-bundle
 
-Releases
-========
-
-To trigger a release, run (update `patch` as needed):
-
-```
-bundle exec gem bump -c -p -t -v patch
-```
-
-This will:
-
-* Update the `version.rb` file
-* Commit the changes
-* Create the new tag and push the changes
-
-GitHub Actions will automatically push the new gem to Rubygems.
 
 Multi-Tenancy
 =============

data/app/assets/stylesheets/kaui/account.less

@@ -37,4 +37,12 @@ h1 span.account-child-label{
       margin: 8px;
     }
   }
-}
+}
+
+.form-force-inline {
+  display: inline;
+}
+
+.form-right {
+  float: right;
+}

data/app/assets/stylesheets/kaui/common.less

@@ -99,7 +99,7 @@ span {
         font-weight: normal;
         color: rgb(119, 119, 119);
 
-        &.label-success, &.label-warning, &.label-danger {
+        &.label-default, &.label-success, &.label-warning, &.label-danger {
             color: #fff;
         }
     }
@@ -497,7 +497,7 @@ table.subtitle {
             }
 
             a {
-                margin: 0 20px;
+                margin: 0 5px;
                 text-transform: uppercase;
                 font-size: 12px;
 

data/app/controllers/kaui/accounts_controller.rb

@@ -29,12 +29,9 @@ class Kaui::AccountsController < Kaui::EngineController
     data_extractor = lambda do |account, column|
       [
           account.parent_account_id,
-          account.name,
           account.account_id,
           account.external_key,
-          account.account_balance,
-          account.city,
-          account.country
+          account.account_balance
       ][column]
     end
 
@@ -44,12 +41,9 @@ class Kaui::AccountsController < Kaui::EngineController
         child_label = account.parent_account_id.nil? ? '' : view_context.content_tag(:span, 'Child', class: ['label', 'label-info', 'account-child-label'])
       end
 
-      [
-          child_label,
-          view_context.link_to(account.account_id, view_context.url_for(:action => :show, :account_id => account.account_id)),
-          account.external_key,
-          view_context.humanized_money_with_symbol(account.balance_to_money)
-      ]
+      row = [child_label, view_context.link_to(account.account_id, view_context.url_for(:action => :show, :account_id => account.account_id))]
+      row += Kaui.account_search_columns.call(account, view_context)[1]
+      row
     end
 
     paginate searcher, data_extractor, formatter
@@ -83,17 +77,17 @@ class Kaui::AccountsController < Kaui::EngineController
     @account = Kaui::Account::find_by_id_or_key(params.require(:account_id), true, true, cached_options_for_klient)
 
     fetch_children = promise { @account.children(false, false, 'NONE',cached_options_for_klient)}
-    fetch_parent = promise (!@account.parent_account_id.nil?){ Kaui::Account::find_by_id(@account.parent_account_id,false,false,cached_options_for_klient)}
+    fetch_parent = @account.parent_account_id.nil? ? nil : promise { Kaui::Account::find_by_id(@account.parent_account_id,false,false,cached_options_for_klient) }
     fetch_overdue_state = promise { @account.overdue(cached_options_for_klient) }
     fetch_account_tags = promise { @account.tags(false, 'NONE', cached_options_for_klient).sort { |tag_a, tag_b| tag_a <=> tag_b } }
     fetch_account_fields = promise { @account.custom_fields('NONE', cached_options_for_klient).sort { |cf_a, cf_b| cf_a.name.downcase <=> cf_b.name.downcase } }
     fetch_account_emails = promise { Kaui::AccountEmail.find_all_sorted_by_account_id(@account.account_id, 'NONE', cached_options_for_klient) }
     fetch_payments = promise { @account.payments(cached_options_for_klient).map! { |payment| Kaui::Payment.build_from_raw_payment(payment) } }
-    fetch_payment_methods = promise(false) { Kaui::PaymentMethod.find_all_by_account_id(@account.account_id, false, cached_options_for_klient) }
+    fetch_payment_methods = promise { Kaui::PaymentMethod.find_all_by_account_id(@account.account_id, false, cached_options_for_klient) }
 
     # is email notification plugin available
     is_email_notifications_plugin_available = Kenui::EmailNotificationService.email_notification_plugin_available?(cached_options_for_klient).first
-    fetch_email_notification_configuration = promise(is_email_notifications_plugin_available) do
+    fetch_email_notification_configuration = !is_email_notifications_plugin_available ? nil : promise do
       Kenui::EmailNotificationService.get_configuration_per_account(params.require(:account_id),cached_options_for_klient)
     end.then do |configuration|
       if configuration.first.is_a?(FalseClass)
@@ -106,7 +100,7 @@ class Kaui::AccountsController < Kaui::EngineController
     fetch_payment_methods_with_details = fetch_payment_methods.then do |pms|
       ops = []
       pms.each do |pm|
-        ops << promise(false) {
+        ops << promise {
           begin
             Kaui::PaymentMethod.find_by_id(pm.payment_method_id, true, cached_options_for_klient)
           rescue => e
@@ -125,7 +119,7 @@ class Kaui::AccountsController < Kaui::EngineController
     @custom_fields = wait(fetch_account_fields)
     @account_emails = wait(fetch_account_emails)
     wait(fetch_payment_methods)
-    @payment_methods = wait(fetch_payment_methods_with_details).map { |pm_f| pm_f.execute }.map { |pm_f| wait(pm_f) }.reject { |pm| pm.nil? }
+    @payment_methods = wait(fetch_payment_methods_with_details).map{ |pm_f| wait(pm_f) }.reject { |pm| pm.nil? }
     @available_tags = wait(fetch_available_tags)
     @children = wait(fetch_children)
     @account_parent = @account.parent_account_id.nil? ? nil : wait(fetch_parent)
@@ -183,6 +177,8 @@ class Kaui::AccountsController < Kaui::EngineController
       redirect_to account_path(account_id), :notice => "Nothing to generate for target date #{target_date.nil? ? 'today' : target_date}"
     elsif dry_run
       @invoice = Kaui::Invoice.build_from_raw_invoice(invoice)
+      @invoice_tags = []
+      @available_invoice_tags = []
       @payments = []
       @payment_methods = nil
       @account = Kaui::Account.find_by_id(account_id, false, false, options_for_klient)

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
@@ -113,4 +113,4 @@ class Kaui::AuditLogsController < Kaui::EngineController
       OBJECT_WITH_HISTORY.include?(object_type)
     end
 
-end
+end

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,25 +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
-      # 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
+    # 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)
@@ -82,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
@@ -104,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]

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
@@ -88,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)
@@ -95,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

@@ -101,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/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/plugin_helper.rb

@@ -10,7 +10,7 @@ module Kaui
       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?

data/app/helpers/kaui/uuid_helper.rb

@@ -6,6 +6,7 @@ module Kaui
       split = uuid.split('-')
       split[0] + '-...-' + split[4]
     end
+    module_function :truncate_uuid
 
     def object_id_popover(object_id, placement = 'right', title = nil)
       content_tag(:span, truncate_uuid(object_id),

data/app/models/kaui/tag.rb

@@ -9,7 +9,7 @@ class Kaui::Tag < KillBillClient::Model::Tag
   end
 
   class << self
-    [:account, :bundle, :subscription].each do |model|
+    [:account, :bundle, :subscription, :invoice].each do |model|
       define_method "all_for_#{model.to_s}" do |model_id, included_deleted, audit, options|
         instance = Kaui.const_get(model.to_s.camelize).new("#{model.to_s}_id".to_sym => model_id)
         instance.tags(included_deleted, audit, options)

data/app/views/kaui/accounts/_billing_info.html.erb

@@ -25,6 +25,10 @@
                       <%= link_to '<i class="fa fa-plus-square"></i>&nbsp;Create charge'.html_safe,
                                   kaui_engine.new_account_charge_path(@account.account_id, :currency => @account.currency) %>
                   <% end %>
+                  <% if deposit_plugin_available? %>
+                      <%= link_to '<i class="fa fa-plus-square"></i>&nbsp;Create deposit'.html_safe,
+                                  deposit_engine.collection_index_path(:account_id => @account.account_id, :currency => @account.currency) %>
+                  <% end %>
                 </div>
               </div>
             </div>

data/app/views/kaui/accounts/_payment_methods.html.erb

@@ -7,6 +7,9 @@
           <%= link_to '<i class="fa fa-plus-square"></i>'.html_safe,
                       kaui_engine.new_payment_method_path(:account_id => @account.account_id),
                       :class => 'btn btn-xs' %>
+          <%= form_tag kaui_engine.refresh_payment_methods_path(params.to_h), :method => :post, :class => 'form-force-inline form-right' do %>
+              <%= button_tag '<i class="fa fa-refresh"></i>'.html_safe, :class => 'btn btn-xs' %>
+          <% end %>
       <% end %>
     </h1>
 

data/app/views/kaui/accounts/index.html.erb

@@ -13,8 +13,9 @@
       <tr>
         <th></th>
         <th>ID</th>
-        <th>External key</th>
-        <th>Balance</th>
+        <% Kaui.account_search_columns.call()[0].each do |title| %>
+          <th><%= title %></th>
+        <% end %>
       </tr>
       </thead>
       <tbody>
@@ -39,8 +40,10 @@ $(document).ready(function() {
     },
     "pageLength": <%= @limit %>,
     "displayStart": <%= @offset %>,
-    <% unless @ordering.blank? %>
-        "order": [[ 1, "<%= @ordering %>" ]],
+    <% if @search_query.blank? %>
+      "ordering": false,
+    <% elsif !@ordering.blank? %>
+      "order": [[ 1, "<%= @ordering %>" ]],
     <% end %>
     "processing": true,
     "serverSide": true,