kaui 2.0.4 → 2.2.1

data/app/controllers/kaui/audit_logs_controller.rb

@@ -1,28 +1,30 @@
-class Kaui::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]
+# frozen_string_literal: true
 
-  def index
-    cached_options_for_klient = options_for_klient
-    @account = Kaui::Account::find_by_id_or_key(params.require(:account_id), false, false, cached_options_for_klient)
-    audit_logs = @account.audit(cached_options_for_klient)
+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
 
+    def index
+      cached_options_for_klient = options_for_klient
+      @account = Kaui::Account.find_by_id_or_key(params.require(:account_id), false, false, cached_options_for_klient)
+      audit_logs = @account.audit(cached_options_for_klient)
 
-    formatter = lambda do |log|
-      object_id_text = view_context.object_id_popover(log.object_id)
+      formatter = lambda do |log|
+        object_id_text = view_context.object_id_popover(log.object_id)
 
-      if object_with_history?(log.object_type)
-        object_id_text = view_context.link_to(object_id_text, '#showHistoryModal',
-                                              data: {
+        if object_with_history?(log.object_type)
+          object_id_text = view_context.link_to(object_id_text, '#showHistoryModal',
+                                                data: {
                                                   toggle: 'modal',
                                                   object_id: log.object_id,
                                                   object_type: log.object_type,
                                                   change_date: log.change_date,
                                                   change_type: log.change_type,
                                                   account_id: @account.account_id
-                                              })
-      end
+                                                })
+        end
 
-      [
+        [
           log.change_date,
           object_id_text,
           log.object_type,
@@ -31,86 +33,87 @@ class Kaui::AuditLogsController < Kaui::EngineController
           log.reason_code,
           log.comments,
           view_context.object_id_popover(log.user_token, 'left')
-      ]
-    end
+        ]
+      end
 
-    @audit_logs_json = []
-    audit_logs.each { |page| @audit_logs_json << formatter.call(page) }
+      @audit_logs_json = []
+      audit_logs.each { |page| @audit_logs_json << formatter.call(page) }
 
-    @audit_logs_json = @audit_logs_json.to_json
-  end
+      @audit_logs_json = @audit_logs_json.to_json
+    end
 
-  def history
-    json_response do
-      account_id = params.require(:account_id)
-      object_id = params.require(:object_id)
-      object_type = params.require(:object_type)
-      cached_options_for_klient = options_for_klient
+    def history
+      json_response do
+        account_id = params.require(:account_id)
+        object_id = params.require(:object_id)
+        object_type = params.require(:object_type)
+        cached_options_for_klient = options_for_klient
 
