kaui 2.1.0 → 3.0.1

data/app/controllers/kaui/invoice_tags_controller.rb

@@ -1,28 +1,32 @@
-class Kaui::InvoiceTagsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def edit
-    @invoice_id = params.require(:invoice_id)
+module Kaui
+  class InvoiceTagsController < Kaui::EngineController
+    def edit
+      @invoice_id = params.require(:invoice_id)
 
-    cached_options_for_klient = options_for_klient
-    fetch_tag_names = promise { (Kaui::Tag.all_for_invoice(@invoice_id, false, 'NONE', cached_options_for_klient).map { |tag| tag.tag_definition_name }).sort }
-    fetch_available_tags = promise { Kaui::TagDefinition.all_for_invoice(cached_options_for_klient) }
+      cached_options_for_klient = options_for_klient
+      fetch_tag_names = promise { Kaui::Tag.all_for_invoice(@invoice_id, false, 'NONE', cached_options_for_klient).map(&:tag_definition_name).sort }
+      fetch_available_tags = promise { Kaui::TagDefinition.all_for_invoice(cached_options_for_klient) }
 
-    @tag_names = wait(fetch_tag_names)
-    @available_tags = wait(fetch_available_tags)
-  end
+      @tag_names = wait(fetch_tag_names)
+      @available_tags = wait(fetch_available_tags)
+    end
 
-  def update
-    account_id = params.require(:account_id)
-    invoice_id = params.require(:invoice_id)
+    def update
+      account_id = params.require(:account_id)
+      invoice_id = params.require(:invoice_id)
 
-    tags = []
-    params.each do |tag, tag_name|
-      tag_info = tag.split('_')
-      next if tag_info.size != 2 or tag_info[0] != 'tag'
-      tags << tag_info[1]
-    end
+      tags = []
+      params.each do |tag, _tag_name|
+        tag_info = tag.split('_')
+        next if (tag_info.size != 2) || (tag_info[0] != 'tag')
 
-    Kaui::Tag.set_for_invoice(invoice_id, tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-    redirect_to kaui_engine.invoice_path(invoice_id, :account_id => account_id), :notice => 'Invoice tags successfully set'
+        tags << tag_info[1]
+      end
+
+      Kaui::Tag.set_for_invoice(invoice_id, tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.invoice_path(invoice_id, account_id:), notice: 'Invoice tags successfully set'
+    end
   end
 end

data/app/controllers/kaui/invoices_controller.rb

@@ -1,68 +1,75 @@
-class Kaui::InvoicesController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def index
-    @search_query = params[:account_id]
+module Kaui
+  class InvoicesController < Kaui::EngineController
+    def index
+      @search_query = 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::Invoice.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
-  end
+      @max_nb_records = @search_query.blank? ? Kaui::Invoice.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
+    end
 
-  def pagination
-    cached_options_for_klient = options_for_klient
+    def pagination
+      cached_options_for_klient = options_for_klient
+
+      searcher = lambda do |search_key, offset, limit|
+        account = begin
+          Kaui::Account.find_by_id_or_key(search_key, false, false, cached_options_for_klient)
+        rescue StandardError
+          nil
+        end
+        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) }
+        end
+      end
 
-    searcher = lambda do |search_key, offset, limit|
-      account = Kaui::Account::find_by_id_or_key(search_key, false, false, cached_options_for_klient) rescue nil
-      if account.nil?
-        Kaui::Invoice.list_or_search(search_key, offset, limit, cached_options_for_klient)
+      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)[1]
+          row
+        end
       else
