kaui 4.0.11 → 4.0.13

data/app/controllers/kaui/admin_tenants_controller.rb

@@ -10,68 +10,6 @@ module Kaui
       @tenants = Kaui::Tenant.all.select { |tenant| tenants_for_current_user.include?(tenant.kb_tenant_id) }
     end
 
-    def new
-      @tenant = Kaui::Tenant.new
-    end
-
-    def create
-      param_tenant = params[:tenant]
-
-      old_tenant = Kaui::Tenant.find_by_name(param_tenant[:name]) || Kaui::Tenant.find_by_api_key(param_tenant[:api_key])
-      if old_tenant
-        old_tenant.kaui_allowed_users << Kaui::AllowedUser.where(kb_username: current_user.kb_username).first_or_create
-        redirect_to admin_tenant_path(old_tenant[:id]), notice: 'Tenant was successfully configured' and return
-      end
-
-      begin
-        options = tenant_options_for_client
-        new_tenant = nil
-
-        begin
-          options[:api_key] = param_tenant[:api_key]
-          options[:api_secret] = param_tenant[:api_secret]
-          new_tenant = Kaui::AdminTenant.find_by_api_key(param_tenant[:api_key], options)
-        rescue KillBillClient::API::Unauthorized, KillBillClient::API::NotFound, KillBillClient::API::InternalServerError => e
-          # Create the tenant in Kill Bill
-          if e.instance_of?(KillBillClient::API::InternalServerError) && !e.message&.include?('TenantCacheLoader cannot find value')
-            flash[:error] = "Internal server error while retrieving tenant: #{as_string(e)}"
-            redirect_to admin_tenants_path and return
-          end
-          new_tenant = Kaui::AdminTenant.new
-          new_tenant.external_key = param_tenant[:name]
-          new_tenant.api_key = param_tenant[:api_key]
-          new_tenant.api_secret = param_tenant[:api_secret]
-          new_tenant = new_tenant.create(false, options[:username], nil, comment, options)
-        end
-
-        # Transform object to Kaui model
-        tenant_model = Kaui::Tenant.new
-        tenant_model.name = param_tenant[:name]
-        tenant_model.api_key = param_tenant[:api_key]
-        tenant_model.api_secret = param_tenant[:api_secret]
-        tenant_model.kb_tenant_id = new_tenant.tenant_id
-
-        # Save in KAUI tables
-        tenant_model.save!
-        # Make sure at least the current user can access the tenant
-        tenant_model.kaui_allowed_users << Kaui::AllowedUser.where(kb_username: current_user.kb_username).first_or_create
-      rescue KillBillClient::API::Conflict => _e
-        # tenant api_key was found but has a wrong api_secret
-        flash[:error] = "Submitted credentials for #{param_tenant[:api_key]} did not match the expected credentials."
-        redirect_to admin_tenants_path and return
-      rescue StandardError => e
-        flash[:error] = "Failed to create the tenant: #{as_string(e)}"
-        redirect_to admin_tenants_path and return
-      end
-
-      # Select the tenant, see TenantsController
-      session[:kb_tenant_id] = tenant_model.kb_tenant_id
-      session[:kb_tenant_name] = tenant_model.name
-      session[:tenant_id] = tenant_model.id
-
-      redirect_to admin_tenant_path(tenant_model[:id]), notice: 'Tenant was successfully configured'
-    end
-
     def show
       @tenant = safely_find_tenant_by_id(params[:id])
       @allowed_users = @tenant.kaui_allowed_users & retrieve_allowed_users_for_current_user
@@ -140,6 +78,68 @@ module Kaui
       end
     end
 
