kaui 2.1.0 → 2.2.1

data/app/helpers/kaui/us_states_helper.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module Kaui
   module UsStatesHelper
+    def all_us_states
+      us_states_yaml_file = File.join(File.dirname(__FILE__), 'us_states_helper.yml')
+      states = YAML.load_file(us_states_yaml_file)
 
-    def get_U_S_states
-        us_states_yaml_file = File.join(File.dirname(__FILE__), 'us_states_helper.yml')
-        states = YAML::load_file(us_states_yaml_file)
-
-        states.map { |state| [state[:state_name],state[:abbreviation]]}
+      states.map { |state| [state[:state_name], state[:abbreviation]] }
     end
   end
-end
+end

data/app/helpers/kaui/uuid_helper.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Kaui
   module UuidHelper
-
     def truncate_uuid(uuid)
       return uuid unless uuid =~ /[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}/
+
       split = uuid.split('-')
-      split[0] + '-...-' + split[4]
+      "#{split[0]}-...-#{split[4]}"
     end
     module_function :truncate_uuid
 
@@ -12,9 +14,9 @@ module Kaui
       content_tag(:span, truncate_uuid(object_id),
                   id: "#{object_id}-popover", class: 'object-id-popover', title: title,
                   data: {
-                      id: object_id,
-                      placement: placement,
-                  } )
+                    id: object_id,
+                    placement: placement
+                  })
     end
   end
 end

data/app/models/kaui/ability.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Kaui
   class Ability
     include CanCan::Ability
@@ -14,19 +16,28 @@ module Kaui
         # permission is something like invoice:item_adjust or payment:refund
         # We rely on a naming convention where the left part refers to a Kaui model
         model, action = permission_to_model_action(permission)
-        if model == '*' and action == '*'
+        if (model == '*') && (action == '*')
           # All permissions!
           can :manage, :all
-        elsif model == '*' and action != '*'
+        elsif (model == '*') && (action != '*')
           # TODO
         elsif action == '*'
-          # TODO Not sure the :all is really working (but we don't use it)
-          can :all, ('Kaui::' + model.camelize).constantize rescue nil
+          # TODO: Not sure the :all is really working (but we don't use it)
+          begin
+            can :all, "Kaui::#{model.camelize}".constantize
+          rescue StandardError
+            nil
+          end
         else
-          can action.to_sym, ('Kaui::' + model.camelize).constantize rescue nil
+          begin
+            can action.to_sym, "Kaui::#{model.camelize}".constantize
+          rescue StandardError
+            nil
+          end
         end
       end
-    rescue KillBillClient::API::Unauthorized => _
+    rescue KillBillClient::API::Unauthorized => _e
+      nil
     end
 
     def permission_to_model_action(permission)
@@ -39,12 +50,8 @@ module Kaui
       #
       to_be_model, action = permission.split(':')
       # Currently the only actions implemented for overdue and catalog (upload_config) are those implemented at the tenant level:
-      if %w(tenant overdue catalog).include?(to_be_model)
-        to_be_model = 'admin_tenant'
-      end
-      if to_be_model == 'entitlement'
-        to_be_model = 'subscription'
-      end
+      to_be_model = 'admin_tenant' if %w[tenant overdue catalog].include?(to_be_model)
+      to_be_model = 'subscription' if to_be_model == 'entitlement'
 
       [to_be_model, action]
     end

data/app/models/kaui/account.rb

@@ -1,40 +1,57 @@
-class Kaui::Account < KillBillClient::Model::Account
+# frozen_string_literal: true
 
-  def self.find_by_id_or_key(account_id_or_key, with_balance = false, with_balance_and_cba = false, options = {})
-    if account_id_or_key =~ /[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}/
-      begin
-        find_by_id(account_id_or_key, with_balance, with_balance_and_cba, options)
-      rescue => e
+module Kaui
+  class Account < KillBillClient::Model::Account
+    attr_accessor :phone, :bill_cycle_day_local
+
+    def check_account_details_phone
+      return true if phone =~ /\A(?:\+?\d{1,3}\s*-?)?\(?(?:\d{3})?\)?[- ]?\d{3}[- ]?\d{4}\z/i
+
+      false
+    end
+
+    def check_account_details_bill_cycle_day_local
+      return true if bill_cycle_day_local.to_i.between?(1, 31)
+
+      false
+    end
+
+    def self.find_by_id_or_key(account_id_or_key, with_balance, with_balance_and_cba, options = {})
+      if account_id_or_key =~ /[A-Fa-f0-9]{8}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{4}-[A-Fa-f0-9]{12}/
         begin