-      audit_logs_with_history = []
-      error = nil
-      
-      begin
-        if object_type == 'ACCOUNT'
-          account = Kaui::Account::find_by_id_or_key(object_id, false, false, cached_options_for_klient)
-          audit_logs_with_history = account.audit_logs_with_history(cached_options_for_klient)
-        elsif object_type == 'ACCOUNT_EMAIL'
-          account = Kaui::Account::find_by_id_or_key(account_id, false, false, cached_options_for_klient)
-          audit_logs_with_history = account.email_audit_logs_with_history(object_id, cached_options_for_klient)
-        elsif object_type == 'BLOCKING_STATES'
-          audit_logs_with_history = Kaui::Account::blocking_state_audit_logs_with_history(object_id, cached_options_for_klient)
-        elsif object_type == 'BUNDLE'
-          bundle = Kaui::Bundle::find_by_id(object_id, cached_options_for_klient)
-          audit_logs_with_history = bundle.audit_logs_with_history(cached_options_for_klient)
-        elsif object_type == 'CUSTOM_FIELD'
-          audit_logs_with_history = Kaui::CustomField.new({:custom_field_id => object_id}).audit_logs_with_history(cached_options_for_klient)
-        elsif object_type == 'INVOICE'
-          invoice = Kaui::Invoice::find_by_id(object_id, false, "NONE", cached_options_for_klient)
-          audit_logs_with_history = invoice.audit_logs_with_history(cached_options_for_klient)
-        elsif object_type == 'INVOICE_ITEM'
-          invoice_item = Kaui::InvoiceItem.new
-          invoice_item.invoice_item_id = object_id
-          audit_logs_with_history = invoice_item.audit_logs_with_history(cached_options_for_klient)
-=begin See https://github.com/killbill/killbill/issues/1104
-        elsif object_type == 'INVOICE_PAYMENT'
-          invoice_payment = Kaui::InvoicePayment::find_by_id(object_id, false, false, cached_options_for_klient)
-          audit_logs_with_history = invoice_payment.audit_logs_with_history(cached_options_for_klient)
-=end
-        elsif object_type == 'PAYMENT_ATTEMPT'
-          audit_logs_with_history = Kaui::Payment::attempt_audit_logs_with_history(object_id, cached_options_for_klient)
-        elsif object_type == 'PAYMENT'
-          payment = Kaui::Payment::find_by_id(object_id, false, false, cached_options_for_klient)
-          audit_logs_with_history = payment.audit_logs_with_history(cached_options_for_klient)
-        elsif object_type == 'PAYMENT_METHOD'
-          payment_method = Kaui::PaymentMethod::find_by_id(object_id, false, cached_options_for_klient)
-          audit_logs_with_history = payment_method.audit_logs_with_history(cached_options_for_klient)
-        elsif object_type == 'SUBSCRIPTION'
-          subscription = Kaui::Subscription::find_by_id(object_id, cached_options_for_klient)
-          audit_logs_with_history = subscription.audit_logs_with_history(cached_options_for_klient)
-        elsif object_type == 'SUBSCRIPTION_EVENT'
-          audit_logs_with_history = Kaui::Subscription::event_audit_logs_with_history(object_id, cached_options_for_klient)
-        elsif object_type == 'TRANSACTION'
-          audit_logs_with_history = Kaui::Transaction::new({:transaction_id => object_id}).audit_logs_with_history(cached_options_for_klient)
-        elsif object_type == 'TAG'
-          audit_logs_with_history = Kaui::Tag.new({:tag_id => object_id}).audit_logs_with_history(cached_options_for_klient)
-        elsif object_type == 'TAG_DEFINITION'
-          audit_logs_with_history = Kaui::TagDefinition.new({:id => object_id}).audit_logs_with_history(cached_options_for_klient)
-        else
-          error = "Object [#{object_type}] history is not supported."
+        audit_logs_with_history = []
+        error = nil
+
+        begin
+          case object_type
+          when 'ACCOUNT'
+            account = Kaui::Account.find_by_id_or_key(object_id, false, false, cached_options_for_klient)
+            audit_logs_with_history = account.audit_logs_with_history(cached_options_for_klient)
+          when 'ACCOUNT_EMAIL'
+            account = Kaui::Account.find_by_id_or_key(account_id, false, false, cached_options_for_klient)
+            audit_logs_with_history = account.email_audit_logs_with_history(object_id, cached_options_for_klient)
+          when 'BLOCKING_STATES'
+            audit_logs_with_history = Kaui::Account.blocking_state_audit_logs_with_history(object_id, cached_options_for_klient)
+          when 'BUNDLE'
+            bundle = Kaui::Bundle.find_by_id(object_id, cached_options_for_klient)
+            audit_logs_with_history = bundle.audit_logs_with_history(cached_options_for_klient)
+          when 'CUSTOM_FIELD'
+            audit_logs_with_history = Kaui::CustomField.new({ custom_field_id: object_id }).audit_logs_with_history(cached_options_for_klient)
+          when 'INVOICE'
+            invoice = Kaui::Invoice.find_by_id(object_id, 'NONE', cached_options_for_klient)
+            audit_logs_with_history = invoice.audit_logs_with_history(cached_options_for_klient)
+          when 'INVOICE_ITEM'
+            invoice_item = Kaui::InvoiceItem.new
+            invoice_item.invoice_item_id = object_id
+            audit_logs_with_history = invoice_item.audit_logs_with_history(cached_options_for_klient)
+          # See https://github.com/killbill/killbill/issues/1104
+          #         elsif object_type == 'INVOICE_PAYMENT'
+          #           invoice_payment = Kaui::InvoicePayment::find_by_id(object_id, false, false, cached_options_for_klient)
+          #           audit_logs_with_history = invoice_payment.audit_logs_with_history(cached_options_for_klient)
+          when 'PAYMENT_ATTEMPT'
+            audit_logs_with_history = Kaui::Payment.attempt_audit_logs_with_history(object_id, cached_options_for_klient)
+          when 'PAYMENT'
+            payment = Kaui::Payment.find_by_id(object_id, false, false, cached_options_for_klient)
+            audit_logs_with_history = payment.audit_logs_with_history(cached_options_for_klient)
+          when 'PAYMENT_METHOD'
+            payment_method = Kaui::PaymentMethod.find_by_id(object_id, false, cached_options_for_klient)
+            audit_logs_with_history = payment_method.audit_logs_with_history(cached_options_for_klient)
+          when 'SUBSCRIPTION'
+            subscription = Kaui::Subscription.find_by_id(object_id, cached_options_for_klient)
+            audit_logs_with_history = subscription.audit_logs_with_history(cached_options_for_klient)
+          when 'SUBSCRIPTION_EVENT'
+            audit_logs_with_history = Kaui::Subscription.event_audit_logs_with_history(object_id, cached_options_for_klient)
+          when 'TRANSACTION'
+            audit_logs_with_history = Kaui::Transaction.new({ transaction_id: object_id }).audit_logs_with_history(cached_options_for_klient)
+          when 'TAG'
+            audit_logs_with_history = Kaui::Tag.new({ tag_id: object_id }).audit_logs_with_history(cached_options_for_klient)
+          when 'TAG_DEFINITION'
+            audit_logs_with_history = Kaui::TagDefinition.new({ id: object_id }).audit_logs_with_history(cached_options_for_klient)
+          else
+            error = "Object [#{object_type}] history is not supported."
+          end
+        rescue StandardError => e
+          error = e.message
         end