+    def new
+      @tenant = Kaui::Tenant.new
+    end
+
+    def create
+      param_tenant = params[:tenant]
+
+      old_tenant = Kaui::Tenant.find_by(name: param_tenant[:name]) || Kaui::Tenant.find_by(api_key: param_tenant[:api_key])
+      if old_tenant
+        old_tenant.kaui_allowed_users << Kaui::AllowedUser.where(kb_username: current_user.kb_username).first_or_create
+        redirect_to admin_tenant_path(old_tenant[:id]), notice: 'Tenant was successfully configured' and return
+      end
+
+      begin
+        options = tenant_options_for_client
+        new_tenant = nil
+
+        begin
+          options[:api_key] = param_tenant[:api_key]
+          options[:api_secret] = param_tenant[:api_secret]
+          new_tenant = Kaui::AdminTenant.find_by_api_key(param_tenant[:api_key], options)
+        rescue KillBillClient::API::Unauthorized, KillBillClient::API::NotFound, KillBillClient::API::InternalServerError => e
+          # Create the tenant in Kill Bill
+          if e.instance_of?(KillBillClient::API::InternalServerError) && !e.message&.include?('TenantCacheLoader cannot find value')
+            flash[:error] = "Internal server error while retrieving tenant: #{as_string(e)}"
+            redirect_to admin_tenants_path and return
+          end
+          new_tenant = Kaui::AdminTenant.new
+          new_tenant.external_key = param_tenant[:name]
+          new_tenant.api_key = param_tenant[:api_key]
+          new_tenant.api_secret = param_tenant[:api_secret]
+          new_tenant = new_tenant.create(false, options[:username], nil, comment, options)
+        end
+
+        # Transform object to Kaui model
+        tenant_model = Kaui::Tenant.new
+        tenant_model.name = param_tenant[:name]
+        tenant_model.api_key = param_tenant[:api_key]
+        tenant_model.api_secret = param_tenant[:api_secret]
+        tenant_model.kb_tenant_id = new_tenant.tenant_id
+
+        # Save in KAUI tables
+        tenant_model.save!
+        # Make sure at least the current user can access the tenant
+        tenant_model.kaui_allowed_users << Kaui::AllowedUser.where(kb_username: current_user.kb_username).first_or_create
+      rescue KillBillClient::API::Conflict => _e
+        # tenant api_key was found but has a wrong api_secret
+        flash[:error] = "Submitted credentials for #{param_tenant[:api_key]} did not match the expected credentials."
+        redirect_to admin_tenants_path and return
+      rescue StandardError => e
+        flash[:error] = "Failed to create the tenant: #{as_string(e)}"
+        redirect_to admin_tenants_path and return
+      end
+
+      # Select the tenant, see TenantsController
+      session[:kb_tenant_id] = tenant_model.kb_tenant_id
+      session[:kb_tenant_name] = tenant_model.name
+      session[:tenant_id] = tenant_model.id
+
+      redirect_to admin_tenant_path(tenant_model[:id]), notice: 'Tenant was successfully configured'
+    end
+
     def upload_catalog
       current_tenant = safely_find_tenant_by_id(params[:id])
 
@@ -158,7 +158,7 @@ module Kaui
       end
       if catalog_validation_errors.blank?
         Kaui::AdminTenant.upload_catalog(catalog_xml, options[:username], nil, comment, options)
-        redirect_to admin_tenant_path(current_tenant.id), notice: I18n.translate('flashes.notices.catalog_uploaded_successfully')
+        redirect_to admin_tenant_path(current_tenant.id), notice: I18n.t('flashes.notices.catalog_uploaded_successfully')
       else
         errors = ''
         catalog_validation_errors.each do |validation_error|
@@ -234,7 +234,7 @@ module Kaui
       options = tenant_options_for_client
       fetch_state_for_new_catalog_screen(options)
 
-      simple_plan = params.require(:simple_plan).delete_if { |_e, value| value.blank? }
+      simple_plan = params.require(:simple_plan).permit!.to_h.compact_blank
       # Fix issue in Rails where first entry in the multi-select array is an empty string
       simple_plan['available_base_products']&.reject!(&:blank?)
 
@@ -288,7 +288,15 @@ module Kaui
       options = tenant_options_for_client
       options[:api_key] = @tenant.api_key
       options[:api_secret] = @tenant.api_secret
