kaui 2.0.4 → 2.2.1

data/app/controllers/kaui/payments_controller.rb

@@ -1,52 +1,56 @@
-class Kaui::PaymentsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def index
-    @search_query = params[:q] || params[:account_id]
+module Kaui
+  class PaymentsController < Kaui::EngineController
+    def index
+      @search_query = params[:q] || params[:account_id]
 
-    @ordering = params[:ordering] || (@search_query.blank? ? 'desc' : 'asc')
-    @offset = params[:offset] || 0
-    @limit = params[:limit] || 50
+      @ordering = params[:ordering] || (@search_query.blank? ? 'desc' : 'asc')
+      @offset = params[:offset] || 0
+      @limit = params[:limit] || 50
 
-    @max_nb_records = @search_query.blank? ? Kaui::Payment.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
-  end
+      @max_nb_records = @search_query.blank? ? Kaui::Payment.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
+    end
 
-  def pagination
-    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
-        payment_state = if %w(PLUGIN_FAILURE UNKNOWN).include?(search_key)
-                          '_ERRORED'
-                        elsif search_key == 'PAYMENT_FAILURE'
-                          '_FAILED'
-                        else
-                          '_' + search_key
-                        end
-        payments = Kaui::Payment.list_or_search(payment_state, offset, limit, options_for_klient)
-      else
-        account = Kaui::Account::find_by_id_or_key(search_key, false, false, options_for_klient) rescue nil
-        if account.nil?
-          payments = Kaui::Payment.list_or_search(search_key, offset, limit, options_for_klient)
+    def pagination
+      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
+          payment_state = if %w[PLUGIN_FAILURE UNKNOWN].include?(search_key)
+                            '_ERRORED'
+                          elsif search_key == 'PAYMENT_FAILURE'
+                            '_FAILED'
+                          else
+                            "_#{search_key}"
+                          end
+          payments = Kaui::Payment.list_or_search(payment_state, offset, limit, options_for_klient)
         else
-          payments = account.payments(options_for_klient).map! { |payment| Kaui::Payment.build_from_raw_payment(payment) }
+          account = begin
+            Kaui::Account.find_by_id_or_key(search_key, false, false, options_for_klient)
+          rescue StandardError
+            nil
+          end
+          payments = if account.nil?
+                       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) }
+                     end
         end
-      end
 
-      payments.each do |payment|
-        created_date = nil
-        payment.transactions.each do |transaction|
-          transaction_date = Date.parse(transaction.effective_date)
-          if created_date.nil? or transaction_date < created_date
-            created_date = transaction_date
+        payments.each do |payment|
+          created_date = nil
+          payment.transactions.each do |transaction|
+            transaction_date = Date.parse(transaction.effective_date)
+            created_date = transaction_date if created_date.nil? || (transaction_date < created_date)
           end
+          payment.payment_date = created_date
         end
-        payment.payment_date = created_date
-      end
 
-      payments
-    end
+        payments
+      end
 
-    data_extractor = lambda do |payment, column|
-      [
+      data_extractor = lambda do |payment, column|
+        [
           payment.payment_number.to_i,
           payment.payment_date,
           payment.total_authed_amount_to_money,
@@ -54,88 +58,87 @@ class Kaui::PaymentsController < Kaui::EngineController
           payment.returned_amount_to_money,
           payment.transactions.empty? ? nil : payment.transactions[-1].status,
           payment.payment_external_key
-      ][column]
-    end
+        ][column]
+      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)),
+      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
-      ]
-    end
+        ]
+      end
 
-    paginate searcher, data_extractor, formatter
-  end
+      paginate searcher, data_extractor, formatter
+    end
 