-          # account_id_or_key looked like an id, but maybe it's an external key (this will happen in tests)?
-          find_by_external_key(account_id_or_key, with_balance, with_balance_and_cba, options)
-        rescue => _
-          # Nope - raise the initial exception
-          raise e
+          find_by_id(account_id_or_key, with_balance, with_balance_and_cba, options)
+        rescue StandardError => e
+          begin
+            # account_id_or_key looked like an id, but maybe it's an external key (this will happen in tests)?
+            find_by_external_key(account_id_or_key, with_balance, with_balance_and_cba, options)
+          rescue StandardError => _
+            # Nope - raise the initial exception
+            raise e
+          end
         end
+      else
+        find_by_external_key(account_id_or_key, with_balance, with_balance_and_cba, options)
       end
-    else
-      find_by_external_key(account_id_or_key, with_balance, with_balance_and_cba, options)
     end
-  end
 
-  def self.list_or_search(search_key = nil, offset = 0, limit = 10, options = {})
-    if search_key.present?
-      find_in_batches_by_search_key(search_key, offset, limit, true, false, options)
-    else
-      find_in_batches(offset, limit, true, false, options)
+    def self.list_or_search(search_key = nil, offset = 0, limit = 10, options = {})
+      if search_key.present?
+        find_in_batches_by_search_key(search_key, offset, limit, true, false, options)
+      else
+        find_in_batches(offset, limit, true, false, options)
+      end
     end
-  end
 
-  def balance_to_money
-    Kaui::Base.to_money(account_balance.abs, currency)
-  end
+    def balance_to_money
+      Kaui::Base.to_money(account_balance.abs, currency)
+    end
 
-  def cba_to_money
-    Kaui::Base.to_money(account_cba.abs, currency)
-  end
+    def cba_to_money
+      Kaui::Base.to_money(account_cba.abs, currency)
+    end
 
-  def persisted?
-    !account_id.blank?
+    def persisted?
+      !account_id.blank?
+    end
   end
 end

data/app/models/kaui/account_email.rb

@@ -1,27 +1,30 @@
-class Kaui::AccountEmail < KillBillClient::Model::AccountEmailAttributes
+# frozen_string_literal: true
 
-  def self.find_all_sorted_by_account_id(account_id, audit = 'NONE', options = {})
-    emails = Kaui::Account.new(:account_id => account_id).emails(audit, options)
-    emails.map { |email| Kaui::AccountEmail.new(email.to_hash) }.sort
-  end
+module Kaui
+  class AccountEmail < KillBillClient::Model::AccountEmailAttributes
+    def self.find_all_sorted_by_account_id(account_id, audit = 'NONE', options = {})
+      emails = Kaui::Account.new(account_id: account_id).emails(audit, options)
+      emails.map { |email| Kaui::AccountEmail.new(email.to_hash) }.sort
+    end
 
-  def create(user = nil, reason = nil, comment = nil, options = {})
-    account = Kaui::Account.new(:account_id => account_id)
-    account.add_email(email, user, reason, comment, options)
-  end
+    def create(user = nil, reason = nil, comment = nil, options = {})
+      account = Kaui::Account.new(account_id: account_id)
+      account.add_email(email, user, reason, comment, options)
+    end
 
-  def destroy(user = nil, reason = nil, comment = nil, options = {})
-    account = Kaui::Account.new(:account_id => account_id)
-    account.remove_email(email, user, reason, comment, options)
-  end
+    def destroy(user = nil, reason = nil, comment = nil, options = {})
+      account = Kaui::Account.new(account_id: account_id)
+      account.remove_email(email, user, reason, comment, options)
+    end
 
-  def <=>(account_email)
-    if account_email.nil?
-      -1
-    elsif account_email.email.nil?
-      email.nil? ? 0 : 1
-    else
-      email.to_s <=> account_email.email.to_s
+    def <=>(other)
+      if other.nil?
+        -1
+      elsif other.email.nil?
+        email.nil? ? 0 : 1
+      else
+        email.to_s <=> other.email.to_s
+      end
     end
   end
 end