-      @overdue = Kaui::Overdue.get_overdue_json(options)
+      begin
+        @overdue = Kaui::Overdue.get_overdue_json(options)
+        @overdue_corrupted = false
+      rescue StandardError => e
+        Rails.logger.warn("Failed to load overdue configuration for tenant #{@tenant.id}: #{e.class}: #{e.message}")
+        @overdue = KillBillClient::Model::Overdue.new.tap { |o| o.overdue_states = [] }
+        @overdue_corrupted = true
+        flash.now[:warning] = 'The existing overdue configuration is corrupted and cannot be loaded. Use the XML upload below to replace it with a valid configuration.'
+      end
     end
 
     def modify_overdue_config
@@ -298,12 +306,12 @@ module Kaui
       options[:api_key] = current_tenant.api_key
       options[:api_secret] = current_tenant.api_secret
 
-      view_form_model = params.require(:kill_bill_client_model_overdue).delete_if { |_e, value| value.blank? }
-      view_form_model['states'] = view_form_model['states'].values unless view_form_model['states'].blank?
+      view_form_model = params.require(:kill_bill_client_model_overdue).permit!.to_h.compact_blank
+      view_form_model['states'] = view_form_model['states'].values if view_form_model['states'].present?
 
       overdue = Kaui::Overdue.from_overdue_form_model(view_form_model)
       Kaui::Overdue.upload_tenant_overdue_config_json(overdue.to_json, options[:username], nil, comment, options)
-      redirect_to admin_tenant_path(current_tenant.id, active_tab: 'OverdueShow'), notice: I18n.translate('flashes.notices.overdue_added_successfully')
+      redirect_to admin_tenant_path(current_tenant.id, active_tab: 'OverdueShow'), notice: I18n.t('flashes.notices.overdue_added_successfully')
     end
 
     def upload_overdue_config
@@ -319,13 +327,13 @@ module Kaui
       begin
         Nokogiri::XML(overdue_config_xml, &:strict)
       rescue Nokogiri::XML::SyntaxError => e
-        flash[:error] = I18n.translate('errors.messages.invalid_xml', error: e)
+        flash[:error] = I18n.t('errors.messages.invalid_xml', error: e)
         redirect_to admin_tenant_path(current_tenant.id) and return
       end
 
       Kaui::AdminTenant.upload_overdue_config(overdue_config_xml, options[:username], nil, comment, options)
 
-      redirect_to admin_tenant_path(current_tenant.id, active_tab: 'OverdueShow'), notice: I18n.translate('flashes.notices.overdue_uploaded_successfully')
+      redirect_to admin_tenant_path(current_tenant.id, active_tab: 'OverdueShow'), notice: I18n.t('flashes.notices.overdue_uploaded_successfully')
     end
 
     def upload_invoice_template
@@ -341,7 +349,7 @@ module Kaui
 
       Kaui::AdminTenant.upload_invoice_template(invoice_template, is_manual_pay, true, options[:username], nil, comment, options)
 
-      redirect_to admin_tenant_path(current_tenant.id), notice: I18n.translate('flashes.notices.invoice_template_uploaded_successfully')
+      redirect_to admin_tenant_path(current_tenant.id), notice: I18n.t('flashes.notices.invoice_template_uploaded_successfully')
     end
 
     def upload_invoice_translation
@@ -357,7 +365,7 @@ module Kaui
 
       Kaui::AdminTenant.upload_invoice_translation(invoice_translation, locale, true, options[:username], nil, comment, options)
 
-      redirect_to admin_tenant_path(current_tenant.id), notice: I18n.translate('flashes.notices.invoice_translation_uploaded_successfully')
+      redirect_to admin_tenant_path(current_tenant.id), notice: I18n.t('flashes.notices.invoice_translation_uploaded_successfully')
     end
 
     def upload_catalog_translation
@@ -373,7 +381,7 @@ module Kaui
 
       Kaui::AdminTenant.upload_catalog_translation(catalog_translation, locale, true, options[:username], nil, comment, options)
 