-  def new
-    cached_options_for_klient = options_for_klient
-    fetch_invoice = promise { Kaui::Invoice.find_by_id(params.require(:invoice_id), 'NONE', cached_options_for_klient) }
-    fetch_payment_methods = promise { Kaui::PaymentMethod.find_all_by_account_id(params.require(:account_id), false, cached_options_for_klient) }
+    def new
+      cached_options_for_klient = options_for_klient
+      fetch_invoice = promise { Kaui::Invoice.find_by_id(params.require(:invoice_id), 'NONE', cached_options_for_klient) }
+      fetch_payment_methods = promise { Kaui::PaymentMethod.find_all_by_account_id(params.require(:account_id), false, cached_options_for_klient) }
 
-    @invoice = wait(fetch_invoice)
-    @payment_methods = wait(fetch_payment_methods)
+      @invoice = wait(fetch_invoice)
+      @payment_methods = wait(fetch_payment_methods)
 
-    @payment = Kaui::InvoicePayment.new('accountId' => @account.account_id, 'targetInvoiceId' => @invoice.invoice_id, 'purchasedAmount' => @invoice.balance)
-  end
+      @payment = Kaui::InvoicePayment.new('accountId' => @account.account_id, 'targetInvoiceId' => @invoice.invoice_id, 'purchasedAmount' => @invoice.balance)
+    end
 
