kaui 3.0.3 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdb45a75d2f3a57307ffe426a864911262563d623f25cccefd3941de52655e36
-  data.tar.gz: f45cbd12e90f63dfb544743381af6c4a2dbeab58fe0671334f02198bdeb97323
+  metadata.gz: 381a1791f9fc6c1d64886d34dca17905a83ec38322043735a2437d83d8516d35
+  data.tar.gz: ee79517525bb910a58c1996621171c0600c113e98215e016f283f5d3ee9d2c0e
 SHA512:
-  metadata.gz: 065274ae77055af9c3a54b7938f8c8f0d09775b5d7a7b4e953c990790ad7e4af247096b287f308062e53f09b13d16eda146ccd893c762baa3dc7ab644f8a3c01
-  data.tar.gz: 15cd32d52a680d624be8bf85f3db439f1afc78ad5d7308054fecf7aad66d130f8a5bd324ec93ba7fd140399be84f4eec6015e1c9a054f55f368f8c4202ecebfb
+  metadata.gz: bce25f97853968fb171263eb1513ca6588d4884e0045232880bc24bc10cd55057b36e72cd89a7ef86996c4c9ec045a0b37aa7f39a35c2c9dfe0137866e1d7255
+  data.tar.gz: 371aa14f4390357331e257e9735a1c4f2ac940069b041f7bf595f68c960fec3c3ca32af274ba39b3abf4047a5e8d789590bbb6b90b079a11236bd7ee1b89de1a

data/app/controllers/kaui/account_timelines_controller.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'csv'
+
 module Kaui
   class AccountTimelinesController < Kaui::EngineController
     def show
@@ -30,8 +32,127 @@ module Kaui
       @selected_bundle = params.key?(:external_key) ? @bundle_names[params[:external_key]] : nil
     end
 