-      redirect_to admin_tenant_path(current_tenant.id), notice: I18n.translate('flashes.notices.catalog_translation_uploaded_successfully')
+      redirect_to admin_tenant_path(current_tenant.id), notice: I18n.t('flashes.notices.catalog_translation_uploaded_successfully')
     end
 
     def upload_plugin_config
@@ -407,18 +415,18 @@ module Kaui
       au = Kaui::AllowedUser.find(params.require(:allowed_user).require(:id))
 
       unless current_user.root?
-        render json: { alert: 'Only the root user can remove users from tenants' }.to_json, status: 401
+        render json: { alert: 'Only the root user can remove users from tenants' }.to_json, status: :unauthorized
         return
       end
 
       # remove the association
       au.kaui_tenants.delete current_tenant
-      render json: '{}', status: 200
+      render json: '{}', status: :ok
     end
 
     def add_allowed_user
       current_tenant = safely_find_tenant_by_id(params[:tenant_id])
-      allowed_user = Kaui::AllowedUser.find_by_kb_username(params.require(:allowed_user).require(:kb_username))
+      allowed_user = Kaui::AllowedUser.find_by(kb_username: params.require(:allowed_user).require(:kb_username))
 
       unless current_user.root?
         flash[:error] = 'Only the root user can add users from tenants'
@@ -498,10 +506,10 @@ module Kaui
 
       if params[:commit] == 'Submit'
         date = Date.parse(params[:new_date]).strftime('%Y-%m-%d')
-        msg = I18n.translate('flashes.notices.clock_updated_successfully', new_date: date)
+        msg = I18n.t('flashes.notices.clock_updated_successfully', new_date: date)
       else
         date = nil
-        msg = I18n.translate('flashes.notices.clock_reset_successfully')
+        msg = I18n.t('flashes.notices.clock_reset_successfully')
       end
 
       begin
@@ -515,7 +523,7 @@ module Kaui
     end
 
     def switch_tenant
-      tenant = Kaui::Tenant.find_by_kb_tenant_id(params.require(:kb_tenant_id))
+      tenant = Kaui::Tenant.find_by(kb_tenant_id: params.require(:kb_tenant_id))
 
       # Select the tenant, see TenantsController
       session[:kb_tenant_id] = tenant.kb_tenant_id
@@ -560,7 +568,7 @@ module Kaui
     end
 
     def safely_find_tenant_by_id(tenant_id)
-      tenant = Kaui::Tenant.find_by_id(tenant_id)
+      tenant = Kaui::Tenant.find_by(id: tenant_id)
       raise ActiveRecord::RecordNotFound, "Could not find tenant #{tenant_id}" unless retrieve_tenants_for_current_user.include?(tenant.kb_tenant_id)
 
       tenant
@@ -606,7 +614,7 @@ module Kaui
       end
 
       catalog_xml = {}
-      catalog_xml = response[0][:xml] unless response.blank?
+      catalog_xml = response[0][:xml] if response.present?
 
       catalog_xml
     end

data/app/controllers/kaui/audit_logs_controller.rb

@@ -76,7 +76,7 @@ module Kaui
         end
       end
 
-      send_data csv_file, type: 'text/csv', filename: "audit-logs-#{Date.today}.csv"
+      send_data csv_file, type: 'text/csv', filename: "audit-logs-#{Time.zone.today}.csv"
     end
 
     def history

data/app/controllers/kaui/bundles_controller.rb

@@ -5,10 +5,11 @@ module Kaui
     # rubocop:disable Lint/HashCompareByIdentity
     def index
       cached_options_for_klient = options_for_klient
+      @search_query = params[:q].presence
+      @search_by = params[:search_by] || 'bundle_id'
       @per_page = (params[:per_page] || 10).to_i
       @page = (params[:page] || 1).to_i
 
-      fetch_bundles = promise { Kaui::Account.paginated_bundles(@account.account_id, (@page - 1) * @per_page, @per_page, 'NONE', cached_options_for_klient) }
       fetch_bundle_tags = promise do
         all_bundle_tags = @account.all_tags(:BUNDLE, false, 'NONE', cached_options_for_klient)
         all_bundle_tags.each_with_object({}) do |entry, hsh|