data/app/models/kaui/account_timeline.rb

@@ -1,2 +1,6 @@
-class Kaui::AccountTimeline < KillBillClient::Model::AccountTimeline
+# frozen_string_literal: true
+
+module Kaui
+  class AccountTimeline < KillBillClient::Model::AccountTimeline
+  end
 end

data/app/models/kaui/admin.rb

@@ -1,80 +1,81 @@
-class Kaui::Admin < KillBillClient::Model::Resource
+# frozen_string_literal: true
 
-  KILLBILL_API_ADMIN_PREFIX = "#{KILLBILL_API_PREFIX}/admin"
-  KILLBILL_API_QUEUES_PREFIX = "#{KILLBILL_API_ADMIN_PREFIX}/queues"
+module Kaui
+  class Admin < KillBillClient::Model::Resource
+    KILLBILL_API_ADMIN_PREFIX = "#{KILLBILL_API_PREFIX}/admin".freeze
+    KILLBILL_API_QUEUES_PREFIX = "#{KILLBILL_API_ADMIN_PREFIX}/queues".freeze
 
-  KILLBILL_API_CLOCK_PREFIX = "#{KILLBILL_API_PREFIX}/test/clock"
+    KILLBILL_API_CLOCK_PREFIX = "#{KILLBILL_API_PREFIX}/test/clock".freeze
 
-  class << self
+    class << self
+      def get_queues_entries(account_id, options = {})
+        res = KillBillClient::API.get KILLBILL_API_QUEUES_PREFIX,
+                                      {
+                                        accountId: account_id,
+                                        withHistory: options[:withHistory],
+                                        minDate: options[:minDate],
+                                        maxDate: options[:maxDate]
+                                      },
+                                      {
+                                        accept: 'application/octet-stream'
+                                      }.merge(options)
+        JSON.parse res.body
+      end
 
-    def get_queues_entries(account_id, options = {})
-      res = KillBillClient::API.get KILLBILL_API_QUEUES_PREFIX,
-                                    {
-                                        :accountId => account_id,
-                                        :withHistory => options[:withHistory],
-                                        :minDate => options[:minDate],
-                                        :maxDate => options[:maxDate]
-                                    },
-                                    {
-                                        :accept => 'application/octet-stream'
-                                    }.merge(options)
-      JSON.parse res.body
-    end
-
-    def fix_transaction_state(payment_id, transaction_id, transaction_status, user = nil, reason = nil, comment = nil, options = {})
-      KillBillClient::API.put "#{KILLBILL_API_ADMIN_PREFIX}/payments/#{payment_id}/transactions/#{transaction_id}",
-                              {:transactionStatus => transaction_status}.to_json,
-                              {},
-                              {
-                                  :user => user,
-                                  :reason => reason,
-                                  :comment => comment,
-                              }.merge(options)
-    end
+      def fix_transaction_state(payment_id, transaction_id, transaction_status, user = nil, reason = nil, comment = nil, options = {})
+        KillBillClient::API.put "#{KILLBILL_API_ADMIN_PREFIX}/payments/#{payment_id}/transactions/#{transaction_id}",
+                                { transactionStatus: transaction_status }.to_json,
+                                {},
+                                {
+                                  user: user,
+                                  reason: reason,
+                                  comment: comment
+                                }.merge(options)
+      end
 
-    def get_clock(time_zone, options)
-      params = {}
-      params[:timeZone] = time_zone unless time_zone.nil?
+      def get_clock(time_zone, options)
+        params = {}
+        params[:timeZone] = time_zone unless time_zone.nil?
 
-      res = KillBillClient::API.get KILLBILL_API_CLOCK_PREFIX,
-                                    params,
-                                    options
-      JSON.parse res.body
-    end
+        res = KillBillClient::API.get KILLBILL_API_CLOCK_PREFIX,
+                                      params,
+                                      options
+        JSON.parse res.body
+      end
 
-    def set_clock(requested_date, time_zone, options)
-      params = {}
-      params[:requestedDate] = requested_date unless requested_date.nil?
-      params[:timeZone] = time_zone unless time_zone.nil?
+      def set_clock(requested_date, time_zone, options)
+        params = {}
+        params[:requestedDate] = requested_date unless requested_date.nil?
+        params[:timeZone] = time_zone unless time_zone.nil?
 
