kaui 3.0.5 → 3.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1d09c53f971465792983fa62e85842cf0f7807e429793bcfaf298129fc30720
-  data.tar.gz: 4536845ab8261e1e16ef4d9a8caba638e62fd4b02090fe0142430fb4d988e8ed
+  metadata.gz: 23207942c5d84c906aa3e23e06c74e86f278b7889088efb260bbb7d591043b4b
+  data.tar.gz: 56df3037f7210cffd9521a410df4302d93da6e5c3989bc5717fbad37033fcb9b
 SHA512:
-  metadata.gz: a3f5018cfde24d5a5a53634a3b4098bb45cd439e0bcad1497163bb928737e6b628b6af430f4e3ff4ba792ed0e72c25c57f7a34f20a49480480383c35e4ddf741
-  data.tar.gz: e4079ed0b2ec629b9fb1ea6fbbc4d617515ec78e2cc75cc4b2742578164c14e8b2d344ebeebba5e3ca83a7a100cf844f0d65cef93d0d770d7743c94444bbb8a9
+  metadata.gz: 5542399f26a14547366266fd4047b78cada6204033610005d9901e8d1a8c7a2367423809e468f599d602e1e59880c0f08cfded1298deeef41bc593e4203592de
+  data.tar.gz: eff5e260361d301bf8cc10ac973320c25f9fb76347aa57b3792017acc6fb4d817cea4e798eb797bf6d7c575862b5e1b4bf62ceed2d036ab33611f66f62a28e15

data/app/assets/javascripts/kaui/kaui_override.js