-        account.invoices(cached_options_for_klient.merge({ :params => { :includeVoidedInvoices => true } })).map! { |invoice| Kaui::Invoice.build_from_raw_invoice(invoice) }
+        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
       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)[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
+      paginate searcher, data_extractor, formatter
     end
 
-    paginate searcher, data_extractor, formatter
-  end
-
-  def show
-    # Go to the database once
-    cached_options_for_klient = options_for_klient
+    # rubocop:disable Lint/HashCompareByIdentity
+    def show
+      # Go to the database once
+      cached_options_for_klient = options_for_klient
 
-    @invoice = Kaui::Invoice.find_by_id(params.require(:id), 'FULL', cached_options_for_klient)
-    # This will put the TAX items at the bottom
-    precedence = {
+      @invoice = Kaui::Invoice.find_by_id(params.require(:id), 'FULL', cached_options_for_klient)
+      # This will put the TAX items at the bottom
+      precedence = {
         'EXTERNAL_CHARGE' => 0,
         'FIXED' => 1,
         'RECURRING' => 2,
@@ -73,74 +80,82 @@ class Kaui::InvoicesController < Kaui::EngineController
         'CBA_ADJ' => 7,
         'CREDIT_ADJ' => 8,
         'TAX' => 9
-    }
-    # TODO The pretty description has to be shared with the view
-    @invoice.items.sort_by! do |ii|
-      # Make sure not to compare nil (ArgumentError comparison of Array with Array failed)
-      a = precedence[ii.item_type] || 100
-      b = (ii.pretty_plan_name.blank? || !ii.item_type.in?(%w{USAGE RECURRING}) ? ii.description : ii.pretty_plan_name) || ''
-      [a, b]
-    end
+      }
+      # TODO: The pretty description has to be shared with the view
+      @invoice.items.sort_by! do |ii|
+        # Make sure not to compare nil (ArgumentError comparison of Array with Array failed)
+        a = precedence[ii.item_type] || 100
+        b = (ii.pretty_plan_name.blank? || !ii.item_type.in?(%w[USAGE RECURRING]) ? ii.description : ii.pretty_plan_name) || ''
+        [a, b]
+      end
 
-    fetch_payments = promise { @invoice.payments(true, true, 'FULL', cached_options_for_klient).map { |payment| Kaui::InvoicePayment.build_from_raw_payment(payment) } }
-    fetch_pms = fetch_payments.then { |payments| Kaui::PaymentMethod.payment_methods_for_payments(payments, cached_options_for_klient) }
-    fetch_invoice_fields = promise { @invoice.custom_fields('NONE', cached_options_for_klient).sort { |cf_a, cf_b| cf_a.name.downcase <=> cf_b.name.downcase } }
-    fetch_payment_fields = promise {
-      all_payment_fields = @account.all_custom_fields(:PAYMENT, 'NONE', cached_options_for_klient)
-      all_payment_fields.inject({}) { |hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh }
-    }
-
-    fetch_available_invoice_item_tags = promise { Kaui::TagDefinition.all_for_invoice_item(cached_options_for_klient) }
-    fetch_tags_per_invoice_item = promise {
-      tags_per_invoice_item = @account.all_tags(:INVOICE_ITEM, false, 'NONE', cached_options_for_klient)
-      tags_per_invoice_item.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
-    }
-
-    fetch_custom_fields_per_invoice_item = promise {
-      custom_fields_per_invoice_item = @account.all_custom_fields(:INVOICE_ITEM, 'NONE', cached_options_for_klient)
-      custom_fields_per_invoice_item.inject({}) { |hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh }
-    }
-
-    fetch_invoice_tags = promise { @invoice.tags(false, 'NONE', cached_options_for_klient).sort { |tag_a, tag_b| tag_a <=> tag_b } }
-    fetch_available_invoice_tags = promise { Kaui::TagDefinition.all_for_invoice(cached_options_for_klient) }
-
-    @payments = wait(fetch_payments)
-    @payment_methods = wait(fetch_pms)
-    @custom_fields = wait(fetch_invoice_fields)
-    @payment_custom_fields = wait(fetch_payment_fields)
-    @custom_fields_per_invoice_item = wait(fetch_custom_fields_per_invoice_item)
-    @tags_per_invoice_item = wait(fetch_tags_per_invoice_item)
-    @available_invoice_item_tags = wait(fetch_available_invoice_item_tags)
-    @invoice_tags = wait(fetch_invoice_tags)
-    @available_invoice_tags = wait(fetch_available_invoice_tags)
-    @available_invoice_tags.reject! { |td| td.name == 'WRITTEN_OFF' } if @invoice.status == 'VOID'
-  end
+      fetch_payments = promise { @invoice.payments(true, true, 'FULL', cached_options_for_klient).map { |payment| Kaui::InvoicePayment.build_from_raw_payment(payment) } }
+      fetch_pms = fetch_payments.then { |payments| Kaui::PaymentMethod.payment_methods_for_payments(payments, cached_options_for_klient) }
+      fetch_invoice_fields = promise { @invoice.custom_fields('NONE', cached_options_for_klient).sort { |cf_a, cf_b| cf_a.name.downcase <=> cf_b.name.downcase } }
+      fetch_payment_fields = promise do
+        all_payment_fields = @account.all_custom_fields(:PAYMENT, 'NONE', cached_options_for_klient)
+        all_payment_fields.each_with_object({}) do |entry, hsh|
+          (hsh[entry.object_id] ||= []) << entry
+        end
+      end
 
-  def void_invoice
-    cached_options_for_klient = options_for_klient
-    invoice = KillBillClient::Model::Invoice.find_by_id(params.require(:id), 'NONE', cached_options_for_klient)
-    begin
-      invoice.void(current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
-      redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id), :notice => 'Invoice successfully voided'
-    rescue => e
-      flash[:error] = "Unable to void invoice: #{as_string(e)}"
-      redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id)
+      fetch_available_invoice_item_tags = promise { Kaui::TagDefinition.all_for_invoice_item(cached_options_for_klient) }
+      fetch_tags_per_invoice_item = promise do
+        tags_per_invoice_item = @account.all_tags(:INVOICE_ITEM, false, 'NONE', cached_options_for_klient)
+        tags_per_invoice_item.each_with_object({}) do |entry, hsh|
+          (hsh[entry.object_id] ||= []) << entry
+        end
+      end
+
+      fetch_custom_fields_per_invoice_item = promise do
+        custom_fields_per_invoice_item = @account.all_custom_fields(:INVOICE_ITEM, 'NONE', cached_options_for_klient)
+        custom_fields_per_invoice_item.each_with_object({}) do |entry, hsh|
+          (hsh[entry.object_id] ||= []) << entry
+        end
+      end
+
+      fetch_invoice_tags = promise { @invoice.tags(false, 'NONE', cached_options_for_klient).sort { |tag_a, tag_b| tag_a <=> tag_b } }
+      fetch_available_invoice_tags = promise { Kaui::TagDefinition.all_for_invoice(cached_options_for_klient) }
+
+      @payments = wait(fetch_payments)
+      @payment_methods = wait(fetch_pms)
+      @custom_fields = wait(fetch_invoice_fields)
+      @payment_custom_fields = wait(fetch_payment_fields)
+      @custom_fields_per_invoice_item = wait(fetch_custom_fields_per_invoice_item)
+      @tags_per_invoice_item = wait(fetch_tags_per_invoice_item)
+      @available_invoice_item_tags = wait(fetch_available_invoice_item_tags)
+      @invoice_tags = wait(fetch_invoice_tags)
+      @available_invoice_tags = wait(fetch_available_invoice_tags)
+      @available_invoice_tags.reject! { |td| td.name == 'WRITTEN_OFF' } if @invoice.status == 'VOID'
+    end
+    # rubocop:enable Lint/HashCompareByIdentity
+
+    def void_invoice
+      cached_options_for_klient = options_for_klient
+      invoice = KillBillClient::Model::Invoice.find_by_id(params.require(:id), 'NONE', cached_options_for_klient)
+      begin
+        invoice.void(current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
+        redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id), notice: 'Invoice successfully voided'
+      rescue StandardError => e
+        flash[:error] = "Unable to void invoice: #{as_string(e)}"
+        redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id)
+      end
     end