-      # The default 5s is not always enough
-      params[:timeoutSec] ||= 10
+        # The default 5s is not always enough
+        params[:timeoutSec] ||= 10
 
-      res = KillBillClient::API.post KILLBILL_API_CLOCK_PREFIX,
-                                     {},
-                                     params,
-                                     {}.merge(options)
-      JSON.parse res.body
-    end
+        res = KillBillClient::API.post KILLBILL_API_CLOCK_PREFIX,
+                                       {},
+                                       params,
+                                       {}.merge(options)
+        JSON.parse res.body
+      end
 
-    def increment_kb_clock(days, weeks, months, years, time_zone, options)
-      params = {}
-      params[:days] = days unless days.nil?
-      params[:weeks] = weeks unless weeks.nil?
-      params[:months] = months unless months.nil?
-      params[:years] = years unless years.nil?
-      params[:timeZone] = time_zone unless time_zone.nil?
+      def increment_kb_clock(days, weeks, months, years, time_zone, options)
+        params = {}
+        params[:days] = days unless days.nil?
+        params[:weeks] = weeks unless weeks.nil?
+        params[:months] = months unless months.nil?
+        params[:years] = years unless years.nil?
+        params[:timeZone] = time_zone unless time_zone.nil?
 
-      # The default 5s is not always enough
-      params[:timeoutSec] ||= 10
+        # The default 5s is not always enough
+        params[:timeoutSec] ||= 10
 
-      res = KillBillClient::API.put KILLBILL_API_CLOCK_PREFIX,
-                                    {},
-                                    params,
-                                    {}.merge(options)
+        res = KillBillClient::API.put KILLBILL_API_CLOCK_PREFIX,
+                                      {},
+                                      params,
+                                      {}.merge(options)
 
-      JSON.parse res.body
+        JSON.parse res.body
+      end
     end
-
   end
 end

data/app/models/kaui/admin_tenant.rb

@@ -1,109 +1,108 @@
-class Kaui::AdminTenant < KillBillClient::Model::Tenant
+# frozen_string_literal: true
 
+module Kaui
+  class AdminTenant < KillBillClient::Model::Tenant
+    class << self
+      def upload_catalog(catalog_xml, user = nil, reason = nil, comment = nil, options = {})
+        KillBillClient::Model::Catalog.upload_tenant_catalog(catalog_xml, user, reason, comment, options)
+      end
 
-  class << self
-    def upload_catalog(catalog_xml, user = nil, reason = nil, comment = nil, options = {})
-      KillBillClient::Model::Catalog.upload_tenant_catalog(catalog_xml, user, reason, comment, options)
-    end
-
-    def upload_overdue_config(overdue_config_xml, user = nil, reason = nil, comment = nil, options = {})
-      KillBillClient::Model::Overdue.upload_tenant_overdue_config_xml(overdue_config_xml, user, reason, comment, options)
-    end
-
-    def upload_invoice_template(invoice_template, is_manual_pay, delete_if_exists, user = nil, reason = nil, comment = nil, options = {})
-      KillBillClient::Model::Invoice.upload_invoice_template(invoice_template, is_manual_pay, delete_if_exists, user, reason, comment, options)
-    end
+      def upload_overdue_config(overdue_config_xml, user = nil, reason = nil, comment = nil, options = {})
+        KillBillClient::Model::Overdue.upload_tenant_overdue_config_xml(overdue_config_xml, user, reason, comment, options)
+      end
 
-    def upload_invoice_translation(invoice_translation, locale, delete_if_exists, user = nil, reason = nil, comment = nil, options = {})
-      KillBillClient::Model::Invoice.upload_invoice_translation(invoice_translation, locale, delete_if_exists, user, reason, comment, options)
-    end
+      def upload_invoice_template(invoice_template, is_manual_pay, delete_if_exists, user = nil, reason = nil, comment = nil, options = {})
+        KillBillClient::Model::Invoice.upload_invoice_template(invoice_template, is_manual_pay, delete_if_exists, user, reason, comment, options)
+      end
 
-    def upload_catalog_translation(catalog_translation, locale, delete_if_exists, user = nil, reason = nil, comment = nil, options = {})
-      KillBillClient::Model::Invoice.upload_catalog_translation(catalog_translation, locale, delete_if_exists, user, reason, comment, options)
-    end
+      def upload_invoice_translation(invoice_translation, locale, delete_if_exists, user = nil, reason = nil, comment = nil, options = {})
+        KillBillClient::Model::Invoice.upload_invoice_translation(invoice_translation, locale, delete_if_exists, user, reason, comment, options)
+      end
 