+    def download
+      timeline = Kaui::AccountTimeline.find_by_account_id(params.require(:account_id), 'FULL', options_for_klient)
+      start_date = params[:startDate]
+      end_date = params[:endDate]
+      start_date = begin
+        Date.parse(start_date)
+      rescue StandardError
+        nil
+      end
+      end_date = begin
+        Date.parse(end_date)
+      rescue StandardError
+        nil
+      end
+      start_date = params[:startDate].present? ? Date.parse(params[:startDate]) : nil
+      end_date = params[:endDate].present? ? Date.parse(params[:endDate]) : nil
+
+      event_type = params[:eventType]
+      @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
+        end
+      end
+
+      @selected_bundle = params.key?(:external_key) ? @bundle_names[params[:external_key]] : nil
+
+      csv_string = CSV.generate(headers: true) do |csv|
+        csv << ['Effective Date', 'Bundles', 'Even Type', 'Details', 'Reason Code/ Comments']
+        if %w[INVOICE ALL].include?(event_type)
+          @invoices.each do |invoice_stub|
+            invoice = invoice_stub.invoice_id.present? && @invoices_by_id.key?(invoice_stub.invoice_id) ? @invoices_by_id[invoice_stub.invoice_id] : invoice_stub
+            target_date = invoice.target_date.present? ? invoice.target_date : '[unknown]'
+            bundle_keys = invoice_stub.bundle_keys.present? ? invoice_stub.bundle_keys.split(',').map { |bundle_key| @bundle_names[bundle_key] }.join(', ') : ''
+            invoice_details = []
+            invoice_details << "Amount: #{invoice.amount_to_money} (#{@account.currency})"
+            invoice_details << "Balance: #{invoice.balance_to_money} (#{@account.currency})"
+            invoice_details << "Credit adjustment: #{invoice.credit_adjustment_to_money} (#{@account.currency})" if invoice.credit_adj.present? && invoice.credit_adj.positive?
+            invoice_details << "Refund adjustment: #{invoice.refund_adjustment_to_money} (#{@account.currency})" if invoice.refund_adj.present? && invoice.refund_adj.negative?
+            invoice_details << "Invoice #: #{invoice.invoice_number}"
+            audit_logs = invoice_stub.audit_logs.present? ? invoice_stub.audit_logs.map { |entry| Kaui::AuditLog.description(entry) }.join(', ') : ''
+            csv << [target_date, bundle_keys, 'INVOICE', invoice_details.join('; '), audit_logs] if filter_date(target_date, start_date, end_date)
+          end
+        end
+        if %w[PAYMENT ALL].include?(event_type)
+          @payments.each do |payment|
+            invoice = if payment.target_invoice_id.present?
+                        @invoices_by_id[payment.target_invoice_id]
+                      else
+                        nil
+                      end
+
+            payment.transactions.each do |transaction|
+              effective_date = transaction.effective_date.present? ? transaction.effective_date : '[unknown]'
+              bundle_keys = @bundle_keys_by_invoice_id[payment.target_invoice_id].present? ? @bundle_keys_by_invoice_id[payment.target_invoice_id].map { |bundle_key| @bundle_names[bundle_key] }.join(', ') : ''
+              transaction_type = transaction.transaction_type
+              details = []
+              details << "Amount: #{Kaui::Transaction.amount_to_money(transaction)} (#{transaction.currency})" unless transaction.transaction_type == 'VOID'
+              details << "Status: #{transaction.status}"
+              details << "Payment #: #{payment.payment_number}"
+              details << "Invoice #: #{invoice.invoice_number}" unless invoice.nil?
+
+              audit_logs = transaction.audit_logs.present? ? transaction.audit_logs.map { |entry| Kaui::AuditLog.description(entry) }.chunk { |x| x }.map(&:first).join(', ') : ''
+
+              csv << [effective_date, bundle_keys, transaction_type, details.join('; '), audit_logs] if filter_date(effective_date, start_date, end_date)
+            end
+          end
+        end
+
+        if %w[ENTITLEMENT ALL].include?(event_type)
+          @bundles.each do |bundle|
+            bundle.subscriptions.each do |sub|
+              sub.events.each do |event|
+                # Skip SERVICE_STATE_CHANGE events
+                next if event.event_type == 'SERVICE_STATE_CHANGE'
+
+                effective_date = event.effective_date.present? ? event.effective_date : '[unknown]'
+                bundle_keys = @bundle_names[bundle.external_key]
+                event_type = event.event_type
+                phase = event.phase
+                audit_logs = event.audit_logs.present? ? event.audit_logs.map { |entry| Kaui::AuditLog.description(entry) }.join(', ') : ''
+
+                csv << [effective_date, bundle_keys, event_type, phase, audit_logs] if filter_date(effective_date, start_date, end_date)
+              end
+            end
+          end
+        end
+      end
+
+      send_data csv_string, filename: "account-timelines-#{Date.today}.csv", type: 'text/csv'
+    end
+
     private
 
+    def filter_date(target_date, start_date, end_date)
+      return true if start_date.nil? || end_date.nil?
+
+      target_date = begin
+        Date.parse(target_date)
+      rescue StandardError
+        nil
+      end
+      target_date >= start_date && target_date <= end_date
+    end
+
     def load_bundle_name_for_timeline(bundle_key)
       @bundle_names[bundle_key] ||= Kaui.bundle_key_display_string.call(bundle_key)
     end

data/app/controllers/kaui/accounts_controller.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'csv'
 module Kaui
   class AccountsController < Kaui::EngineController
     def index
@@ -16,6 +17,8 @@ module Kaui
         return
       end
 
+      @dropdown_default = default_columns(Kaui.account_search_columns.call[2], Kaui::Account::SENSIVITE_DATA_FIELDS)
+
       @ordering = params[:ordering] || (@search_query.blank? ? 'desc' : 'asc')
       @offset = params[:offset] || 0
       @limit = params[:limit] || 50
@@ -39,17 +42,47 @@ module Kaui
       end
 
       formatter = lambda do |account|
-        child_label = ''
-        unless account.parent_account_id.nil?
-          child_label = account.parent_account_id.nil? ? '' : view_context.content_tag(:span, 'Child', class: %w[label label-info account-child-label])
-        end
+        Kaui.account_search_columns.call(account, view_context)[1]
+      end
 