-  end
 
-  def restful_show
-    invoice = Kaui::Invoice.find_by_id(params.require(:id), 'NONE', options_for_klient)
-    redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id)
-  end
+    def restful_show
+      invoice = Kaui::Invoice.find_by_id(params.require(:id), 'NONE', options_for_klient)
+      redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id)
+    end
 
-  def show_html
-    render :html => Kaui::Invoice.as_html(params.require(:id), options_for_klient).html_safe
-  end
+    def show_html
+      render html: Kaui::Invoice.as_html(params.require(:id), options_for_klient).html_safe
+    end
 
-  def commit_invoice
-    cached_options_for_klient = options_for_klient
-    invoice = KillBillClient::Model::Invoice.find_by_id(params.require(:id), 'NONE', cached_options_for_klient)
-    invoice.commit(current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
-    redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id), :notice => 'Invoice successfully committed'
+    def commit_invoice
+      cached_options_for_klient = options_for_klient
+      invoice = KillBillClient::Model::Invoice.find_by_id(params.require(:id), 'NONE', cached_options_for_klient)
+      invoice.commit(current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
+      redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id), notice: 'Invoice successfully committed'
+    end
   end
 end

data/app/controllers/kaui/login_proxy_controller.rb

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Kaui
   class LoginProxyController < Kaui::EngineController
-
     def check_login
       #
       # Redirect to where we come from after going through all the Kaui filters ensuring correct authentication and kb_tenant_id

data/app/controllers/kaui/payment_methods_controller.rb