-    def upload_tenant_plugin_config(plugin_name, plugin_config, user = nil, reason = nil, comment = nil, options = {})
-      KillBillClient::Model::Tenant.upload_tenant_plugin_config(plugin_name, plugin_config, user, reason, comment, options)
-    end
+      def upload_catalog_translation(catalog_translation, locale, delete_if_exists, user = nil, reason = nil, comment = nil, options = {})
+        KillBillClient::Model::Invoice.upload_catalog_translation(catalog_translation, locale, delete_if_exists, user, reason, comment, options)
+      end
 
-    # Return a map of plugin_name => config
-    def get_tenant_plugin_config(options)
-      raw_tenant_config = KillBillClient::Model::Tenant::search_tenant_config("PLUGIN_CONFIG_", options)
+      def upload_tenant_plugin_config(plugin_name, plugin_config, user = nil, reason = nil, comment = nil, options = {})
+        KillBillClient::Model::Tenant.upload_tenant_plugin_config(plugin_name, plugin_config, user, reason, comment, options)
+      end
 
-      tenant_config = raw_tenant_config.inject({}) do |hsh, e|
-        # Strip prefix '/PLUGIN_CONFIG_'
-        plugin_name = e.key.gsub!(/PLUGIN_CONFIG_/, '')
+      # Return a map of plugin_name => config
+      def get_tenant_plugin_config(options)
+        raw_tenant_config = KillBillClient::Model::Tenant.search_tenant_config('PLUGIN_CONFIG_', options)
 
-        # Construct simple hash with one property (first value)
-        hsh[plugin_name] = e.values[0]
+        raw_tenant_config.each_with_object({}) do |e, hsh|
+          # Strip prefix '/PLUGIN_CONFIG_'
+          plugin_name = e.key.gsub!(/PLUGIN_CONFIG_/, '')
 
-        hsh
+          # Construct simple hash with one property (first value)
+          hsh[plugin_name] = e.values[0]
+        end
       end
 
-      tenant_config
-    end
-
-    def format_plugin_config(plugin_key, plugin_type, props)
-      return nil unless props.present?
-      return props['raw_config'].gsub(/\r\n?/, "\n") if props['raw_config']
-
-      if plugin_type == 'ruby'
-        require 'yaml'
-        props = reformat_plugin_config(plugin_type, props)
-        hsh = {}
-        hsh[plugin_key.to_sym] = {}
-        props.each do |k,v|
-          hsh[plugin_key.to_sym][k.to_sym] = v
+      def format_plugin_config(plugin_key, plugin_type, props)
+        return nil unless props.present?
+        return props['raw_config'].gsub(/\r\n?/, "\n") if props['raw_config']
+
+        if plugin_type == 'ruby'
+          require 'yaml'
+          props = reformat_plugin_config(plugin_type, props)
+          hsh = {}
+          hsh[plugin_key.to_sym] = {}
+          props.each do |k, v|
+            hsh[plugin_key.to_sym][k.to_sym] = v
+          end
+          hsh.to_yaml
+        elsif plugin_type == 'java'
+          props = reformat_plugin_config(plugin_type, props)
+          res = ''
+          props.each do |k, v|
+            res = "#{res}#{k}=#{v}\n"
+          end
+          res
+        else
+          props['raw_config']
         end
-        hsh.to_yaml
-      elsif plugin_type == 'java'
-        props = reformat_plugin_config(plugin_type, props)
-        res = ""
-        props.each do |k, v|
-          res = "#{res}#{k.to_s}=#{v.to_s}\n"
-        end
-        res
-      else
-        props['raw_config']
       end
-    end
 
-    def reformat_plugin_config(plugin_type, props)
-      unless props['raw_config'].blank?
-        new_props = {}
-        props['raw_config'].split("\n").each do |p|
-          line = p.split('=')
-          new_props[line[0]] = line[1].blank? ? '' : line[1].delete("\r")
+      def reformat_plugin_config(_plugin_type, props)
+        unless props['raw_config'].blank?
+          new_props = {}
+          props['raw_config'].split("\n").each do |p|
+            line = p.split('=')
+            new_props[line[0]] = line[1].blank? ? '' : line[1].delete("\r")
+          end
+
+          return new_props
         end
 