@@ -36,8 +37,15 @@ module Kaui
       fetch_available_tags = promise { Kaui::TagDefinition.all_for_bundle(cached_options_for_klient) }
       fetch_available_subscription_tags = promise { Kaui::TagDefinition.all_for_subscription(cached_options_for_klient) }
 
-      @bundles = wait(fetch_bundles)
-      @total_pages = (@bundles.pagination_max_nb_records.to_f / @per_page).ceil
+      if @search_query.present?
+        @bundles = search_bundles(@search_query, @search_by, cached_options_for_klient)
+        @total_pages = 1
+        @page = 1
+      else
+        fetched = Kaui::Account.paginated_bundles(@account.account_id, (@page - 1) * @per_page, @per_page, 'NONE', cached_options_for_klient)
+        @bundles = fetched
+        @total_pages = (fetched.pagination_max_nb_records.to_f / @per_page).ceil
+      end
 
       @tags_per_bundle = wait(fetch_bundle_tags)
       @tags_per_subscription = wait(fetch_subscription_tags)
@@ -46,8 +54,15 @@ module Kaui
       @available_tags = wait(fetch_available_tags)
       @available_subscription_tags = wait(fetch_available_subscription_tags)
 
-      # Don't load the full catalog to avoid memory issues
-      @catalog = nil
+      # Collect the distinct start dates from subscriptions on this page, then fetch
+      # only the catalog versions needed — one per unique date — to avoid loading all
+      # historical versions into memory.
+      start_dates = @bundles.flat_map(&:subscriptions).filter_map(&:start_date).uniq
+      @catalogs = start_dates.filter_map do |date|
+        Kaui::Catalog.get_account_catalog_json(@account.account_id, date, cached_options_for_klient)&.last
+      rescue StandardError
+        nil
+      end.uniq(&:effective_date)
 
       @subscription = {}
       @bundles.each do |bundle|
@@ -112,5 +127,38 @@ module Kaui
              end
       redirect_to kaui_engine.account_bundles_path(@account.account_id), notice: msg
     end
+
+    private
+
+    def search_bundles(query, search_by, options)
+      case search_by
+      when 'bundle_id'
+        bundle = Kaui::Bundle.find_by_id(query, options)
+        bundle ? [bundle] : []
+      when 'bundle_external_key'
+        bundle = Kaui::Bundle.find_by_external_key(query, false, options)
+        bundle ? [bundle] : []
+      when 'subscription_id'
+        subscription = KillBillClient::Model::Subscription.find_by_id(query, 'NONE', options)
+        if subscription
+          bundle = Kaui::Bundle.find_by_id(subscription.bundle_id, options)
+          bundle ? [bundle] : []
+        else
+          []
+        end
+      when 'subscription_external_key'
+        subscription = KillBillClient::Model::Subscription.find_by_external_key(query, 'NONE', options)
+        if subscription
+          bundle = Kaui::Bundle.find_by_id(subscription.bundle_id, options)
+          bundle ? [bundle] : []
+        else
+          []
+        end
+      else
+        []
+      end
+    rescue KillBillClient::API::NotFound
+      []
+    end
   end
 end

data/app/controllers/kaui/chargebacks_controller.rb

@@ -29,7 +29,7 @@ module Kaui
           account.bundles(cached_options_for_klient).each do |bundle|
             bundle.subscriptions.each do |subscription|
               # Already cancelled?
-              next unless subscription.billing_end_date.blank?
+              next if subscription.billing_end_date.present?
 
               # Cancel the entitlement immediately but use the default billing policy
               entitlement = Kaui::Subscription.new(subscription_id: subscription.subscription_id)

data/app/controllers/kaui/charges_controller.rb

@@ -19,13 +19,16 @@ module Kaui
     end
 
     def create