@@ -1,116 +1,124 @@
-class Kaui::PaymentMethodsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def new
-    @payment_method = Kaui::PaymentMethod.new(:account_id  => params[:account_id],
-                                              :plugin_name => params[:plugin_name] || Kaui.creditcard_plugin_name.call)
-  end
+module Kaui
+  class PaymentMethodsController < Kaui::EngineController
+    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? })
-    # Transform "1" into boolean
-    @payment_method.is_default  = @payment_method.is_default == '1'
-    # Sensible default
-    @payment_method.plugin_name ||= Kaui.creditcard_plugin_name.call
-
-    # Instance variables needed in case of failure
-    @card_type                  = params[:card_type]
-    @card_holder_name           = params[:card_holder_name]
-    @expiration_year            = params[:expiration_year]
-    @expiration_month           = params[:expiration_month]
-    @credit_card_number         = params[:credit_card_number]
-    @verification_value         = params[:verification_value]
-    @address1                   = params[:address1]
-    @address2                   = params[:address2]
-    @city                       = params[:city]
-    @postal_code                = params[:postal_code]
-    @state                      = params[:state]
-    @country                    = params[:country]
-
-    # Magic from lib/killbill/helpers/active_merchant/payment_plugin.rb
-    @payment_method.plugin_info = {
-        'type'                => 'CreditCard',
-        'ccType'              => @card_type,
-        'ccFirstName'         => @card_holder_name,
-        'ccLastName'          => @card_holder_name,
-        'ccExpirationMonth'   => @expiration_month,
-        'ccExpirationYear'    => @expiration_year,
-        'ccNumber'            => @credit_card_number,
+    def create
+      @payment_method             = Kaui::PaymentMethod.new(params[:payment_method].delete_if { |_key, value| value.blank? })
+      # Transform "1" into boolean
+      @payment_method.is_default  = @payment_method.is_default == '1'
+      # Sensible default
+      @payment_method.plugin_name ||= Kaui.creditcard_plugin_name.call
+
+      # Instance variables needed in case of failure
+      @card_type                  = params[:card_type]
+      @card_holder_name           = params[:card_holder_name]
+      @expiration_year            = params[:expiration_year]
+      @expiration_month           = params[:expiration_month]
+      @credit_card_number         = params[:credit_card_number]
+      @verification_value         = params[:verification_value]
+      @address1                   = params[:address1]
+      @address2                   = params[:address2]
+      @city                       = params[:city]
+      @postal_code                = params[:postal_code]
+      @state                      = params[:state]
+      @country                    = params[:country]
+
+      # Magic from lib/killbill/helpers/active_merchant/payment_plugin.rb
+      @payment_method.plugin_info = {
+        'type' => 'CreditCard',
+        'ccType' => @card_type,
+        'ccFirstName' => @card_holder_name,
+        'ccLastName' => @card_holder_name,
+        'ccExpirationMonth' => @expiration_month,
+        'ccExpirationYear' => @expiration_year,
+        'ccNumber' => @credit_card_number,
         'ccVerificationValue' => @verification_value,
-        'address1'            => @address1,
-        'address2'            => @address2,
-        'city'                => @city,
-        'country'             => @country,
-        'zip'                 => @postal_code,
-        'state'               => @state
-    }
-
-    @plugin_properties = params[:plugin_properties].values.select{ |item| !(item['value'].blank? || item['key'].blank?) } rescue @plugin_properties = nil
-    if @plugin_properties.blank?
-      # In case of error, we want the view to receive nil, not [], so that at least the first row is populated (required to make the JS work)
-      # See https://github.com/killbill/killbill-admin-ui/issues/258
-      @plugin_properties = nil
-    else
-      @plugin_properties.map! do |property|
-        KillBillClient::Model::PluginPropertyAttributes.new(property)
+        'address1' => @address1,
+        'address2' => @address2,
+        'city' => @city,
+        'country' => @country,
+        'zip' => @postal_code,
+        'state' => @state
+      }
+
+      @plugin_properties = begin
+        params[:plugin_properties].values.reject { |item| (item['value'].blank? || item['key'].blank?) }
+      rescue StandardError
+        @plugin_properties = nil
+      end
+      if @plugin_properties.blank?
+        # In case of error, we want the view to receive nil, not [], so that at least the first row is populated (required to make the JS work)
+        # See https://github.com/killbill/killbill-admin-ui/issues/258
+        @plugin_properties = nil
+      else
+        @plugin_properties.map! do |property|
+          KillBillClient::Model::PluginPropertyAttributes.new(property)
+        end
+      end
+
+      begin
+        @payment_method = @payment_method.create(@payment_method.is_default, current_user.kb_username, params[:reason], params[:comment],
+                                                 @plugin_properties.blank? ? options_for_klient : { pluginProperty: @plugin_properties }.merge(options_for_klient))
+        redirect_to kaui_engine.account_path(@payment_method.account_id), notice: 'Payment method was successfully created'
+      rescue StandardError => e
+        flash.now[:error] = "Error while creating payment method: #{as_string(e)}"
+        render action: :new
       end
     end
 