-        return new_props
+        props
       end
 
-      props
-    end
+      # checks if string could be parse as yaml
+      def yaml?(candidate_string)
+        is_yaml = false
+        return is_yaml if candidate_string.blank?
 
-    # checks if string could be parse as yaml
-    def is_yaml?(candidate_string)
-      is_yaml = false
-      return is_yaml if candidate_string.blank?
+        begin
+          is_yaml = !YAML.load(candidate_string).nil?
+          is_yaml &&= YAML.load(candidate_string).instance_of?(Hash)
+        rescue StandardError
+          is_yaml = false
+        end
 
-      begin
-        is_yaml = !!YAML::load(candidate_string)
-        is_yaml = is_yaml && YAML.load(candidate_string).instance_of?(Hash)
-      rescue
-        is_yaml = false
+        is_yaml
       end
 
-      is_yaml
-    end
+      # checks if string could be parse as key value pair
+      def kv?(candidate_string)
+        return false if candidate_string.blank? || yaml?(candidate_string)
 
-    # checks if string could be parse as key value pair
-    def is_kv?(candidate_string)
-      return false if candidate_string.blank? || is_yaml?(candidate_string)
-      lines = candidate_string.split("\n")
-      return false if lines.blank?
+        lines = candidate_string.split("\n")
+        return false if lines.blank?
 
-      lines.all? { |kv| kv.split('=').count >= 1 }
+        lines.all? { |kv| kv.split('=').count >= 1 }
+      end
     end
   end
 end

data/app/models/kaui/allowed_user.rb

@@ -1,13 +1,14 @@
+# frozen_string_literal: true
+
 module Kaui
   class AllowedUser < ApplicationRecord
-
     has_many :kaui_allowed_user_tenants,
-             :class_name => 'Kaui::AllowedUserTenant',
-             :foreign_key => 'kaui_allowed_user_id'
+             class_name: 'Kaui::AllowedUserTenant',
+             foreign_key: 'kaui_allowed_user_id'
 
     has_many :kaui_tenants, -> { distinct },
-             :through => :kaui_allowed_user_tenants,
-             :source => :kaui_tenant
+             through: :kaui_allowed_user_tenants,
+             source: :kaui_tenant
 
     # Create the user locally and in Kill Bill (if needed)
     def create_in_kb!(password, roles = [], user = nil, reason = nil, comment = nil, options = {})
@@ -20,8 +21,12 @@ module Kaui
       begin
         kb_user.create(user, reason, comment, options)
       rescue KillBillClient::API::BadRequest => e
-        error_code = JSON.parse(e.response.body)['code'] rescue nil
-        raise e unless error_code == 40002 # SECURITY_USER_ALREADY_EXISTS
+        error_code = begin
+          JSON.parse(e.response.body)['code']
+        rescue StandardError
+          nil
+        end
+        raise e unless error_code == 40_002 # SECURITY_USER_ALREADY_EXISTS
       end
 
       # Save locally
@@ -30,7 +35,6 @@ module Kaui
 
     # Update the user locally and in Kill Bill (if needed)
     def update_in_kb!(password, roles, user = nil, reason = nil, comment = nil, options = {})
-
       user_role = KillBillClient::Model::UserRoles.new
       user_role.username = kb_username
 
@@ -55,7 +59,7 @@ module Kaui
 
       begin
         user_role.destroy(user, reason, comment, options)
-      rescue KillBillClient::API::BadRequest => _
+      rescue KillBillClient::API::BadRequest => _e
         # User already deactivated in Kill Bill
       end
 

data/app/models/kaui/allowed_user_tenant.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Kaui
   class AllowedUserTenant < ApplicationRecord
-    belongs_to :kaui_allowed_user, :class_name => 'Kaui::AllowedUser', :foreign_key => 'kaui_allowed_user_id'
-    belongs_to :kaui_tenant, :class_name => 'Kaui::Tenant', :foreign_key => 'kaui_tenant_id'
+    belongs_to :kaui_allowed_user, class_name: 'Kaui::AllowedUser', foreign_key: 'kaui_allowed_user_id'
+    belongs_to :kaui_tenant, class_name: 'Kaui::Tenant', foreign_key: 'kaui_tenant_id'
   end
 end