-        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
+      paginate searcher, data_extractor, formatter, default_columns(Kaui.account_search_columns.call[2], Kaui::Account::SENSIVITE_DATA_FIELDS)
+    end
+
+    def download
+      start_date = params[:startDate]
+      end_date = params[:endDate]
+      all_fields_checked = params[:allFieldsChecked] == 'true'
+
+      columns = if all_fields_checked
+                  KillBillClient::Model::AccountAttributes.instance_variable_get('@json_attributes')
+                else
+                  params.require(:columnsString).split(',').map { |attr| attr.split.join('_').downcase }
+                end
+      start_date = begin
+        Date.parse(start_date)
+      rescue StandardError
+        nil
+      end
+      end_date = begin
+        Date.parse(end_date)
+      rescue StandardError
+        nil
       end
+      accounts = Kaui::Account.list_or_search(nil, 0, MAXIMUM_NUMBER_OF_RECORDS_DOWNLOAD, options_for_klient)
+
+      csv_string = CSV.generate(headers: true) do |csv|
+        csv << columns
+        accounts.each do |account|
+          change_date = Date.parse(account.reference_time)
+          data = columns.map do |attr|
+            account&.send(attr.downcase)
+          end
+          next if start_date && end_date && change_date && (change_date < start_date || change_date > end_date)
 
-      paginate searcher, data_extractor, formatter
+          csv << data
+        end
+      end
+      send_data csv_string, filename: "accounts-#{Date.today}.csv", type: 'text/csv'
     end
 
     def new
@@ -331,6 +364,11 @@ module Kaui
       end
     end
 
+    def export_account
+      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)

data/app/controllers/kaui/audit_logs_controller.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'csv'
+
 module Kaui
   class AuditLogsController < Kaui::EngineController
     OBJECT_WITH_HISTORY = %w[ACCOUNT ACCOUNT_EMAIL BLOCKING_STATES BUNDLE CUSTOM_FIELD INVOICE INVOICE_ITEM PAYMENT_ATTEMPT PAYMENT PAYMENT_METHOD SUBSCRIPTION SUBSCRIPTION_EVENT TRANSACTION TAG TAG_DEFINITION].freeze
@@ -42,6 +44,41 @@ module Kaui
       @audit_logs_json = @audit_logs_json.to_json
     end
 
+    def download
+      account_id = params.require(:account_id)
+      start_date = params[:startDate]
+      end_date = params[:endDate]
+      start_date = begin
+        Date.parse(start_date)
+      rescue StandardError
+        nil
+      end
+      end_date = begin
+        Date.parse(end_date)
+      rescue StandardError
+        nil
+      end
+
+      account = Kaui::Account.find_by_id_or_key(account_id, false, false, options_for_klient)
+      audit_logs = account.audit(options_for_klient)
+
+      csv_file = CSV.generate do |csv|
+        csv << Kaui.account_audit_logs_columns.call[0]
+        audit_logs.each do |log|
+          change_date = begin
+            Date.parse(log.change_date)
+          rescue StandardError
+            nil
+          end
+          next if start_date && end_date && change_date && !(change_date > start_date && change_date < end_date)
+
+          csv << [log.change_date, log.object_id, log.object_type, log.change_type, log.changed_by, log.reason_code, log.comments, log.user_token]
+        end
+      end
+
+      send_data csv_file, type: 'text/csv', filename: "audit_logs_#{account_id}.csv"
+    end
+
     def history
       json_response do
         account_id = params.require(:account_id)

data/app/controllers/kaui/bundles_controller.rb

@@ -5,8 +5,10 @@ module Kaui
     # rubocop:disable Lint/HashCompareByIdentity
     def index
       cached_options_for_klient = options_for_klient
+      @per_page = (params[:per_page] || 10).to_i
+      @page = (params[:page] || 1).to_i
 
-      fetch_bundles = promise { @account.bundles(cached_options_for_klient) }
+      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|
@@ -35,6 +37,8 @@ module Kaui
       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