-      charge = Kaui::InvoiceItem.new(params.require(:invoice_item).delete_if { |_key, value| value.blank? })
+      charge = Kaui::InvoiceItem.new(params.require(:invoice_item).permit!.to_h.compact_blank)
       charge.account_id ||= params.require(:account_id)
 
+      # Preserve the original invoice_id since the API may not return it
+      original_invoice_id = charge.invoice_id
+
       auto_commit = params[:auto_commit] == '1'
 
       charge = charge.create(auto_commit, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.account_invoice_path(charge.account_id, charge.invoice_id), notice: 'Charge was successfully created'
+      redirect_to kaui_engine.account_invoice_path(charge.account_id, charge.invoice_id || original_invoice_id), notice: 'Charge was successfully created'
     end
   end
 end

data/app/controllers/kaui/credits_controller.rb

@@ -19,7 +19,7 @@ module Kaui
     end
 
     def create
-      credit = Kaui::Credit.new(params[:credit].delete_if { |_key, value| value.blank? })
+      credit = Kaui::Credit.new(params[:credit].permit!.to_h.compact_blank)
       credit.account_id ||= params.require(:account_id)
 
       # No need to show the newly created invoice for account level credits

data/app/controllers/kaui/custom_fields_controller.rb

@@ -101,7 +101,7 @@ module Kaui
       end
 
       if test_uuid.blank?
-        flash[:error] = I18n.translate('object_invalid_dont_exist')
+        flash[:error] = I18n.t('object_invalid_dont_exist')
         redirect_to custom_fields_path
         return
       end
@@ -120,12 +120,12 @@ module Kaui
               when :INVOICE_ITEM
                 Kaui::InvoiceItem.new(invoice_item_id: @custom_field.object_id)
               else
-                flash.now[:error] = I18n.translate('invalid_object_type', error: @custom_field.object_type)
+                flash.now[:error] = I18n.t('invalid_object_type', error: @custom_field.object_type)
                 render :new and return
               end
       model.add_custom_field(@custom_field, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
 
-      redirect_to custom_fields_path, notice: I18n.translate('custom_field_created_success')
+      redirect_to custom_fields_path, notice: I18n.t('custom_field_created_success')
     end
 
     private
@@ -143,7 +143,7 @@ module Kaui
         rescue StandardError
           # Ignore
         ensure
-          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_invoice_item_db') } unless test_uuid.blank?
+          msg = { status: '200', message: I18n.t('custom_field_uuid_exist_in_invoice_item_db') } if test_uuid.present?
         end
       when  'ACCOUNT'
         begin
@@ -151,7 +151,7 @@ module Kaui
         rescue StandardError
           # Ignore
         ensure
-          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_account_db') } if !test_uuid.blank? && (test_uuid.account_id == param_uuid)
+          msg = { status: '200', message: I18n.t('custom_field_uuid_exist_in_account_db') } if test_uuid.present? && (test_uuid.account_id == param_uuid)
         end
       when  'BUNDLE'
         begin
@@ -159,7 +159,7 @@ module Kaui
         rescue StandardError
           # Ignore
         ensure
-          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_bundle_db') } if !test_uuid.blank? && (test_uuid.bundle_id == param_uuid)
+          msg = { status: '200', message: I18n.t('custom_field_uuid_exist_in_bundle_db') } if test_uuid.present? && (test_uuid.bundle_id == param_uuid)
         end
       when  'SUBSCRIPTION'
         begin
@@ -167,7 +167,7 @@ module Kaui
         rescue StandardError
           # Ignore
         ensure
-          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_subscription_db') } if !test_uuid.blank? && (test_uuid.subscription_id == param_uuid)
+          msg = { status: '200', message: I18n.t('custom_field_uuid_exist_in_subscription_db') } if test_uuid.present? && (test_uuid.subscription_id == param_uuid)
         end
       when  'INVOICE'
         begin
@@ -176,7 +176,7 @@ module Kaui
         rescue StandardError
           # Ignore
         ensure
-          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_invoice_db') } if !test_uuid.blank? && (test_uuid.invoice_id == param_uuid)
+          msg = { status: '200', message: I18n.t('custom_field_uuid_exist_in_invoice_db') } if test_uuid.present? && (test_uuid.invoice_id == param_uuid)
         end
       when  'PAYMENT'
         begin
@@ -184,18 +184,18 @@ module Kaui
         rescue StandardError
           # Ignore
         ensure
-          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_invoice_payment_db') } if !test_uuid.blank? && (test_uuid.payment_id == param_uuid)
+          msg = { status: '200', message: I18n.t('custom_field_uuid_exist_in_invoice_payment_db') } if test_uuid.present? && (test_uuid.payment_id == param_uuid)
         end
         begin
           test_uuid = Kaui::Payment.find_by_external_key(param_uuid, false, true, options_for_klient)
         rescue StandardError
           # Ignore
         ensure
-          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_payment_db') } if !test_uuid.blank? && (test_uuid.payment_id == param_uuid)
+          msg = { status: '200', message: I18n.t('custom_field_uuid_exist_in_payment_db') } if test_uuid.present? && (test_uuid.payment_id == param_uuid)
         end
       end
 
-      msg ||= { status: '431', message: I18n.translate('custom_field_uuid_do_not_exist_in_db') }
+      msg ||= { status: '431', message: I18n.t('custom_field_uuid_do_not_exist_in_db') }
       render json: msg
     end
   end

data/app/controllers/kaui/engine_controller_util.rb

@@ -111,9 +111,9 @@ module Kaui
     def promise_as_string(promise)
       return 'nil' if promise.nil?
 
-      executor = promise.instance_variable_get('@executor')
+      executor = promise.instance_variable_get(:@executor)
       executor_as_string = "queue_length=#{executor.queue_length}, pool_size=#{executor.length}"
-      "#{promise.instance_variable_get('@promise_body')}[state=#{promise.state}, parent=#{promise_as_string(promise.instance_variable_get('@parent'))}, executor=[#{executor_as_string}]]"
+      "#{promise.instance_variable_get(:@promise_body)}[state=#{promise.state}, parent=#{promise_as_string(promise.instance_variable_get(:@parent))}, executor=[#{executor_as_string}]]"
     end
 
     # Used to format flash error messages
@@ -127,7 +127,7 @@ module Kaui
         as_string(exception.cause)
       else
         log_rescue_error(exception)
-        exception.message
+        exception.message.to_s[0..200]
       end
     end
 
@@ -147,10 +147,10 @@ module Kaui
       if error_message.respond_to?(:[]) && error_message['message'].present?
         # Likely BillingExceptionJson
         error_message = error_message['message']
-        error_message += " (code=#{error_message['code']})" unless error_message['code'].blank?
+        error_message += " (code=#{error_message['code']})" if error_message['code'].present?
       end
       # Limit the error size to avoid ActionDispatch::Cookies::CookieOverflow
-      error_message[0..1000]
+      error_message.to_s[0..200]
     end
 
     def nested_hash_value(obj, key)

data/app/controllers/kaui/home_controller.rb

@@ -20,6 +20,10 @@ module Kaui
 
     def search
       object_type, search_query = splitting_new_search(params[:q])
+      if search_query.nil?
+        search_error('Please specify a search type (e.g., "Account: search_term")')
+        return
+      end
       object_type = object_type.tr(' ', '_').downcase
       cached_options_for_klient = options_for_klient
       send("#{object_type}_search", search_query, nil, 0, cached_options_for_klient)
@@ -254,7 +258,7 @@ module Kaui
     end
 
     def unsupported_search_field(object_type, object_field)
-      field_name = object_field.gsub('_', ' ')
+      field_name = object_field.tr('_', ' ')
       search_error("\"#{object_type}\": Search by \"#{field_name}\" is not supported.")
     end
 
@@ -283,7 +287,7 @@ module Kaui
         '0'
       end
 
-      search_error("\"#{search_by}\" is not a valid search by value") if !search_by.blank? && !search_by.in?(Kaui::ObjectHelper::ADVANCED_SEARCH_OBJECT_FIELDS)
+      search_error("\"#{search_by}\" is not a valid search by value") if search_by.present? && !search_by.in?(Kaui::ObjectHelper::ADVANCED_SEARCH_OBJECT_FIELDS)
 
       [object_type, search_for, search_by, fast]
     end

data/app/controllers/kaui/invoices_controller.rb

@@ -6,7 +6,7 @@ module Kaui
     def index
       @search_query = params[:account_id]
       @advance_search_query = params[:q] || request.query_string
-      @ordering = params[:ordering] || (@search_query.blank? ? 'desc' : 'asc')
+      @ordering = params[:ordering] || 'desc'
       @offset = params[:offset] || 0
       @limit = params[:limit] || 50
       @search_fields = Kaui::Invoice::ADVANCED_SEARCH_COLUMNS.map { |attr| [attr, attr.split('_').join(' ').capitalize] }
@@ -21,7 +21,7 @@ module Kaui
       all_fields_checked = params[:allFieldsChecked] == 'true'
       query_string = handle_balance_search(params[:search])
       columns = if all_fields_checked
-                  KillBillClient::Model::InvoiceAttributes.instance_variable_get('@json_attributes') - Kaui::Invoice::TABLE_IGNORE_COLUMNS
+                  KillBillClient::Model::InvoiceAttributes.instance_variable_get(:@json_attributes) - Kaui::Invoice::TABLE_IGNORE_COLUMNS
                 else
                   params.require(:columnsString).split(',').map { |attr| attr.split.join('_').downcase }
                 end
@@ -52,7 +52,7 @@ module Kaui
           csv << columns.map { |attr| invoice&.send(attr.downcase) }
         end
       end
-      send_data csv_string, filename: "invoices-#{Date.today}.csv", type: 'text/csv'
+      send_data csv_string, filename: "invoices-#{Time.zone.today}.csv", type: 'text/csv'
     end
 
     def pagination
@@ -134,7 +134,7 @@ module Kaui
         end
       end
 
-      fetch_invoice_tags = promise { @invoice.tags(false, 'NONE', cached_options_for_klient).sort { |tag_a, tag_b| tag_a <=> tag_b } }
+      fetch_invoice_tags = promise { @invoice.tags(false, 'NONE', cached_options_for_klient).sort }
       fetch_available_invoice_tags = promise { Kaui::TagDefinition.all_for_invoice(cached_options_for_klient) }
 
       @payments = wait(fetch_payments)
@@ -173,7 +173,9 @@ module Kaui
     end
 
     def show_html
+      # rubocop:disable Rails/OutputSafety -- Invoice HTML from Kill Bill backend is trusted
       render html: Kaui::Invoice.as_html(params.require(:id), options_for_klient).html_safe
+      # rubocop:enable Rails/OutputSafety
     end
 
     def commit_invoice

data/app/controllers/kaui/payment_methods_controller.rb

@@ -2,13 +2,17 @@
 
 module Kaui
   class PaymentMethodsController < Kaui::EngineController
+    def show
+      restful_show
+    end
+
     def new
       @payment_method = Kaui::PaymentMethod.new(account_id: params[:account_id],
                                                 plugin_name: params[:plugin_name] || Kaui.creditcard_plugin_name.call)
     end
 
     def create
-      @payment_method             = Kaui::PaymentMethod.new(params[:payment_method].delete_if { |_key, value| value.blank? })
+      @payment_method             = Kaui::PaymentMethod.new(params[:payment_method].permit!.to_h.compact_blank)
       # Transform "1" into boolean
       @payment_method.is_default  = @payment_method.is_default == '1'
       # Sensible default
@@ -84,10 +88,6 @@ module Kaui
       end
     end
 
-    def show
-      restful_show
-    end
-
     def restful_show
       payment_method = Kaui::PaymentMethod.find_by_id(params.require(:id), false, false, [], 'NONE', options_for_klient)
       redirect_to kaui_engine.account_path(payment_method.account_id)