-    begin
-      @payment_method = @payment_method.create(@payment_method.is_default, current_user.kb_username, params[:reason], params[:comment],
-                                               @plugin_properties.blank? ? options_for_klient : ({:pluginProperty => @plugin_properties}).merge(options_for_klient))
-      redirect_to kaui_engine.account_path(@payment_method.account_id), :notice => 'Payment method was successfully created'
-    rescue => e
-      flash.now[:error] = "Error while creating payment method: #{as_string(e)}"
-      render :action => :new
+    def destroy
+      payment_method_id = params[:id]
+
+      payment_method = Kaui::PaymentMethod.find_by_id(payment_method_id, false, options_for_klient)
+      begin
+        Kaui::PaymentMethod.destroy(payment_method_id, params[:set_auto_pay_off], false, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+        redirect_to kaui_engine.account_path(payment_method.account_id), notice: "Payment method #{payment_method_id} successfully deleted"
+      rescue StandardError => e
+        flash[:error] = "Error while deleting payment method #{payment_method_id}: #{as_string(e)}"
+        redirect_to kaui_engine.account_path(payment_method.account_id)
+      end
     end
-  end
 
-  def destroy
-    payment_method_id = params[:id]
+    def show
+      restful_show
+    end
 
-    payment_method = Kaui::PaymentMethod.find_by_id(payment_method_id, false, options_for_klient)
-    begin
-      Kaui::PaymentMethod.destroy(payment_method_id, params[:set_auto_pay_off], false, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.account_path(payment_method.account_id), :notice => "Payment method #{payment_method_id} successfully deleted"
-    rescue => e
-      flash[:error] = "Error while deleting payment method #{payment_method_id}: #{as_string(e)}"
+    def restful_show
+      payment_method = Kaui::PaymentMethod.find_by_id(params.require(:id), false, options_for_klient)
       redirect_to kaui_engine.account_path(payment_method.account_id)
     end
-  end
 
-  def show
-    restful_show
-  end
-
-  def restful_show
-    payment_method = Kaui::PaymentMethod.find_by_id(params.require(:id), false, options_for_klient)
-    redirect_to kaui_engine.account_path(payment_method.account_id)
-  end
+    def validate_external_key
+      json_response do
+        external_key = params.require(:external_key)
 
-  def validate_external_key
-    json_response do
-      external_key = params.require(:external_key)
+        begin
+          payment_methods = Kaui::PaymentMethod.find_by_external_key(external_key, false, false, 'NONE', options_for_klient)
+        rescue KillBillClient::API::NotFound
+          payment_methods = nil
+        end
 
-      begin
-        payment_methods = Kaui::PaymentMethod::find_by_external_key(external_key,false,false,'NONE', options_for_klient)
-      rescue KillBillClient::API::NotFound
-        payment_methods = nil
+        { is_found: !payment_methods.nil? }
       end
+    end
 
-      { :is_found => !payment_methods.nil? }
+    def refresh
+      Kaui::PaymentMethod.refresh(params.require(:account_id), current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.account_path(params.require(:account_id)), notice: 'Payment methods successfully refreshed'
     end
-  end
 
-  def refresh
-    Kaui::PaymentMethod.refresh(params.require(:account_id), current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-    redirect_to kaui_engine.account_path(params.require(:account_id)), :notice => 'Payment methods successfully refreshed'
-  end
+    private
 
-  private
+    def find_value_from_properties(properties, key)
+      return nil if key.nil? || properties.nil?
 
-  def find_value_from_properties(properties, key)
-    return nil if key.nil? or properties.nil?
-    prop = (properties.find { |kv| kv.key.to_s == key.to_s })
-    prop.nil? ? nil : prop.value
+      prop = (properties.find { |kv| kv.key.to_s == key.to_s })
+      prop&.value
+    end
   end
 end