kaui 2.1.0 → 3.0.1

data/app/assets/stylesheets/kaui/tooltip.scss

@@ -0,0 +1,15 @@
+
+.tooltip-arrow,
+.kb-tooltip + .tooltip > .tooltip-inner {background-color: #C0E0E3;}
+.kb-tooltip + .tooltip.top > .tooltip-arrow {background-color: #fff; border-top: #C0E0E3;}
+
+
+.kb-tooltip + .bs-tooltip-auto[x-placement^=top] .arrow::before,
+.kb-tooltip + .bs-tooltip-top .arrow::before {
+  border-bottom-color: #C0E0E3;
+}
+
+.tooltip .tooltip-arrow {
+border-top: 5px solid #C0E0E3 !important;}
+
+

data/app/controllers/kaui/account_children_controller.rb

@@ -1,47 +1,44 @@
+# frozen_string_literal: true
 
-class Kaui::AccountChildrenController < Kaui::EngineController
+module Kaui
+  class AccountChildrenController < Kaui::EngineController
+    def index
+      # check that the required parent account id is provided and get its data
 
-  def index
-
-    # check that the required parent account id is provided and get its data
-    begin
-      @account = Kaui::Account::find_by_id(params.require(:account_id), false, false, options_for_klient)
+      @account = Kaui::Account.find_by_id(params.require(:account_id), false, false, options_for_klient)
     rescue KillBillClient::API::NotFound
       flash[:error] = "Invalid parent account id supplied #{params.require(:account_id)}"
       redirect_to kaui_engine.home_path and return
     end
 
-  end
+    # It will fetch all the children. It use the paginate to fetch all children as permitting for future exchange
+    # when killbill account/{account_id}/children endpoint includes offset and limit parameters.
+    def pagination
+      cached_options_for_klient = options_for_klient
+      searcher = lambda do |parent_account_id, _offset, _limit|
+        Kaui::Account.find_children(parent_account_id, true, true, 'NONE', cached_options_for_klient)
+      end
 
-  # It will fetch all the children. It use the paginate to fetch all children as permitting for future exchange
-  # when killbill account/{account_id}/children endpoint includes offset and limit parameters.
-  def pagination
-    cached_options_for_klient = options_for_klient
-    searcher = lambda do |parent_account_id, offset, limit|
-      Kaui::Account.find_children(parent_account_id, true, true, 'NONE', cached_options_for_klient)
-    end
-
-    data_extractor = lambda do |account_child, column|
-      [
+      data_extractor = lambda do |account_child, column|
+        [
           account_child.name,
           account_child.account_id,
           account_child.external_key,
           account_child.account_balance,
           account_child.city,
           account_child.country
-      ][column]
-    end
+        ][column]
+      end
 
-    formatter = lambda do |account_child|
-      [
+      formatter = lambda do |account_child|
+        [
           view_context.link_to(account_child.account_id, account_path(account_child.account_id)),
           account_child.external_key,
-          view_context.humanized_money_with_symbol(account_child.balance_to_money),
-      ]
-    end
+          view_context.humanized_money_with_symbol(account_child.balance_to_money)
+        ]
+      end
 
-    paginate searcher, data_extractor, formatter
+      paginate searcher, data_extractor, formatter
+    end
   end
-
-
-end
+end

data/app/controllers/kaui/account_custom_fields_controller.rb

@@ -1,24 +1,25 @@
-class Kaui::AccountCustomFieldsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def index
-    cached_options_for_klient = options_for_klient
-    account = Kaui::Account::find_by_id_or_key(params.require(:account_id), true, true, cached_options_for_klient)
-    custom_fields = account.all_custom_fields(nil, 'NONE', cached_options_for_klient)
+module Kaui
+  class AccountCustomFieldsController < Kaui::EngineController
+    def index
+      cached_options_for_klient = options_for_klient
+      account = Kaui::Account.find_by_id_or_key(params.require(:account_id), true, true, cached_options_for_klient)
+      custom_fields = account.all_custom_fields(nil, 'NONE', cached_options_for_klient)
 
-
-    formatter = lambda do |custom_field|
-      url_for_object = view_context.url_for_object(custom_field.object_id, custom_field.object_type)
-      [
+      formatter = lambda do |custom_field|
+        url_for_object = view_context.url_for_object(custom_field.object_id, custom_field.object_type)
+        [
           url_for_object ? view_context.link_to(custom_field.object_id, url_for_object) : custom_field.object_id,
           custom_field.object_type,
           custom_field.name,
           custom_field.value
-      ]
-    end
-    @custom_fields_json = []
-    custom_fields.each { |page| @custom_fields_json << formatter.call(page) }
+        ]
+      end
+      @custom_fields_json = []
+      custom_fields.each { |page| @custom_fields_json << formatter.call(page) }
 
-    @custom_fields_json = @custom_fields_json.to_json
+      @custom_fields_json = @custom_fields_json.to_json
+    end
   end
-
 end

data/app/controllers/kaui/account_emails_controller.rb

@@ -1,36 +1,39 @@
-class Kaui::AccountEmailsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def new
-    @account_email = Kaui::AccountEmail.new(:account_id => params.require(:account_id),
-                                            :email => params[:email])
-  end
+module Kaui
+  class AccountEmailsController < Kaui::EngineController
+    def new
+      @account_email = Kaui::AccountEmail.new(account_id: params.require(:account_id),
+                                              email: params[:email])
+    end
 
-  def create
-    @account_email = Kaui::AccountEmail.new(account_email_params.merge(:account_id => params.require(:account_id)))
+    def create
+      @account_email = Kaui::AccountEmail.new(account_email_params.merge(account_id: params.require(:account_id)))
 
-    begin
-      @account_email.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.account_path(@account_email.account_id), :notice => 'Account email was successfully added'
-    rescue => e
-      flash.now[:error] = "Error while adding the email: #{as_string(e)}"
-      render :action => :new
+      begin
+        @account_email.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+        redirect_to kaui_engine.account_path(@account_email.account_id), notice: 'Account email was successfully added'
+      rescue StandardError => e
+        flash.now[:error] = "Error while adding the email: #{as_string(e)}"
+        render action: :new
+      end
     end
-  end
 
-  def destroy
-    account_email = Kaui::AccountEmail.new(:account_id => params.require(:account_id),
-                                           :email => params.require(:id))
+    def destroy
+      account_email = Kaui::AccountEmail.new(account_id: params.require(:account_id),
+                                             email: params.require(:id))
 
-    account_email.destroy(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      account_email.destroy(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
 
-    redirect_to kaui_engine.account_path(account_email.account_id), :notice => 'Account email was successfully deleted'
-  end
+      redirect_to kaui_engine.account_path(account_email.account_id), notice: 'Account email was successfully deleted'
+    end
 
-  private
+    private
 
-  def account_email_params
-    account_email = params.require(:account_email)
-    account_email.require(:email)
-    account_email
+    def account_email_params
+      account_email = params.require(:account_email)
+      account_email.require(:email)
+      account_email
+    end
   end
 end

data/app/controllers/kaui/account_tags_controller.rb

@@ -1,48 +1,51 @@
-class Kaui::AccountTagsController < Kaui::EngineController
-
-  def index
-    cached_options_for_klient = options_for_klient
-    account = Kaui::Account::find_by_id_or_key(params.require(:account_id), true, true, cached_options_for_klient)
-    tags = account.all_tags(nil, false, 'NONE', cached_options_for_klient)
-
-
-    formatter = lambda do |tag|
-      url_for_object = view_context.url_for_object(tag.object_id, tag.object_type)
-      [
+# frozen_string_literal: true
+
+module Kaui
+  class AccountTagsController < Kaui::EngineController
+    def index
+      cached_options_for_klient = options_for_klient
+      account = Kaui::Account.find_by_id_or_key(params.require(:account_id), true, true, cached_options_for_klient)
+      tags = account.all_tags(nil, false, 'NONE', cached_options_for_klient)
+
+      formatter = lambda do |tag|
+        url_for_object = view_context.url_for_object(tag.object_id, tag.object_type)
+        [
           tag.tag_id,
           url_for_object ? view_context.link_to(tag.object_id, url_for_object) : tag.object_id,
           tag.object_type,
           tag.tag_definition_name
-      ]
+        ]
+      end
+      @tags_json = []
+      tags.each { |page| @tags_json << formatter.call(page) }
+
+      @tags_json = @tags_json.to_json
     end
-    @tags_json = []
-    tags.each { |page| @tags_json << formatter.call(page) }
 
-    @tags_json = @tags_json.to_json
-  end
+    def edit
+      @account_id = params.require(:account_id)
 
-  def edit
-    @account_id = params.require(:account_id)
+      cached_options_for_klient = options_for_klient
+      fetch_tag_names = promise { Kaui::Tag.all_for_account(@account_id, false, 'NONE', cached_options_for_klient).map(&:tag_definition_name).sort }
+      fetch_available_tags = promise { Kaui::TagDefinition.all_for_account(cached_options_for_klient) }
 
-    cached_options_for_klient = options_for_klient
-    fetch_tag_names = promise { (Kaui::Tag.all_for_account(@account_id, false, 'NONE', cached_options_for_klient).map { |tag| tag.tag_definition_name }).sort }
-    fetch_available_tags = promise { Kaui::TagDefinition.all_for_account(cached_options_for_klient) }
+      @tag_names = wait(fetch_tag_names)
+      @available_tags = wait(fetch_available_tags)
+    end
 
-    @tag_names = wait(fetch_tag_names)
-    @available_tags = wait(fetch_available_tags)
-  end
+    def update
+      account_id = params.require(:account_id)
 
-  def update
-    account_id = params.require(:account_id)
+      tags = []
+      params.each do |tag, _tag_name|
+        tag_info = tag.split('_')
+        next if (tag_info.size != 2) || (tag_info[0] != 'tag')
 
-    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
+        tags << tag_info[1]
+      end
 
-    Kaui::Tag.set_for_account(account_id, tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-    redirect_to kaui_engine.account_path(account_id), :notice => 'Account tags successfully set'
+      Kaui::Tag.set_for_account(account_id, tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.account_path(account_id), notice: 'Account tags successfully set'
+    end
   end
 end

data/app/controllers/kaui/account_timelines_controller.rb

@@ -1,43 +1,48 @@
-class Kaui::AccountTimelinesController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def show
-    timeline = Kaui::AccountTimeline.find_by_account_id(params.require(:account_id), 'FULL', options_for_klient)
-    @account = timeline.account
-    @bundles = timeline.bundles
-    @invoices = timeline.invoices
-    @payments = timeline.payments
-    extract_invoices_by_id(@invoices)
+module Kaui
+  class AccountTimelinesController < Kaui::EngineController
+    def show
+      timeline = Kaui::AccountTimeline.find_by_account_id(params.require(:account_id), 'FULL', options_for_klient)
+      @account = timeline.account
+      @bundles = timeline.bundles
+      @invoices = timeline.invoices
+      @payments = timeline.payments
+      extract_invoices_by_id(@invoices)
 
-    # Lookup all bundle names
-    @bundle_names = {}
-    @bundle_names_by_invoice_id = {}
-    @bundle_keys_by_invoice_id = {}
-    @bundles.each do |bundle|
-      load_bundle_name_for_timeline(bundle.external_key)
-    end
-    @invoices.each do |invoice|
-      @bundle_names_by_invoice_id[invoice.invoice_id] = Set.new
-      @bundle_keys_by_invoice_id[invoice.invoice_id] = Set.new
-      (invoice.bundle_keys || '').split(',').each do |bundle_key|
-        load_bundle_name_for_timeline(bundle_key)
-        @bundle_names_by_invoice_id[invoice.invoice_id] << @bundle_names[bundle_key]
-        @bundle_keys_by_invoice_id[invoice.invoice_id] << bundle_key
+      # Lookup all bundle names
+      @bundle_names = {}
+      @bundle_names_by_invoice_id = {}
+      @bundle_keys_by_invoice_id = {}
+      @bundles.each do |bundle|
+        load_bundle_name_for_timeline(bundle.external_key)
+      end
+      @invoices.each do |invoice|
+        @bundle_names_by_invoice_id[invoice.invoice_id] = Set.new
+        @bundle_keys_by_invoice_id[invoice.invoice_id] = Set.new
+        (invoice.bundle_keys || '').split(',').each do |bundle_key|
+          load_bundle_name_for_timeline(bundle_key)
+          @bundle_names_by_invoice_id[invoice.invoice_id] << @bundle_names[bundle_key]
+          @bundle_keys_by_invoice_id[invoice.invoice_id] << bundle_key
+        end
       end
-    end
 
-    @selected_bundle = params.has_key?(:external_key) ? @bundle_names[params[:external_key]] : nil
-  end
+      @selected_bundle = params.key?(:external_key) ? @bundle_names[params[:external_key]] : nil
+    end
 
-  private
+    private
 
-  def load_bundle_name_for_timeline(bundle_key)
-    @bundle_names[bundle_key] ||= Kaui.bundle_key_display_string.call(bundle_key)
-  end
+    def load_bundle_name_for_timeline(bundle_key)
+      @bundle_names[bundle_key] ||= Kaui.bundle_key_display_string.call(bundle_key)
+    end
 
-  def extract_invoices_by_id(all_invoices)
-    return {} if all_invoices.nil? || all_invoices.empty?
+    def extract_invoices_by_id(all_invoices)
+      return {} if all_invoices.nil? || all_invoices.empty?
 
-    # Convert into Kaui::Invoice to benefit from additional methods xxx_to_money
-    @invoices_by_id = all_invoices.inject({}) { |hsh, invoice| hsh[invoice.invoice_id] = Kaui::Invoice.build_from_raw_invoice(invoice); hsh }
+      # Convert into Kaui::Invoice to benefit from additional methods xxx_to_money
+      @invoices_by_id = all_invoices.each_with_object({}) do |invoice, hsh|
+        hsh[invoice.invoice_id] = Kaui::Invoice.build_from_raw_invoice(invoice)
+      end
+    end
   end
 end