+
       @tags_per_bundle = wait(fetch_bundle_tags)
       @tags_per_subscription = wait(fetch_subscription_tags)
       @custom_fields_per_bundle = wait(fetch_bundle_fields)

data/app/controllers/kaui/engine_controller.rb

@@ -1,6 +1,9 @@
+require_relative '../../../lib/kaui/error_handler'
+
 class Kaui::EngineController < ApplicationController
 
   include Kaui::EngineControllerUtil
+  include Kaui::ErrorHandler
 
   before_action :authenticate_user!, :check_for_redirect_to_tenant_screen, :populate_account_details
 
@@ -59,25 +62,6 @@ class Kaui::EngineController < ApplicationController
     end
   end
 
-  # Note! Order matters, StandardError needs to be first
-  rescue_from(StandardError) do |error|
-    flash[:error] = "Error: #{as_string(error)}"
-    try_to_redirect_to_account_path = !params[:controller].ends_with?('accounts')
-    perform_redirect_after_error try_to_redirect_to_account_path
-  end
-
-  rescue_from(ActionController::ParameterMissing) do |parameter_missing_exception|
-    log_rescue_error parameter_missing_exception
-    flash[:error] = "Required parameter missing: #{parameter_missing_exception.param}"
-    perform_redirect_after_error
-  end
-
-  rescue_from(KillBillClient::API::ResponseError) do |killbill_exception|
-    flash[:error] = "Error while communicating with the Kill Bill server: #{as_string(killbill_exception)}"
-    try_to_redirect_to_account_path = !killbill_exception.is_a?(KillBillClient::API::Unauthorized) && !(killbill_exception.is_a?(KillBillClient::API::NotFound) && params[:controller].ends_with?('accounts'))
-    perform_redirect_after_error try_to_redirect_to_account_path
-  end
-
   private
 
   def current_tenant_user
@@ -95,13 +79,4 @@ class Kaui::EngineController < ApplicationController
     end
     result
   end
-
-  def perform_redirect_after_error(try_to_redirect_to_account_path = true)
-    account_id = nested_hash_value(params.permit!.to_h, :account_id)
-    if try_to_redirect_to_account_path && account_id.present?
-      redirect_to kaui_engine.account_path(account_id)
-    else
-      redirect_to kaui_engine.home_path
-    end
-  end
 end

data/app/controllers/kaui/engine_controller_util.rb

@@ -4,6 +4,7 @@ module Kaui
   module EngineControllerUtil
     # See DefaultPaginationSqlDaoHelper.java
     SIMPLE_PAGINATION_THRESHOLD = 20_000
+    MAXIMUM_NUMBER_OF_RECORDS_DOWNLOAD = 1000
 
     protected
 
@@ -13,7 +14,7 @@ module Kaui
     end
     # rubocop:enable Lint/UselessAssignment, Naming/AccessorMethodName
 
-    def paginate(searcher, data_extractor, formatter)
+    def paginate(searcher, data_extractor, formatter, table_default_columns = [])
       search_key = (params[:search] || {})[:value].presence
       offset = (params[:start] || 0).to_i
       limit = (params[:length] || 10).to_i
@@ -30,7 +31,8 @@ module Kaui
         # We need to fill-in a number to make DataTables happy
         recordsTotal: pages.nil? ? 0 : (pages.pagination_max_nb_records || SIMPLE_PAGINATION_THRESHOLD),
         recordsFiltered: pages.nil? ? 0 : (pages.pagination_total_nb_records || SIMPLE_PAGINATION_THRESHOLD),
-        data: []
+        data: [],
+        columns: table_default_columns
       }
       json[:error] = error unless error.nil?
 
@@ -151,5 +153,9 @@ module Kaui
       end
       render json: response, status: response_status
     end
+
+    def default_columns(fields, sensivite_fields)
+      fields.map { |field| { data: fields.index(field), visible: !(sensivite_fields.include? field) } }
+    end
   end
 end

data/app/controllers/kaui/invoices_controller.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'csv'
 module Kaui
   class InvoicesController < Kaui::EngineController
     def index
@@ -12,6 +13,37 @@ module Kaui
       @max_nb_records = @search_query.blank? ? Kaui::Invoice.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
     end
 