-  def create
-    payment = Kaui::InvoicePayment.new(invoice_payment_params)
-    external_payment = params[:external] == '1'
-    payment.payment_method_id = nil if external_payment || payment.payment_method_id.blank?
-    payment = payment.create(external_payment, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-    redirect_to kaui_engine.account_invoice_path(payment.account_id, payment.target_invoice_id), :notice => 'Payment created'
-  end
+    def create
+      payment = Kaui::InvoicePayment.new(invoice_payment_params)
+      external_payment = params[:external] == '1'
+      payment.payment_method_id = nil if external_payment || payment.payment_method_id.blank?
+      payment.create(external_payment, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.account_invoice_path(payment.account_id, payment.target_invoice_id), notice: 'Payment triggered'
+    end
 
-  def show
-    cached_options_for_klient = options_for_klient
+    def show
+      cached_options_for_klient = options_for_klient
 
-    invoice_payment = Kaui::InvoicePayment.find_safely_by_id(params.require(:id), cached_options_for_klient)
-    @payment = Kaui::InvoicePayment.build_from_raw_payment(invoice_payment)
+      invoice_payment = Kaui::InvoicePayment.find_safely_by_id(params.require(:id), cached_options_for_klient)
+      @payment = Kaui::InvoicePayment.build_from_raw_payment(invoice_payment)
 
-    fetch_payment_fields = promise {
-      direct_payment = Kaui::Payment.new(:payment_id => @payment.payment_id)
-      direct_payment.custom_fields('NONE', cached_options_for_klient).sort { |cf_a, cf_b| cf_a.name.downcase <=> cf_b.name.downcase }
-    }
-    # The payment method may have been deleted
-    fetch_payment_method = promise { Kaui::PaymentMethod.find_safely_by_id(@payment.payment_method_id, cached_options_for_klient) }
+      fetch_payment_fields = promise do
+        direct_payment = Kaui::Payment.new(payment_id: @payment.payment_id)
+        direct_payment.custom_fields('NONE', cached_options_for_klient).sort { |cf_a, cf_b| cf_a.name.downcase <=> cf_b.name.downcase }
+      end
+      # The payment method may have been deleted
+      fetch_payment_method = promise { Kaui::PaymentMethod.find_safely_by_id(@payment.payment_method_id, cached_options_for_klient) }
 
-    @custom_fields = wait(fetch_payment_fields)
-    @payment_method = wait(fetch_payment_method)
-  end
+      @custom_fields = wait(fetch_payment_fields)
+      @payment_method = wait(fetch_payment_method)
+    end
 
-  def restful_show
-    begin
-      payment = Kaui::InvoicePayment.find_by_id(params.require(:id), false, true, options_for_klient)
-    rescue KillBillClient::API::NotFound
-      payment = Kaui::Payment.find_by_external_key(params.require(:id), false, true, options_for_klient)
+    def restful_show
+      begin
+        payment = Kaui::InvoicePayment.find_by_id(params.require(:id), false, true, options_for_klient)
+      rescue KillBillClient::API::NotFound
+        payment = Kaui::Payment.find_by_external_key(params.require(:id), false, true, options_for_klient)
+      end
+      redirect_to account_payment_path(payment.account_id, payment.payment_id)
     end
-    redirect_to account_payment_path(payment.account_id, payment.payment_id)
-  end
 
-  def cancel_scheduled_payment
-    begin
+    def cancel_scheduled_payment
       payment_transaction = Kaui::Transaction.new
       payment_transaction.transaction_external_key = params.require(:transaction_external_key)
 
       payment_transaction.cancel_scheduled_payment(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
 
-      redirect_to kaui_engine.account_payment_path(params.require(:account_id), params.require(:id)), :notice => "Payment attempt retry successfully deleted"
-    rescue => e
+      redirect_to kaui_engine.account_payment_path(params.require(:account_id), params.require(:id)), notice: 'Payment attempt retry successfully deleted'
+    rescue StandardError => e
       flash[:error] = "Error deleting payment attempt retry: #{as_string(e)}"
       redirect_to kaui_engine.account_path(params.require(:account_id))
     end
-  end
 
-  private
+    private
 
-  def invoice_payment_params
-    invoice_payment = params.require(:invoice_payment)
-    invoice_payment.require(:target_invoice_id)
-    invoice_payment
+    def invoice_payment_params
+      invoice_payment = params.require(:invoice_payment)
+      invoice_payment.require(:target_invoice_id)
+      invoice_payment
+    end
   end
 end

data/app/controllers/kaui/queues_controller.rb

@@ -1,19 +1,52 @@
-class Kaui::QueuesController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def index
-    @account_id = params[:account_id]
-    begin
-      @now = Kaui::Admin.get_clock(nil, options_for_klient)['currentUtcTime'].to_datetime
-    rescue KillBillClient::API::NotFound
-      # If TestResource is not bound, then clock has not been manipulated, we can default to NOW
-      @now = DateTime.now.in_time_zone("UTC")
-    end
+module Kaui
+  class QueuesController < Kaui::EngineController
+    # rubocop:disable Lint/SuppressedException,Lint/EnsureReturn
+    def index
+      @account_id = params[:account_id]
+
+      unless params[:max_date].blank?
+        begin
+          max_date_test = Time.parse(params[:max_date]).iso8601
+        rescue StandardError
+        ensure
+          if max_date_test.nil?
+            flash[:error] = I18n.translate('errors.messages.invalid_max_date')
+            redirect_to account_queues_path(@account.account_id) and return
+          end
+        end
+      end
+
+      unless params[:min_date].blank?
+        begin
+          min_date_test = Time.parse(params[:min_date]).iso8601
+        rescue StandardError
+        ensure
+          if min_date_test.nil?
+            flash[:error] = I18n.translate('errors.messages.invalid_min_date')
+            redirect_to account_queues_path(@account.account_id) and return
+          end
+        end
+      end
 
-    min_date = params[:min_date] || '1970-01-01'
-    max_date = params[:max_date] || '2100-01-01'
-    with_history = params[:with_history] || false
-    @queues_entries = Kaui::Admin.get_queues_entries(@account_id, options_for_klient.merge(:withHistory => with_history, :minDate => min_date, :maxDate => max_date))
+      begin
+        @now = Kaui::Admin.get_clock(nil, options_for_klient)['currentUtcTime'].to_datetime
+      rescue KillBillClient::API::NotFound
+        # If TestResource is not bound, then clock has not been manipulated, we can default to NOW
+        @now = DateTime.now.in_time_zone('UTC')
+      end
 
-    params.permit!
+      min_date = (Time.parse(params[:min_date]).iso8601 unless params[:min_date].blank?) || '1970-01-01'
+      max_date = (Time.parse(params[:max_date]).iso8601 unless params[:max_date].blank?) || Time.now.iso8601
+
+      with_history = params[:with_history] || false
+      @queues_entries = Kaui::Admin.get_queues_entries(@account_id,
+                                                       options_for_klient.merge(withHistory: with_history,
+                                                                                minDate: min_date, maxDate: max_date))
+
+      params.permit!
+    end
+    # rubocop:enable Lint/SuppressedException,Lint/EnsureReturn
   end
 end

data/app/controllers/kaui/refunds_controller.rb

@@ -1,49 +1,52 @@
-class Kaui::RefundsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def new
-    cached_options_for_klient = options_for_klient
+module Kaui
+  class RefundsController < Kaui::EngineController
+    def new
+      cached_options_for_klient = options_for_klient
 
-    fetch_invoice = promise { Kaui::Invoice.find_by_id(params.require(:invoice_id), 'NONE', cached_options_for_klient) }
-    fetch_payment = promise { Kaui::InvoicePayment::find_by_id(params.require(:payment_id), false, false, cached_options_for_klient) }
-    fetch_bundles = promise { @account.bundles(cached_options_for_klient) }
+      fetch_invoice = promise { Kaui::Invoice.find_by_id(params.require(:invoice_id), 'NONE', cached_options_for_klient) }
+      fetch_payment = promise { Kaui::InvoicePayment.find_by_id(params.require(:payment_id), false, false, cached_options_for_klient) }
+      fetch_bundles = promise { @account.bundles(cached_options_for_klient) }
 
-    @invoice = wait(fetch_invoice)
-    @payment = wait(fetch_payment)
-    @bundles = wait(fetch_bundles)
+      @invoice = wait(fetch_invoice)
+      @payment = wait(fetch_payment)
+      @bundles = wait(fetch_bundles)
 
-    @refund = KillBillClient::Model::InvoiceItem.new(:invoice_id => @invoice.invoice_id)
-  end
+      @refund = KillBillClient::Model::InvoiceItem.new(invoice_id: @invoice.invoice_id)
+    end
 
-  def create
-    invoice = Kaui::Invoice.find_by_id(params.require(:invoice_id), 'NONE', options_for_klient)
+    # rubocop:disable Lint/FloatComparison
+    def create
+      invoice = Kaui::Invoice.find_by_id(params.require(:invoice_id), 'NONE', options_for_klient)
 
-    if params[:adjustment_type] == 'invoiceItemAdjustment'
-      items = []
-      (params.to_unsafe_h[:adjustments] || []).each do |ii|
-        original_item = find_original_item(invoice.items, ii[0])
+      if params[:adjustment_type] == 'invoiceItemAdjustment'
+        items = []
+        (params.to_unsafe_h[:adjustments] || []).each do |ii|
+          original_item = find_original_item(invoice.items, ii[0])
 
-        item = KillBillClient::Model::InvoiceItem.new
-        item.invoice_item_id = ii[0]
-        # If we tried to do a partial item adjustment, we pass the value, if not we don't send any value and let the system
-        # decide what is the maximum amount we can have on that item
-        item.amount = (ii[1].to_f == original_item.amount) ? nil : ii[1]
+          item = KillBillClient::Model::InvoiceItem.new
+          item.invoice_item_id = ii[0]
+          # If we tried to do a partial item adjustment, we pass the value, if not we don't send any value and let the system
+          # decide what is the maximum amount we can have on that item
+          item.amount = ii[1].to_f == original_item.amount ? nil : ii[1]
 
-        items << item
+          items << item
+        end
       end
-    end
 
-    KillBillClient::Model::InvoicePayment.refund(params.require(:payment_id), params[:amount], items, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-    redirect_to kaui_engine.account_invoice_path(invoice.account_id, invoice.invoice_id), :notice => 'Refund created'
-  end
+      KillBillClient::Model::InvoicePayment.refund(params.require(:payment_id), params[:amount], items, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.account_invoice_path(invoice.account_id, invoice.invoice_id), notice: 'Refund created'
+    end
+    # rubocop:enable Lint/FloatComparison
 
-  private
+    private
 
-  def find_original_item(items, item_id)
-    items.each do |ii|
-      if ii.invoice_item_id == item_id
-        return ii
+    def find_original_item(items, item_id)
+      items.each do |ii|
+        return ii if ii.invoice_item_id == item_id
       end
+      nil
     end
-    nil
   end
 end

data/app/controllers/kaui/registrations_controller.rb

@@ -1,12 +1,12 @@
+# frozen_string_literal: true
+
 module Kaui
   class RegistrationsController < Devise::RegistrationsController
-
     layout Kaui.config[:layout]
 
     skip_before_action :check_for_redirect_to_tenant_screen, raise: false
 
     def create
-
       if Kaui.disable_sign_up_link
         flash[:error] = 'You need to sign in before adding a user!'
         redirect_to new_user_session_path and return
@@ -14,7 +14,7 @@ module Kaui
 
       sign_up_params = sign_up_rails_params
 
-      @user = Kaui::AllowedUser.new(:kb_username => sign_up_params.require(:kb_username))
+      @user = Kaui::AllowedUser.new(kb_username: sign_up_params.require(:kb_username))
 
       if Kaui::AllowedUser.find_by_kb_username(@user.kb_username).present?
         flash.now[:error] = "User with name #{@user.kb_username} already exists!"
@@ -37,10 +37,10 @@ module Kaui
 
     def root_options_for_klient
       {
-          :username => Kaui.root_username,
-          :password => Kaui.root_password,
-          :api_key => Kaui.root_api_key,
-          :api_secret => Kaui.root_api_secret
+        username: Kaui.root_username,
+        password: Kaui.root_password,
+        api_key: Kaui.root_api_key,
+        api_secret: Kaui.root_api_secret
       }
     end
 

data/app/controllers/kaui/role_definitions_controller.rb

@@ -1,20 +1,23 @@
-class Kaui::RoleDefinitionsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def new
-    @role_definition = Kaui::RoleDefinition.new
-  end
+module Kaui
+  class RoleDefinitionsController < Kaui::EngineController
+    def new
+      @role_definition = Kaui::RoleDefinition.new
+    end
 
-  def create
-    # Sanity is done on the server side
-    @role_definition = Kaui::RoleDefinition.new(params.require(:role_definition))
-    @role_definition.permissions = @role_definition.permissions.split(',')
+    def create
+      # Sanity is done on the server side
+      @role_definition = Kaui::RoleDefinition.new(params.require(:role_definition))
+      @role_definition.permissions = @role_definition.permissions.split(',')
 
-    begin
-      @role_definition = @role_definition.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to admin_allowed_users_path, :notice => 'Role was successfully created'
-    rescue => e
-      flash.now[:error] = "Error while creating role: #{as_string(e)}"
-      render :action => :new
+      begin
+        @role_definition = @role_definition.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+        redirect_to admin_allowed_users_path, notice: 'Role was successfully created'
+      rescue StandardError => e
+        flash.now[:error] = "Error while creating role: #{as_string(e)}"
+        render action: :new
+      end
     end
   end
 end

data/app/controllers/kaui/sessions_controller.rb

@@ -1,28 +1,31 @@
+# frozen_string_literal: true
+
 module Kaui
   # Subclassed to specify the correct layout
   class SessionsController < Devise::SessionsController
-
     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
+
     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
-    def after_sign_in_path_for(resource)
+    def after_sign_in_path_for(_resource)
       # Clear the tenant_id from the cookie to not rely on old cookie data
       session[:kb_tenant_id] = nil
       stored_location_for(:user) || Kaui.tenant_home_path.call
     end
 
-    def after_sign_out_path_for(resource)
+    def after_sign_out_path_for(_resource)
       kaui_path
     end
 
     def require_no_authentication
       super
       # Remove the somewhat confusing message "You are already signed in."
-      flash.discard(:alert) if flash[:alert] == I18n.t("devise.failure.already_authenticated")
+      flash.discard(:alert) if flash[:alert] == I18n.t('devise.failure.already_authenticated')
     end
   end
 end