-      rescue Exception => e
-        error = e.message
-      end
 
-      { audits: audit_logs_with_history, error: error }
+        { audits: audit_logs_with_history, error: error }
+      end
     end
-  end
 
-  private
+    private
 
     def object_with_history?(object_type)
       return false if object_type.nil?
+
       OBJECT_WITH_HISTORY.include?(object_type)
     end
-
-end
+  end
+end

data/app/controllers/kaui/bundle_tags_controller.rb

@@ -1,28 +1,32 @@
-class Kaui::BundleTagsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def edit
-    @bundle_id = params.require(:bundle_id)
+module Kaui
+  class BundleTagsController < Kaui::EngineController
+    def edit
+      @bundle_id = params.require(:bundle_id)
 
-    cached_options_for_klient = options_for_klient
-    fetch_tag_names = promise { (Kaui::Tag.all_for_bundle(@bundle_id, false, 'NONE', cached_options_for_klient).map { |tag| tag.tag_definition_name }).sort }
-    fetch_available_tags = promise { Kaui::TagDefinition.all_for_bundle(cached_options_for_klient) }
+      cached_options_for_klient = options_for_klient
+      fetch_tag_names = promise { Kaui::Tag.all_for_bundle(@bundle_id, false, 'NONE', cached_options_for_klient).map(&:tag_definition_name).sort }
+      fetch_available_tags = promise { Kaui::TagDefinition.all_for_bundle(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)
-    bundle_id = params.require(:bundle_id)
+    def update
+      account_id = params.require(:account_id)
+      bundle_id = params.require(:bundle_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_bundle(bundle_id, tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-    redirect_to kaui_engine.account_bundles_path(account_id), :notice => 'Bundle tags successfully set'
+        tags << tag_info[1]
+      end
+
+      Kaui::Tag.set_for_bundle(bundle_id, tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.account_bundles_path(account_id), notice: 'Bundle tags successfully set'
+    end
   end
 end

data/app/controllers/kaui/bundles_controller.rb

@@ -1,99 +1,113 @@
-class Kaui::BundlesController < Kaui::EngineController
-
-  def index
-    cached_options_for_klient = options_for_klient
-
-    fetch_bundles = promise { @account.bundles(cached_options_for_klient) }
-    fetch_bundle_tags = promise {
-      all_bundle_tags = @account.all_tags(:BUNDLE, false, 'NONE', cached_options_for_klient)
-      all_bundle_tags.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
-    }
-    fetch_subscription_tags = promise {
-      all_subscription_tags = @account.all_tags(:SUBSCRIPTION, false, 'NONE', cached_options_for_klient)
-      all_subscription_tags.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
-    }
-    fetch_bundle_fields = promise {
-      all_bundle_fields = @account.all_custom_fields(:BUNDLE, 'NONE', cached_options_for_klient)
-      all_bundle_fields.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
-    }
-    fetch_subscription_fields = promise {
-      all_subscription_fields = @account.all_custom_fields(:SUBSCRIPTION, 'NONE', cached_options_for_klient)
-      all_subscription_fields.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
-    }
-    fetch_available_tags = promise { Kaui::TagDefinition.all_for_bundle(cached_options_for_klient) }
-    fetch_available_subscription_tags = promise { Kaui::TagDefinition.all_for_subscription(cached_options_for_klient) }
-
-    @bundles = wait(fetch_bundles)
-    @tags_per_bundle = wait(fetch_bundle_tags)
-    @tags_per_subscription = wait(fetch_subscription_tags)
-    @custom_fields_per_bundle = wait(fetch_bundle_fields)
-    @custom_fields_per_subscription = wait(fetch_subscription_fields)
-    @available_tags = wait(fetch_available_tags)
-    @available_subscription_tags = wait(fetch_available_subscription_tags)
-
-    # TODO This doesn't take into account catalog versions
-    catalogs = Kaui::Catalog.get_account_catalog_json(@account.account_id, nil, cached_options_for_klient) || []
-    @catalog = catalogs[-1]
-
-    @subscription = {}
-    @bundles.each do |bundle|
-      bundle.subscriptions.each do |sub|
-        next if sub.product_category == 'ADD_ON'
-        @subscription[bundle.bundle_id] = sub
-        break
+# frozen_string_literal: true
+
+module Kaui
+  class BundlesController < Kaui::EngineController
+    # rubocop:disable Lint/HashCompareByIdentity
+    def index
+      cached_options_for_klient = options_for_klient
+
+      fetch_bundles = promise { @account.bundles(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|
+          (hsh[entry.object_id] ||= []) << entry
+        end
+      end
+      fetch_subscription_tags = promise do
+        all_subscription_tags = @account.all_tags(:SUBSCRIPTION, false, 'NONE', cached_options_for_klient)
+        all_subscription_tags.each_with_object({}) do |entry, hsh|
+          (hsh[entry.object_id] ||= []) << entry
+        end
+      end
+      fetch_bundle_fields = promise do
+        all_bundle_fields = @account.all_custom_fields(:BUNDLE, 'NONE', cached_options_for_klient)
+        all_bundle_fields.each_with_object({}) do |entry, hsh|
+          (hsh[entry.object_id] ||= []) << entry
+        end
+      end
+      fetch_subscription_fields = promise do
+        all_subscription_fields = @account.all_custom_fields(:SUBSCRIPTION, 'NONE', cached_options_for_klient)
+        all_subscription_fields.each_with_object({}) do |entry, hsh|
+          (hsh[entry.object_id] ||= []) << entry
+        end
+      end
+      fetch_available_tags = promise { Kaui::TagDefinition.all_for_bundle(cached_options_for_klient) }
+      fetch_available_subscription_tags = promise { Kaui::TagDefinition.all_for_subscription(cached_options_for_klient) }
+
+      @bundles = wait(fetch_bundles)
+      @tags_per_bundle = wait(fetch_bundle_tags)
+      @tags_per_subscription = wait(fetch_subscription_tags)
+      @custom_fields_per_bundle = wait(fetch_bundle_fields)
+      @custom_fields_per_subscription = wait(fetch_subscription_fields)
+      @available_tags = wait(fetch_available_tags)
+      @available_subscription_tags = wait(fetch_available_subscription_tags)
+
+      # TODO: This doesn't take into account catalog versions
+      catalogs = Kaui::Catalog.get_account_catalog_json(@account.account_id, nil, cached_options_for_klient) || []
+      @catalog = catalogs[-1]
+
+      @subscription = {}
+      @bundles.each do |bundle|
+        bundle.subscriptions.each do |sub|
+          next if sub.product_category == 'ADD_ON'
+
+          @subscription[bundle.bundle_id] = sub
+          break
+        end
       end
     end
-  end
+    # rubocop:enable Lint/HashCompareByIdentity
 
-  def transfer
-    @bundle_id = params.require(:id)
-  end
+    def transfer
+      @bundle_id = params.require(:id)
+    end
 
-  def do_transfer
-    cached_options_for_klient = options_for_klient
+    def do_transfer
+      cached_options_for_klient = options_for_klient
 
-    new_account = Kaui::Account::find_by_id_or_key(params.require(:new_account_key), false, false, cached_options_for_klient)
+      new_account = Kaui::Account.find_by_id_or_key(params.require(:new_account_key), false, false, cached_options_for_klient)
 
-    bundle = Kaui::Bundle::new(:bundle_id => params.require(:id), :account_id => new_account.account_id)
-    bundle.transfer(nil, params[:billing_policy], current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
+      bundle = Kaui::Bundle.new(bundle_id: params.require(:id), account_id: new_account.account_id)
+      bundle.transfer(nil, params[:billing_policy], current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
 
-    redirect_to kaui_engine.account_bundles_path(new_account.account_id), :notice => 'Bundle was successfully transferred'
-  end
+      redirect_to kaui_engine.account_bundles_path(new_account.account_id), notice: 'Bundle was successfully transferred'
+    end
 
-  def restful_show
-    bundle = Kaui::Bundle.find_by_id_or_key(params.require(:id), options_for_klient)
-    redirect_to kaui_engine.account_bundles_path(bundle.account_id)
-  end
+    def restful_show
+      bundle = Kaui::Bundle.find_by_id_or_key(params.require(:id), options_for_klient)
+      redirect_to kaui_engine.account_bundles_path(bundle.account_id)
+    end
 
-  def pause_resume
-    @bundle = Kaui::Bundle.find_by_id_or_key(params.require(:id), options_for_klient)
-    @base_subscription = @bundle.subscriptions.find { |sub| sub.product_category == 'BASE' }
-  end
+    def pause_resume
+      @bundle = Kaui::Bundle.find_by_id_or_key(params.require(:id), options_for_klient)
+      @base_subscription = @bundle.subscriptions.find { |sub| sub.product_category == 'BASE' }
+    end
 
-  def do_pause_resume
-    bundle = Kaui::Bundle::new(:bundle_id => params.require(:id))
+    def do_pause_resume
+      bundle = Kaui::Bundle.new(bundle_id: params.require(:id))
 
-    paused = false
-    resumed = false
+      paused = false
+      resumed = false
 
-    if params[:pause_requested_date].present?
-      bundle.pause(params[:pause_requested_date], current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      paused = true
-    end
+      if params[:pause_requested_date].present?
+        bundle.pause(params[:pause_requested_date], current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+        paused = true
+      end
 
-    if params[:resume_requested_date].present?
-      bundle.resume(params[:resume_requested_date], current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      resumed = true
-    end
+      if params[:resume_requested_date].present?
+        bundle.resume(params[:resume_requested_date], current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+        resumed = true
+      end
 
-    msg = 'Bundle was successfully '
-    if paused && !resumed
-      msg += 'paused'
-    elsif !paused && resumed
-      msg += 'resumed'
-    else
-      msg += 'updated'
+      msg = 'Bundle was successfully '
+      msg += if paused && !resumed
+               'paused'
+             elsif !paused && resumed
+               'resumed'
+             else
+               'updated'
+             end
+      redirect_to kaui_engine.account_bundles_path(@account.account_id), notice: msg
     end
-    redirect_to kaui_engine.account_bundles_path(@account.account_id), :notice => msg
   end
 end

data/app/controllers/kaui/chargebacks_controller.rb

@@ -1,45 +1,48 @@
-class Kaui::ChargebacksController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def new
-    payment = Kaui::Payment::find_by_id(params.require(:payment_id), false, false, options_for_klient)
-    @chargeback = Kaui::Chargeback.new(:payment_id => payment.payment_id,
-                                       :amount => payment.paid_amount_to_money.to_f,
-                                       :currency => payment.currency)
-  end
-
-  def create
-    cached_options_for_klient = options_for_klient
+module Kaui
+  class ChargebacksController < Kaui::EngineController
+    def new
+      payment = Kaui::Payment.find_by_id(params.require(:payment_id), false, false, options_for_klient)
+      @chargeback = Kaui::Chargeback.new(payment_id: payment.payment_id,
+                                         amount: payment.paid_amount_to_money.to_f,
+                                         currency: payment.currency)
+    end
 
-    @chargeback = Kaui::Chargeback.new(params.require(:chargeback))
-    should_cancel_subs = (params[:cancel_all_subs] == '1')
+    def create
+      cached_options_for_klient = options_for_klient
 
-    begin
-      payment = @chargeback.chargeback(current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
-    rescue => e
-      flash.now[:error] = "Error while creating a new chargeback: #{as_string(e)}"
-      render :action => :new and return
-    end
+      @chargeback = Kaui::Chargeback.new(params.require(:chargeback))
+      should_cancel_subs = (params[:cancel_all_subs] == '1')
 
-    # Cancel all subscriptions on the account, if required
-    if should_cancel_subs
       begin
-        account = Kaui::Account.find_by_id(payment.account_id, false, false, cached_options_for_klient)
-        account.bundles(cached_options_for_klient).each do |bundle|
-          bundle.subscriptions.each do |subscription|
-            # Already cancelled?
-            next unless subscription.billing_end_date.blank?
+        payment = @chargeback.chargeback(current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
+      rescue StandardError => e
+        flash.now[:error] = "Error while creating a new chargeback: #{as_string(e)}"
+        render action: :new and return
+      end
+
+      # Cancel all subscriptions on the account, if required
+      if should_cancel_subs
+        begin
+          account = Kaui::Account.find_by_id(payment.account_id, false, false, cached_options_for_klient)
+          account.bundles(cached_options_for_klient).each do |bundle|
+            bundle.subscriptions.each do |subscription|
+              # Already cancelled?
+              next unless subscription.billing_end_date.blank?
 
-            # Cancel the entitlement immediately but use the default billing policy
-            entitlement = Kaui::Subscription.new(:subscription_id => subscription.subscription_id)
-            entitlement.cancel_entitlement_immediately(current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
+              # Cancel the entitlement immediately but use the default billing policy
+              entitlement = Kaui::Subscription.new(subscription_id: subscription.subscription_id)
+              entitlement.cancel_entitlement_immediately(current_user.kb_username, params[:reason], params[:comment], cached_options_for_klient)
+            end
           end
+        rescue StandardError => e
+          flash[:error] = "Error while cancelling subscriptions: #{as_string(e)}"
+          render action: :new and return
         end
-      rescue => e
-        flash[:error] = "Error while cancelling subscriptions: #{as_string(e)}"
-        render :action => :new and return
       end
-    end
 
-    redirect_to kaui_engine.account_payment_path(payment.account_id, payment.payment_id), :notice => 'Chargeback created'
+      redirect_to kaui_engine.account_payment_path(payment.account_id, payment.payment_id), notice: 'Chargeback created'
+    end
   end
 end

data/app/controllers/kaui/charges_controller.rb

@@ -1,28 +1,31 @@
-class Kaui::ChargesController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def new
-    invoice_id = params[:invoice_id]
-    amount = params[:amount]
+module Kaui
+  class ChargesController < Kaui::EngineController
+    def new
+      invoice_id = params[:invoice_id]
+      amount = params[:amount]
 
-    if invoice_id.present?
-      @invoice = Kaui::Invoice.find_by_id(invoice_id, 'NONE', options_for_klient)
-      amount ||= @invoice.balance
-      currency = @invoice.currency
-    else
-      @invoice = nil
-      currency = params[:currency] || 'USD'
-    end
+      if invoice_id.present?
+        @invoice = Kaui::Invoice.find_by_id(invoice_id, 'NONE', options_for_klient)
+        amount ||= @invoice.balance
+        currency = @invoice.currency
+      else
+        @invoice = nil
+        currency = params[:currency] || 'USD'
+      end
 
-    @charge = Kaui::InvoiceItem.new(:account_id => params.require(:account_id), :invoice_id => invoice_id, :amount => amount, :currency => currency)
-  end
+      @charge = Kaui::InvoiceItem.new(account_id: params.require(:account_id), invoice_id: invoice_id, amount: amount, currency: currency)
+    end
 
-  def create
-    charge = Kaui::InvoiceItem.new(params.require(:invoice_item).delete_if { |key, value| value.blank? })
-    charge.account_id ||= params.require(:account_id)
+    def create
+      charge = Kaui::InvoiceItem.new(params.require(:invoice_item).delete_if { |_key, value| value.blank? })
+      charge.account_id ||= params.require(:account_id)
 
-    auto_commit = params[:auto_commit] == '1'
+      auto_commit = params[:auto_commit] == '1'
 
-    charge = charge.create(auto_commit, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-    redirect_to kaui_engine.account_invoice_path(charge.account_id, charge.invoice_id), :notice => 'Charge was successfully created'
+      charge = charge.create(auto_commit, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.account_invoice_path(charge.account_id, charge.invoice_id), notice: 'Charge was successfully created'
+    end
   end
 end