@@ -132,12 +132,7 @@ jQuery(document).ready(function ($) {
 
     function set_first_name_length(name){
         var name_in_parts = name.trim().split(' ');
-
-        if (name_in_parts.length > 1){
-            $('#account_first_name_length').val(name_in_parts[0].length);
-        }else{
-            $('#account_first_name_length').val('');
-        }
+        $('#account_first_name_length').val(name_in_parts[0].length);
     }
 
 

data/app/assets/javascripts/kaui/multi_functions_bar_utils.js

@@ -0,0 +1,132 @@
+// Function to map operators to user-friendly text
+function searchFormatOperator(operator) {
+  var operatorMapping = {
+    'eq': 'Equals',
+    'neq': 'Not Equals',
+    'gt': 'Greater Than',
+    'gte': 'Greater Than Or Equal',
+    'lt': 'Less Than',
+    'lte': 'Less Than Or Equal',
+    'like': 'Like'
+  };
+  return operatorMapping[operator] || operator;
+}
+
+// Function to parse URL parameters
+function getUrlParams() {
+  var params = {};
+  var queryString = window.location.search.substring(1);
+  queryString = queryString.replace(/ac_id/g, 'account_id');
+  var regex = /([^&=]+)=([^&]*)/g;
+  var m;
+  while (m = regex.exec(queryString)) {
+    params[decodeURIComponent(m[1])] = decodeURIComponent(m[2]);
+  }
+  return params;
+}
+
+// Function to populate search labels from URL parameters
+function populateSearchLabelsFromUrl() {
+  var params = getUrlParams();
+  var searchLabelsContainer = $('#search-labels-container');
+  searchLabelsContainer.empty();
+
+  var hasBalanceFilter = window.location.search.includes('balance');
+
+  for (var key in params) {
+    if (params.hasOwnProperty(key)) {
+      var value = params[key];
+      value = value.replace(/%/g, '');
+      var match = key.match(/(.*)\[(.*)\]/);
+      if (match) {
+        var columnName = match[1].replace(/_/g, ' ').replace(/^\w/, function(l) { return l.toUpperCase(); });
+        var filter = searchFormatOperator(match[2]);
+        var label = $('<span>', {
+          class: 'label label-info',
+          text: columnName + ' [' + filter + '] ' + value
+        });
+
+        if (hasBalanceFilter && columnName.toLowerCase() !== 'balance') {
+          label.attr('class', 'label label-default');
+        }
+
+        searchLabelsContainer.append(label);
+      }
+    }
+  }
+}
+
+function searchQuery(account_id){
+  var searchFields = $('.search-field');
+  var searchLabelsContainer = $('#search-labels-container');
+  searchLabelsContainer.empty();
+
+  var searchLabels = searchFields.map(function() {
+    var filter = $(this).find('.search-field-filter').val();
+    var value = $(this).find('.search-field-value').val();
+    var columnName = $(this).find('.search-field-filter').attr('name').replace('Filter', '').toLowerCase().replace(/\s+/g, '_');
+
+    if (value !== '') {
+      if (filter === 'like') {
+        return columnName + encodeURIComponent('[' + filter + ']') + '=' + encodeURIComponent('%' + value + '%');
+      } else {
+        return columnName + encodeURIComponent('[' + filter + ']') + '=' + encodeURIComponent(value);
+      }
+    }
+  }).get().join('&');
+
+  if (account_id !== undefined && account_id !== '') {
+    searchLabels += '&' + encodeURIComponent('account_id[eq]') + '=' + encodeURIComponent(account_id);
+  }
+
+  var searchLabelString = searchLabels.length > 0 ? ('_q=1&' + searchLabels) : '';
+  if (searchLabelString == '') {
+    clearAdvanceSearch();
+  }
+  return searchLabelString;
+};
+
+function clearAdvanceSearch() {
+  // Clear all search fields
+  $('#search-fields-container').empty();
+
+  // Remove all search labels
+  $('#search-labels-container').empty();
+
+  // Reload the page with the original URL (no parameters)
+  window.location.href = window.location.pathname;
+
+  // Hide the modal
+  $('#advanceSearchModal').modal('hide');
+}
+
+function showAdvanceSearchModal() {
+  var searchLabelsContainer = $('#search-labels-container');
+  var searchFieldsContainer = $('#search-fields-container');
+  searchFieldsContainer.empty();
+
+  // Populate the search fields with the current filters
+  searchLabelsContainer.find('.label').each(function() {
+    var labelText = $(this).text();
+    var parts = labelText.split(' [');
+    var columnName = parts[0].trim();
+    var filterAndValue = parts[1].split('] ');
+    var filter = filterAndValue[0].trim();
+    var value = filterAndValue[1].trim();
+
+    var template = document.getElementById('search-field-template').content.cloneNode(true);
+    template.querySelector('.search-field-label').textContent = columnName.replace(/([A-Z])/g, ' $1').trim();
+    template.querySelector('.search-field-filter').name = columnName + 'Filter';
+    template.querySelector('.search-field-filter').value = filter;
+    template.querySelector('.search-field-value').name = columnName;
+    template.querySelector('.search-field-value').value = value;
+
+    searchFieldsContainer.append(template);
+    var dropdown = searchFieldsContainer.find('.search-field:last-child .search-field-filter');
+    dropdown.find('option').each(function() {
+      if ($(this).text().trim().toLowerCase() === filter.toLowerCase()) {
+        $(this).prop('selected', true);
+      }
+    });
+  });
+}

data/app/controllers/kaui/account_timelines_controller.rb

@@ -146,7 +146,7 @@ module Kaui
       rescue StandardError
         nil
       end
-      target_date >= start_date && target_date <= end_date
+      target_date.between?(start_date, end_date)
     end
 
     def load_bundle_name_for_timeline(bundle_key)

data/app/controllers/kaui/accounts_controller.rb

@@ -5,7 +5,7 @@ module Kaui
   class AccountsController < Kaui::EngineController
     def index
       @search_query = params[:q]
-
+      @advance_search_query = request.query_string
       if params[:fast] == '1' && !@search_query.blank?
         account = Kaui::Account.list_or_search(@search_query, -1, 1, options_for_klient).first
         if account.nil?
@@ -16,7 +16,7 @@ module Kaui
         end
         return
       end
-
+      @search_fields = Kaui::Account::ADVANCED_SEARCH_COLUMNS.map { |attr| [attr, attr.split('_').join(' ').capitalize] }
       @dropdown_default = default_columns(Kaui.account_search_columns.call[2], Kaui::Account::SENSIVITE_DATA_FIELDS)
 
       @ordering = params[:ordering] || (@search_query.blank? ? 'desc' : 'asc')
@@ -29,6 +29,7 @@ module Kaui
     def pagination
       cached_options_for_klient = options_for_klient
       searcher = lambda do |search_key, offset, limit|
+        search_key = remapping_addvanced_search_fields(search_key, Kaui::Account::ADVANCED_SEARCH_NAME_CHANGES)
         Kaui::Account.list_or_search(search_key, offset, limit, cached_options_for_klient)
       end
 
@@ -52,11 +53,18 @@ module Kaui
       start_date = params[:startDate]
       end_date = params[:endDate]
       all_fields_checked = params[:allFieldsChecked] == 'true'
+      query_string = params[:search]
 
       if all_fields_checked
         columns = KillBillClient::Model::AccountAttributes.instance_variable_get('@json_attributes')
+        csv_headers = columns.dup
+        Kaui::Account::REMAPPING_FIELDS.each do |k, v|
+          index = csv_headers.index(k)
+          csv_headers[index] = v if index
+        end
       else
         columns = params.require(:columnsString).split(',').map { |attr| attr.split.join('_').downcase }
+        csv_headers = columns.dup
         Kaui::Account::REMAPPING_FIELDS.each do |k, v|
           index = columns.index(v)
           columns[index] = k if index
@@ -73,10 +81,11 @@ module Kaui
       rescue StandardError
         nil
       end
-      accounts = Kaui::Account.list_or_search(nil, 0, MAXIMUM_NUMBER_OF_RECORDS_DOWNLOAD, options_for_klient)
+      query_string = remapping_addvanced_search_fields(query_string, Kaui::Account::ADVANCED_SEARCH_NAME_CHANGES)
+      accounts = Kaui::Account.list_or_search(query_string, 0, MAXIMUM_NUMBER_OF_RECORDS_DOWNLOAD, options_for_klient)
 
       csv_string = CSV.generate(headers: true) do |csv|
-        csv << columns
+        csv << csv_headers
         accounts.each do |account|
           change_date = Date.parse(account.reference_time)
           data = columns.map do |attr|
@@ -135,12 +144,10 @@ module Kaui
       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 { 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
+      is_email_notifications_plugin_available = Dependencies::Kenui::EmailNotification.email_notification_plugin_available?(cached_options_for_klient).first
       fetch_email_notification_configuration = if is_email_notifications_plugin_available
                                                  promise do
-                                                   Kenui::EmailNotificationService.get_configuration_per_account(params.require(:account_id), cached_options_for_klient)
+                                                   Dependencies::Kenui::EmailNotification.get_configuration_per_account(params.require(:account_id), cached_options_for_klient)
                                                  end.then do |configuration|
                                                    if configuration.first.is_a?(FalseClass)
                                                      Rails.logger.warn(configuration[1])
@@ -175,7 +182,7 @@ module Kaui
       @available_tags = wait(fetch_available_tags)
       @children = wait(fetch_children)
       @account_parent = @account.parent_account_id.nil? ? nil : wait(fetch_parent)
-      @email_notification_configuration = wait(fetch_email_notification_configuration) if is_email_notifications_plugin_available
+      @email_notification_configuration = is_email_notifications_plugin_available ? wait(fetch_email_notification_configuration) : []
 
       @last_transaction_by_payment_method_id = {}
       wait(fetch_payments).each do |payment|
@@ -345,15 +352,15 @@ module Kaui
       event_types = configuration[:event_types]
       cached_options_for_klient = options_for_klient
 
-      is_success, message = email_notification_plugin_available?(cached_options_for_klient)
+      is_success, message = Dependencies::Kenui::EmailNotification.email_notification_plugin_available?(cached_options_for_klient)
 
       if is_success
-        is_success, message = Kenui::EmailNotificationService.set_configuration_per_account(account_id,
-                                                                                            event_types,
-                                                                                            current_user.kb_username,
-                                                                                            params[:reason],
-                                                                                            params[:comment],
-                                                                                            cached_options_for_klient)
+        is_success, message = Dependencies::Kenui::EmailNotification.set_configuration_per_account(account_id,
+                                                                                                   event_types,
+                                                                                                   current_user.kb_username,
+                                                                                                   params[:reason],
+                                                                                                   params[:comment],
+                                                                                                   cached_options_for_klient)
       end
       if is_success
         flash[:notice] = message
@@ -365,7 +372,7 @@ module Kaui
 
     def events_to_consider
       json_response do
-        { data: Kenui::EmailNotificationService.get_events_to_consider(options_for_klient) }
+        { data: Dependencies::Kenui::EmailNotification.get_events_to_consider(options_for_klient) }
       end
     end
 
@@ -373,16 +380,5 @@ module Kaui
       data = KillBillClient::Model::Export.find_by_account_id(params[:account_id], current_user.kb_username, options_for_klient)
       send_data data, filename: "account#{params[:account_id]}.txt", type: :txt
     end
-
-    private
-
-    def email_notification_plugin_available?(options_for_klient)
-      error_message = 'Email notification plugin is not installed'
-
-      is_available = Kenui::EmailNotificationService.email_notification_plugin_available?(options_for_klient).first
-      [is_available, is_available ? nil : error_message]
-    rescue StandardError
-      [false, error_message]
-    end
   end
 end

data/app/controllers/kaui/admin_tenants_controller.rb

@@ -142,7 +142,7 @@ module Kaui
       else
         errors = ''
         catalog_validation_errors.each do |validation_error|
-          errors += (validation_error['errorDescription'])
+          errors += validation_error['errorDescription']
         end
         flash[:error] = errors
         redirect_to admin_tenant_new_catalog_path(id: current_tenant.id)

data/app/controllers/kaui/engine_controller_util.rb

@@ -14,8 +14,34 @@ module Kaui
     end
     # rubocop:enable Lint/UselessAssignment, Naming/AccessorMethodName
 
+    # Remove this when we support balance search alongside the other search
+    def handle_balance_search(query_string)
+      return nil if query_string.blank?
+      return query_string unless query_string.include?('balance')
+
+      CGI.unescape(query_string)
+         .split('&')
+         .grep(/_q|balance/)
+         .map { |param| param.split('=') }
+         .map { |key, value| "#{CGI.escape(key)}=#{value}" }
+         .join('&')
+    end
+
+    def remapping_addvanced_search_fields(search_string, advanced_search_name_changes)
+      return search_string if search_string.blank? || !(search_string.include? '_q')
+
+      advanced_search_name_changes.each do |new_name, old_name|
+        search_string = search_string.gsub(new_name, old_name)
+      end
+      search_string
+    end
+
     def paginate(searcher, data_extractor, formatter, table_default_columns = [])
       search_key = (params[:search] || {})[:value].presence
+      advance_search_query = params[:advance_search_query].presence
+
+      search_key = advance_search_query if advance_search_query
+      search_key = handle_balance_search(search_key) if search_key.present?
       offset = (params[:start] || 0).to_i
       limit = (params[:length] || 10).to_i
 
@@ -41,6 +67,7 @@ module Kaui
       # Until we support server-side sorting
       ordering = (params[:order] || {})[:'0'] || {}
       ordering_column = (ordering[:column] || 0).to_i
+      ordering_column = params[:colum_order][ordering_column].to_i if params[:colum_order].present?
       ordering_dir = ordering[:dir] || 'asc'
       unless search_key.nil?
         pages.sort! do |a, b|

data/app/controllers/kaui/invoices_controller.rb

@@ -5,10 +5,11 @@ module Kaui
   class InvoicesController < Kaui::EngineController
     def index
       @search_query = params[:account_id]
-
+      @advance_search_query = request.query_string
       @ordering = params[:ordering] || (@search_query.blank? ? 'desc' : 'asc')
       @offset = params[:offset] || 0
       @limit = params[:limit] || 50
+      @search_fields = Kaui::Invoice::ADVANCED_SEARCH_COLUMNS.map { |attr| [attr, attr.split('_').join(' ').capitalize] }
 
       @max_nb_records = @search_query.blank? ? Kaui::Invoice.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
     end
@@ -18,6 +19,7 @@ module Kaui
       start_date = params[:startDate]
       end_date = params[:endDate]
       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
                 else
@@ -27,12 +29,12 @@ module Kaui
       kb_params = {}
       kb_params[:startDate] = Date.parse(start_date).strftime('%Y-%m-%d') if start_date
       kb_params[:endDate] = Date.parse(end_date).strftime('%Y-%m-%d') if end_date
-      if account_id.present?
-        account = Kaui::Account.find_by_id_or_key(account_id, false, false, options_for_klient)
-        invoices = account.invoices(options_for_klient.merge(params: kb_params))
-      else
-        invoices = Kaui::Invoice.list_or_search(nil, 0, MAXIMUM_NUMBER_OF_RECORDS_DOWNLOAD, options_for_klient.merge(params: kb_params))
-      end
+      query_string = remapping_addvanced_search_fields(query_string, Kaui::Invoice::ADVANCED_SEARCH_NAME_CHANGES)
+      invoices = if account_id.present? && query_string.blank?
+                   Kaui::Account.paginated_invoices(account_id, nil, nil, 'NONE', options_for_klient).map! { |invoice| Kaui::Invoice.build_from_raw_invoice(invoice) }
+                 else
+                   Kaui::Invoice.list_or_search(query_string, 0, MAXIMUM_NUMBER_OF_RECORDS_DOWNLOAD, options_for_klient.merge(params: kb_params))
+                 end
 
       csv_string = CSV.generate(headers: true) do |csv|
         csv << columns
@@ -54,6 +56,7 @@ module Kaui
           nil
         end
         if account.nil?
+          search_key = remapping_addvanced_search_fields(search_key, Kaui::Invoice::ADVANCED_SEARCH_NAME_CHANGES)
           Kaui::Invoice.list_or_search(search_key, offset, limit, cached_options_for_klient)
         else
           Kaui::Account.paginated_invoices(search_key, offset, limit, 'NONE', cached_options_for_klient).map! { |invoice| Kaui::Invoice.build_from_raw_invoice(invoice) }
@@ -70,13 +73,7 @@ module Kaui
                          end
                        else
                          lambda do |invoice, column|
-                           [
-                             invoice.invoice_number.to_i,
-                             invoice.invoice_date,
-                             invoice.amount,
-                             invoice.balance,
-                             invoice.status
-                           ][column]
+                           Kaui.account_invoices_columns.call(invoice, view_context)[2][column]
                          end
                        end
 

data/app/controllers/kaui/payments_controller.rb

@@ -6,10 +6,11 @@ module Kaui
   class PaymentsController < Kaui::EngineController
     def index
       @search_query = params[:q] || params[:account_id]
-
+      @advance_search_query = request.query_string
       @ordering = params[:ordering] || (@search_query.blank? ? 'desc' : 'asc')
       @offset = params[:offset] || 0
       @limit = params[:limit] || 50
+      @search_fields = Kaui::Payment::ADVANCED_SEARCH_COLUMNS.map { |attr| [attr, attr.split('_').join(' ').capitalize] }
 
       @max_nb_records = @search_query.blank? ? Kaui::Payment.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
     end
@@ -19,25 +20,34 @@ module Kaui
       start_date = params[:startDate]
       end_date = params[:endDate]
       all_fields_checked = params[:allFieldsChecked] == 'true'
+      query_string = params[:search]
+
       if all_fields_checked
         columns = KillBillClient::Model::PaymentAttributes.instance_variable_get('@json_attributes') - %w[transactions audit_logs]
+        csv_headers = columns.dup
+        Kaui::Payment::REMAPPING_FIELDS.each do |k, v|
+          index = csv_headers.index(k)
+          csv_headers[index] = v if index
+        end
       else
         columns = params.require(:columnsString).split(',').map { |attr| attr.split.join('_').downcase }
+        csv_headers = columns.dup
         Kaui::Payment::REMAPPING_FIELDS.each do |k, v|
           index = columns.index(v)
           columns[index] = k if index
         end
       end
-
+      query_string = remapping_addvanced_search_fields(query_string, Kaui::Payment::ADVANCED_SEARCH_NAME_CHANGES)
       kb_params = {}
       kb_params[:startDate] = Date.parse(start_date).strftime('%Y-%m-%d') if start_date
       kb_params[:endDate] = Date.parse(end_date).strftime('%Y-%m-%d') if end_date
-      if account_id.present?
-        account = Kaui::Account.find_by_id_or_key(account_id, false, false, options_for_klient)
-        payments = account.payments(options_for_klient).map! { |payment| Kaui::Payment.build_from_raw_payment(payment) }
-      else
-        payments = Kaui::Payment.list_or_search(nil, 0, MAXIMUM_NUMBER_OF_RECORDS_DOWNLOAD, options_for_klient.merge(params: kb_params))
-      end
+      account = account_id.present? ? Kaui::Account.find_by_id_or_key(account_id, false, false, options_for_klient) : nil
+
+      payments = if account_id.present? && query_string.blank?
+                   Kaui::Account.paginated_payments(account_id, nil, nil, 'NONE', options_for_klient).map! { |payment| Kaui::Payment.build_from_raw_invoice(payment) }
+                 else
+                   Kaui::Payment.list_or_search(query_string, 0, MAXIMUM_NUMBER_OF_RECORDS_DOWNLOAD, options_for_klient.merge(params: kb_params))
+                 end
 
       payments.each do |payment|
         created_date = nil
@@ -99,6 +109,7 @@ module Kaui
           end
 
           payments = if account.nil?
+                       search_key = remapping_addvanced_search_fields(search_key, Kaui::Payment::ADVANCED_SEARCH_NAME_CHANGES)
                        Kaui::Payment.list_or_search(search_key, offset, limit, options_for_klient)
                      else
                        account.payments(options_for_klient).map! { |payment| Kaui::Payment.build_from_raw_payment(payment) }
@@ -118,15 +129,7 @@ module Kaui
       end
 
       data_extractor = lambda do |payment, column|
-        [
-          payment.payment_number.to_i,
-          payment.payment_date,
-          payment.total_authed_amount_to_money,
-          payment.paid_amount_to_money,
-          payment.returned_amount_to_money,
-          payment.transactions.empty? ? nil : payment.transactions[-1].status,
-          payment.payment_external_key
-        ][column]
+        Kaui.account_payments_columns.call(account, payment, view_context)[2][column]
       end
 
       formatter = lambda do |payment|

data/app/controllers/kaui/sessions_controller.rb

@@ -12,6 +12,8 @@ module Kaui
     # The sign-in flow eventually calls authenticate! from config/initializers/killbill_authenticatable.rb
 
     rescue_from(StandardError) do |exception|
+      Rails.logger.error(exception.message)
+      Rails.logger.error(exception.backtrace.join("\n")) if exception.backtrace
       @error = standardize_exception(exception)
       render 'kaui/errors/500', status: 500, layout: false
     end

data/app/helpers/kaui/exception_helper.rb

@@ -5,8 +5,10 @@ module Kaui
     def standardize_exception(exception)
       if defined?(JRUBY_VERSION)
         case exception
-        when ActiveRecord::JDBCError
+        when ActiveRecord::JDBCError, ActiveRecord::NoDatabaseError, ActiveRecord::DatabaseConnectionError, ActiveRecord::ConnectionNotEstablished
           return I18n.translate('errors.messages.unable_to_connect_database')
+        else
+          return exception.message
         end
       end
 

data/app/models/kaui/account.rb

@@ -7,12 +7,15 @@ module Kaui
     SENSIVITE_DATA_FIELDS = %w[name email].freeze
     REMAPPING_FIELDS = {
       'is_payment_delegated_to_parent' => 'pay_via_parent',
-      'bill_cycle_day_local' => 'bcd',
       'account_balance' => 'balance',
+      'bill_cycle_day_local' => 'bcd',
       'account_cba' => 'cba',
       'is_migrated' => 'migrated'
     }.freeze
 
+    ADVANCED_SEARCH_COLUMNS = %w[id external_key email name currency parent_account_id pay_via_parent payment_method_id time_zone country postal_code].freeze
+    ADVANCED_SEARCH_NAME_CHANGES = [%w[pay_via_parent is_payment_delegated_to_parent]].freeze
+
     def check_account_details_phone
       return true if phone =~ /\A(?:\+?\d{1,3}\s*-?)?\(?(?:\d{3})?\)?[- ]?\d{3}[- ]?\d{4}\z/i
 

data/app/models/kaui/invoice.rb

@@ -3,6 +3,8 @@
 module Kaui
   class Invoice < KillBillClient::Model::Invoice
     TABLE_IGNORE_COLUMNS = %w[amount balance credit_adj refund_adj items is_parent_invoice parent_invoice_id parent_account_id audit_logs bundle_keys].freeze
+    ADVANCED_SEARCH_COLUMNS = %w[id account_id invoice_date target_date currency status balance].freeze
+    ADVANCED_SEARCH_NAME_CHANGES = [%w[ac_id account_id]].freeze
 
     def self.build_from_raw_invoice(raw_invoice)
       result = Kaui::Invoice.new

data/app/models/kaui/payment.rb

@@ -14,6 +14,8 @@ module Kaui
       'credited_amount' => 'credit',
       'refunded_amount' => 'refund'
     }.freeze
+    ADVANCED_SEARCH_COLUMNS = %w[id account_id payment_method_id external_key].freeze
+    ADVANCED_SEARCH_NAME_CHANGES = [%w[ac_id account_id]].freeze
 
     def self.build_from_raw_payment(raw_payment)
       result = Kaui::Payment.new

data/app/services/dependencies/kenui.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Dependencies
+  module Kenui
+    class EmailNotification
+      ERROR_MESSAGE = I18n.translate('errors.messages.email_notification_plugin_not_available')
+      class << self
+        def email_notification_plugin_available?(options_for_klient)
+          is_available = ::Kenui::EmailNotificationService.email_notification_plugin_available?(options_for_klient)
+          [is_available, is_available ? nil : ERROR_MESSAGE]
+        rescue StandardError
+          [false, ERROR_MESSAGE]
+        end
+
+        def set_configuration_per_account(account_id, event_types, kb_username, reason, comment, options_for_klient)
+          ::Kenui::EmailNotificationService.set_configuration_per_account(account_id,
+                                                                          event_types,
+                                                                          kb_username,
+                                                                          reason,
+                                                                          comment,
+                                                                          options_for_klient)
+        rescue StandardError
+          [false, ERROR_MESSAGE]
+        end
+
+        def get_events_to_consider(options_for_klient)
+          ::Kenui::EmailNotificationService.get_events_to_consider(options_for_klient)
+        rescue StandardError
+          {}
+        end
+
+        def get_configuration_per_account(account_id, options_for_klient)
+          ::Kenui::EmailNotificationService.get_configuration_per_account(account_id, options_for_klient)
+        rescue StandardError
+          []
+        end
+      end
+    end
+  end
+end