+    def download
+      account_id = params[:account_id]
+      start_date = params[:startDate]
+      end_date = params[:endDate]
+      all_fields_checked = params[:allFieldsChecked] == 'true'
+      columns = if all_fields_checked
+                  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
+
+      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
+
+      csv_string = CSV.generate(headers: true) do |csv|
+        csv << columns
+
+        invoices.each do |invoice|
+          csv << columns.map { |attr| invoice&.send(attr.downcase) }
+        end
+      end
+      send_data csv_string, filename: "invoices-#{Date.today}.csv", type: 'text/csv'
+    end
+
     def pagination
       cached_options_for_klient = options_for_klient
 
@@ -24,39 +56,32 @@ module Kaui
         if account.nil?
           Kaui::Invoice.list_or_search(search_key, offset, limit, cached_options_for_klient)
         else
-          account.invoices(cached_options_for_klient.merge({ params: { includeVoidedInvoices: true } })).map! { |invoice| Kaui::Invoice.build_from_raw_invoice(invoice) }
+          Kaui::Account.paginated_invoices(search_key, offset, limit, 'NONE', cached_options_for_klient).map! { |invoice| Kaui::Invoice.build_from_raw_invoice(invoice) }
         end
       end
 
       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, cached_options_for_klient)[1]
-          row
-        end
-      else
-        data_extractor = lambda do |invoice, column|
-          [
-            invoice.invoice_number.to_i,
-            invoice.invoice_date,
-            invoice.amount,
-            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
+      data_extractor = if account_id.blank?
+                         lambda do |invoice, column|
+                           [
+                             invoice.invoice_number.to_i,
+                             invoice.invoice_date
+                           ][column]
+                         end
+                       else
+                         lambda do |invoice, column|
+                           [
+                             invoice.invoice_number.to_i,
+                             invoice.invoice_date,
+                             invoice.amount,
+                             invoice.balance,
+                             invoice.status
+                           ][column]
+                         end
+                       end
+
+      formatter = lambda do |invoice|
+        Kaui.account_invoices_columns.call(invoice, view_context)[1]
       end
 
       paginate searcher, data_extractor, formatter

data/app/controllers/kaui/payments_controller.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'csv'
+
 module Kaui
   class PaymentsController < Kaui::EngineController
     def index
@@ -12,7 +14,68 @@ module Kaui
       @max_nb_records = @search_query.blank? ? Kaui::Payment.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
     end
 
+    def download
+      account_id = params[:account_id]
+      start_date = params[:startDate]
+      end_date = params[:endDate]
+      all_fields_checked = params[:allFieldsChecked] == 'true'
+      columns = if all_fields_checked
+                  KillBillClient::Model::PaymentAttributes.instance_variable_get('@json_attributes') - %w[transactions audit_logs]
+                else
+                  params.require(:columnsString).split(',').map { |attr| attr.split.join('_').downcase }
+                end
+
+      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
+
+      payments.each do |payment|
+        created_date = nil
+        payment.transactions.each do |transaction|
+          transaction_date = Date.parse(transaction.effective_date)
+          created_date ||= transaction_date if transaction_date < created_date
+        end
+        payment.payment_date = created_date
+      end
+
+      csv_string = CSV.generate(headers: true) do |csv|
+        csv << columns
+
+        payments.each do |payment|
+          next if start_date && end_date && (payment.payment_date < Date.parse(start_date) || payment.payment_date > Date.parse(end_date))
+
+          data = columns.map do |attr|
+            case attr
+            when 'payment_number'
+              payment.payment_number
+            when 'payment_date'
+              view_context.format_date(payment.payment_date, account&.time_zone)
+            when 'total_authed_amount_to_money'
+              view_context.humanized_money_with_symbol(payment.total_authed_amount_to_money)
+            when 'paid_amount_to_money'
+              view_context.humanized_money_with_symbol(payment.paid_amount_to_money)
+            when 'returned_amount_to_money'
+              view_context.humanized_money_with_symbol(payment.returned_amount_to_money)
+            when 'status'
+              payment.transactions.empty? ? nil : payment.transactions[-1].status
+            else
+              payment&.send(attr.downcase)
+            end
+          end
+          csv << data
+        end
+      end
+      send_data csv_string, filename: "payments-#{Date.today}.csv", type: 'text/csv'
+    end
+
     def pagination
+      account = nil
       searcher = lambda do |search_key, offset, limit|
         if Kaui::Payment::TRANSACTION_STATUSES.include?(search_key)
           # Search is done by payment state on the server side, see http://docs.killbill.io/latest/userguide_payment.html#_payment_states
@@ -30,6 +93,7 @@ module Kaui
           rescue StandardError
             nil
           end
+
           payments = if account.nil?
                        Kaui::Payment.list_or_search(search_key, offset, limit, options_for_klient)
                      else
@@ -62,15 +126,7 @@ module Kaui
       end
 
       formatter = lambda do |payment|
-        [
-          view_context.link_to(payment.payment_number, view_context.url_for(controller: :payments, action: :show, account_id: payment.account_id, id: payment.payment_id)),
-          view_context.format_date(payment.payment_date, @account.time_zone),
-          view_context.humanized_money_with_symbol(payment.total_authed_amount_to_money),
-          view_context.humanized_money_with_symbol(payment.paid_amount_to_money),
-          view_context.humanized_money_with_symbol(payment.returned_amount_to_money),
-          payment.transactions.empty? ? nil : view_context.colored_transaction_status(payment.transactions[-1].status),
-          payment.payment_external_key
-        ]
+        Kaui.account_payments_columns.call(account, payment, view_context)[1]
       end
 
       paginate searcher, data_extractor, formatter

data/app/controllers/kaui/sessions_controller.rb

@@ -3,12 +3,19 @@
 module Kaui
   # Subclassed to specify the correct layout
   class SessionsController < Devise::SessionsController
+    include Kaui::ExceptionHelper
+
     layout Kaui.config[:layout]
 
     skip_before_action :check_for_redirect_to_tenant_screen, raise: false
 
     # The sign-in flow eventually calls authenticate! from config/initializers/killbill_authenticatable.rb
 
+    rescue_from(StandardError) do |exception|
+      @error = standardize_exception(exception)
+      render 'kaui/errors/500', status: 500, layout: false
+    end
+
     protected
 
     # Override after_sign_in_path_for to not have to rely on the default 'root' config which we want to keep on home#index

data/app/helpers/kaui/exception_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Kaui
+  module ExceptionHelper
+    def standardize_exception(exception)
+      if defined?(JRUBY_VERSION)
+        case exception
+        when ActiveRecord::JDBCError
+          return I18n.translate('errors.messages.unable_to_connect_database')
+        end
+      end
+
+      case exception
+      when ActiveRecord::DatabaseConnectionError
+        I18n.translate('errors.messages.unable_to_connect_database')
+      when Errno::ECONNREFUSED, Errno::EBADF
+        I18n.translate('errors.messages.unable_to_connect_killbill')
+      when ->(e) { e.class.name.start_with?('KillBillClient::API') }
+        I18n.translate('errors.messages.error_communicating_killbill')
+      else
+        nil
+      end
+    end
+  end
+end

data/app/helpers/kaui/subscription_helper.rb

@@ -172,5 +172,9 @@ module Kaui
     def subscription_cancelled?(sub)
       sub.present? and sub.billing_end_date.present?
     end
+
+    def paging_button_class(num, current_page)
+      num == current_page ? 'btn btn-primary' : 'btn btn-custom'
+    end
   end
 end

data/app/models/kaui/account.rb

@@ -4,6 +4,8 @@ module Kaui
   class Account < KillBillClient::Model::Account
     attr_accessor :phone, :bill_cycle_day_local
 
+    SENSIVITE_DATA_FIELDS = %w[name email].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

@@ -2,6 +2,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].freeze
+
     def self.build_from_raw_invoice(raw_invoice)
       result = Kaui::Invoice.new
       KillBillClient::Model::InvoiceAttributes.instance_variable_get('@json_attributes').each do |attr|