kaui 2.1.0 → 3.0.1

data/app/controllers/kaui/credits_controller.rb

@@ -1,35 +1,38 @@
-class Kaui::CreditsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def new
-    invoice_id = params[:invoice_id]
-    amount = params[:amount]
+module Kaui
+  class CreditsController < 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
 
-    @credit = Kaui::Credit.new(:account_id => params.require(:account_id), :invoice_id => invoice_id, :amount => amount, :currency => currency)
-  end
+      @credit = Kaui::Credit.new(account_id: params.require(:account_id), invoice_id:, amount:, currency:)
+    end
 
-  def create
-    credit = Kaui::Credit.new(params[:credit].delete_if { |key, value| value.blank? })
-    credit.account_id ||= params.require(:account_id)
+    def create
+      credit = Kaui::Credit.new(params[:credit].delete_if { |_key, value| value.blank? })
+      credit.account_id ||= params.require(:account_id)
 
-    # No need to show the newly created invoice for account level credits
-    should_redirect_to_invoice = credit.invoice_id.present?
+      # No need to show the newly created invoice for account level credits
+      should_redirect_to_invoice = credit.invoice_id.present?
 
-    credits = credit.create(true, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-    flash[:notice] = 'Credit was successfully created'
+      credits = credit.create(true, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      flash[:notice] = 'Credit was successfully created'
 
-    if should_redirect_to_invoice
-      redirect_to kaui_engine.account_invoice_path(credits[0].account_id, credits[0].invoice_id)
-    else
-      redirect_to kaui_engine.account_path(credits[0].account_id)
+      if should_redirect_to_invoice
+        redirect_to kaui_engine.account_invoice_path(credits[0].account_id, credits[0].invoice_id)
+      else
+        redirect_to kaui_engine.account_path(credits[0].account_id)
+      end
     end
   end
 end

data/app/controllers/kaui/custom_fields_controller.rb

@@ -1,68 +1,202 @@
-class Kaui::CustomFieldsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def index
-    @search_query = params[:q]
+module Kaui
+  class CustomFieldsController < Kaui::EngineController
+    def index
+      @search_query = params[:q]
 
-    @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::CustomField.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
-  end
-
-  def pagination
-    searcher = lambda do |search_key, offset, limit|
-      Kaui::CustomField.list_or_search(search_key, offset, limit, options_for_klient)
+      @max_nb_records = @search_query.blank? ? Kaui::CustomField.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
     end
 
-    data_extractor = lambda do |custom_field, column|
-      [
+    def pagination
+      searcher = lambda do |search_key, offset, limit|
+        Kaui::CustomField.list_or_search(search_key, offset, limit, options_for_klient)
+      end
+
+      data_extractor = lambda do |custom_field, column|
+        [
           custom_field.object_id,
           custom_field.object_type,
           custom_field.name,
           custom_field.value
-      ][column]
-    end
+        ][column]
+      end
 
-    formatter = lambda do |custom_field|
-      url_for_object = view_context.url_for_object(custom_field.object_id, custom_field.object_type)
-      [
+      formatter = lambda do |custom_field|
+        url_for_object = view_context.url_for_object(custom_field.object_id, custom_field.object_type)
+        [
           url_for_object ? view_context.link_to(custom_field.object_id, url_for_object) : custom_field.object_id,
           custom_field.object_type,
           custom_field.name,
           custom_field.value
-      ]
+        ]
+      end
+
+      paginate searcher, data_extractor, formatter
     end
 
-    paginate searcher, data_extractor, formatter
-  end
+    def new
+      @custom_field = Kaui::CustomField.new
+    end
 
-  def new
-    @custom_field = Kaui::CustomField.new
-  end
+    def check_object_exist
+      param_uuid = params[:uuid]
+      param_object_type = params[:object_type]
+
+      _check_object_exist(param_uuid, param_object_type)
+    end
 
-  def create
-    @custom_field = Kaui::CustomField.new(params.require(:custom_field))
+    def create
+      @custom_field = Kaui::CustomField.new(params.require(:custom_field))
 
-    model = case @custom_field.object_type.to_sym
+      param_uuid = @custom_field.object_id
+
+      test_uuid = nil
+      case @custom_field.object_type.to_sym
+      when :ACCOUNT
+        begin
+          test_uuid = Kaui::Account.find_by_id_or_key(param_uuid, false, false, options_for_klient)
+        rescue StandardError
+          # Ignore
+        end
+      when :BUNDLE
+        begin
+          test_uuid = Kaui::Bundle.find_by_id_or_key(param_uuid, options_for_klient)
+        rescue StandardError
+          # Ignore
+        end
+      when :SUBSCRIPTION
+        begin
+          test_uuid = Kaui::Subscription.find_by_id(param_uuid, options_for_klient)
+        rescue StandardError
+          # Ignore
+        end
+      when :INVOICE
+        begin
+          test_uuid = Kaui::Invoice.find_by_id(param_uuid, false, 'NONE', options_for_klient)
+        rescue StandardError
+          # Ignore
+        end
+      when :PAYMENT
+        begin
+          test_uuid = Kaui::InvoicePayment.find_by_id(param_uuid, false, true, options_for_klient)
+        rescue StandardError
+          # Ignore
+        end
+        begin
+          test_uuid = Kaui::Payment.find_by_external_key(param_uuid, false, true, options_for_klient)
+        rescue StandardError
+          # Ignore
+        end
+      when :INVOICE_ITEM
+        begin
+          test_uuid = Kaui::Invoice.find_by_invoice_item_id(param_uuid, false, 'NONE', options_for_klient)
+        rescue StandardError
+          # Ignore
+        end
+      end
+
+      if test_uuid.blank?
+        flash[:error] = I18n.translate('object_invalid_dont_exist')
+        redirect_to custom_fields_path
+        return
+      end
+
+      model = case @custom_field.object_type.to_sym
               when :ACCOUNT
-                Kaui::Account.new(:account_id => @custom_field.object_id)
+                Kaui::Account.new(account_id: @custom_field.object_id)
               when :BUNDLE
-                Kaui::Bundle.new(:bundle_id => @custom_field.object_id)
+                Kaui::Bundle.new(bundle_id: @custom_field.object_id)
               when :SUBSCRIPTION
-                Kaui::Subscription.new(:subscription_id => @custom_field.object_id)
+                Kaui::Subscription.new(subscription_id: @custom_field.object_id)
               when :INVOICE
-                Kaui::Invoice.new(:invoice_id => @custom_field.object_id)
+                Kaui::Invoice.new(invoice_id: @custom_field.object_id)
               when :PAYMENT
-                Kaui::Payment.new(:payment_id => @custom_field.object_id)
+                Kaui::Payment.new(payment_id: @custom_field.object_id)
               when :INVOICE_ITEM
-                Kaui::InvoiceItem.new(:invoice_item_id => @custom_field.object_id)
+                Kaui::InvoiceItem.new(invoice_item_id: @custom_field.object_id)
               else
-                flash.now[:error] = "Invalid object type #{@custom_field.object_type}"
+                flash.now[:error] = I18n.translate('invalid_object_type', error: @custom_field.object_type)
                 render :new and return
-            end
-    model.add_custom_field(@custom_field, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+              end
+      model.add_custom_field(@custom_field, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+
+      redirect_to custom_fields_path, notice: I18n.translate('custom_field_created_success')
+    end
 
-    redirect_to custom_fields_path, :notice => 'Custom field was successfully created'
+    private
+
+    def _check_object_exist(uuid, object_type)
+      param_uuid = uuid
+      param_object_type = object_type
+
+      test_uuid = nil
+      msg = nil
+      case param_object_type
+      when  'INVOICE_ITEM'
+        begin
+          test_uuid = Kaui::Invoice.find_by_invoice_item_id(param_uuid, false, 'NONE', options_for_klient)
+        rescue StandardError
+          # Ignore
+        ensure
+          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_invoice_item_db') } unless test_uuid.blank?
+        end
+      when  'ACCOUNT'
+        begin
+          test_uuid = Kaui::Account.find_by_id_or_key(param_uuid, false, false, options_for_klient)
+        rescue StandardError
+          # Ignore
+        ensure
+          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_account_db') } if !test_uuid.blank? && (test_uuid.account_id == param_uuid)
+        end
+      when  'BUNDLE'
+        begin
+          test_uuid = Kaui::Bundle.find_by_id_or_key(param_uuid, options_for_klient)
+        rescue StandardError
+          # Ignore
+        ensure
+          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_bundle_db') } if !test_uuid.blank? && (test_uuid.bundle_id == param_uuid)
+        end
+      when  'SUBSCRIPTION'
+        begin
+          test_uuid = Kaui::Subscription.find_by_id(param_uuid, options_for_klient)
+        rescue StandardError
+          # Ignore
+        ensure
+          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_subscription_db') } if !test_uuid.blank? && (test_uuid.subscription_id == param_uuid)
+        end
+      when  'INVOICE'
+        begin
+          cached_options_for_klient = options_for_klient
+          test_uuid = Kaui::Invoice.find_by_id(param_uuid, 'FULL', cached_options_for_klient)
+        rescue StandardError
+          # Ignore
+        ensure
+          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_invoice_db') } if !test_uuid.blank? && (test_uuid.invoice_id == param_uuid)
+        end
+      when  'PAYMENT'
+        begin
+          test_uuid = Kaui::InvoicePayment.find_by_id(param_uuid, false, true, options_for_klient)
+        rescue StandardError
+          # Ignore
+        ensure
+          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_invoice_payment_db') } if !test_uuid.blank? && (test_uuid.payment_id == param_uuid)
+        end
+        begin
+          test_uuid = Kaui::Payment.find_by_external_key(param_uuid, false, true, options_for_klient)
+        rescue StandardError
+          # Ignore
+        ensure
+          msg = { status: '200', message: I18n.translate('custom_field_uuid_exist_in_payment_db') } if !test_uuid.blank? && (test_uuid.payment_id == param_uuid)
+        end
+      end
+
+      msg ||= { status: '431', message: I18n.translate('custom_field_uuid_do_not_exist_in_db') }
+      render json: msg
+    end
   end
 end

data/app/controllers/kaui/engine_controller.rb

@@ -21,13 +21,14 @@ class Kaui::EngineController < ApplicationController
     super
   end
 
+  # Called lazily by the can? helper
   def current_ability
     # Redefined here to namespace Ability in the correct module
     @current_ability ||= Kaui::Ability.new(current_user)
   end
 
   def check_for_redirect_to_tenant_screen
-    unless Kaui.is_user_assigned_valid_tenant?(current_user, session)
+    unless Kaui.user_assigned_valid_tenant?(current_user, session)
       session[:kb_tenant_id] = nil
       redirect_to Kaui.tenant_home_path.call
     end

data/app/controllers/kaui/engine_controller_util.rb

@@ -1,144 +1,155 @@
-module Kaui::EngineControllerUtil
+# frozen_string_literal: true
 
-  # See DefaultPaginationSqlDaoHelper.java
-  SIMPLE_PAGINATION_THRESHOLD = 20000
+module Kaui
+  module EngineControllerUtil
+    # See DefaultPaginationSqlDaoHelper.java
+    SIMPLE_PAGINATION_THRESHOLD = 20_000
 
-  protected
+    protected
 
-  def get_layout
-    layout ||= Kaui.config[:layout]
-  end
-
-  def paginate(searcher, data_extractor, formatter)
-    search_key = (params[:search] || {})[:value].presence
-    offset = (params[:start] || 0).to_i
-    limit = (params[:length] || 10).to_i
-
-    limit = -limit if params[:ordering] == 'desc'
-    begin
-      pages = searcher.call(search_key, offset, limit)
-    rescue => e
-      error = e.to_s
+    # rubocop:disable Lint/UselessAssignment, Naming/AccessorMethodName
+    def get_layout
+      layout ||= Kaui.config[:layout]
     end
+    # rubocop:enable Lint/UselessAssignment, Naming/AccessorMethodName
+
+    def paginate(searcher, data_extractor, formatter)
+      search_key = (params[:search] || {})[:value].presence
+      offset = (params[:start] || 0).to_i
+      limit = (params[:length] || 10).to_i
+
+      limit = -limit if params[:ordering] == 'desc'
+      begin
+        pages = searcher.call(search_key, offset, limit)
+      rescue StandardError => e
+        error = e.to_s
+      end
 
-    json = {
-        :draw => (params[:draw] || 0).to_i,
+      json = {
+        draw: (params[:draw] || 0).to_i,
         # We need to fill-in a number to make DataTables happy
-        :recordsTotal => pages.nil? ? 0 : (pages.pagination_max_nb_records || SIMPLE_PAGINATION_THRESHOLD),
-        :recordsFiltered => pages.nil? ? 0 : (pages.pagination_total_nb_records || SIMPLE_PAGINATION_THRESHOLD),
-        :data => []
-    }
-    json[:error] = error unless error.nil?
-
-    pages ||= []
-
-    # Until we support server-side sorting
-    ordering = ((params[:order] || {})[:'0'] || {})
-    ordering_column = (ordering[:column] || 0).to_i
-    ordering_dir = ordering[:dir] || 'asc'
-    pages.sort! do |a, b|
-      a = data_extractor.call(a, ordering_column)
-      b = data_extractor.call(b, ordering_column)
-      sort = a <=> b
-      sort.nil? ? -1 : sort
-    end unless search_key.nil? # Keep DB ordering when listing all entries (note! make sure to set "ordering": false in DataTables config as the client-side sort behavior can be confusing)
-    pages.reverse! if ordering_dir == 'desc' && limit >= 0 || ordering_dir == 'asc' && limit < 0
-
-    pages.each { |page| json[:data] << formatter.call(page) }
-
-    respond_to do |format|
-      format.json { render :json => json }
+        recordsTotal: pages.nil? ? 0 : (pages.pagination_max_nb_records || SIMPLE_PAGINATION_THRESHOLD),
+        recordsFiltered: pages.nil? ? 0 : (pages.pagination_total_nb_records || SIMPLE_PAGINATION_THRESHOLD),
+        data: []
+      }
+      json[:error] = error unless error.nil?
+
+      pages ||= []
+
+      # Until we support server-side sorting
+      ordering = ((params[:order] || {})[:'0'] || {})
+      ordering_column = (ordering[:column] || 0).to_i
+      ordering_dir = ordering[:dir] || 'asc'
+      unless search_key.nil?
+        pages.sort! do |a, b|
+          a = data_extractor.call(a, ordering_column)
+          b = data_extractor.call(b, ordering_column)
+          sort = a <=> b
+          sort.nil? ? -1 : sort
+        end
+      end
+      pages.reverse! if (ordering_dir == 'desc' && limit >= 0) || (ordering_dir == 'asc' && limit.negative?)
+
+      pages.each { |page| json[:data] << formatter.call(page) }
+
+      respond_to do |format|
+        format.json { render json: }
+      end
     end
-  end
 
-  def promise
-    # Evaluation starts immediately
-    ::Concurrent::Promises.future do
-      # https://github.com/rails/rails/issues/26847
-      Rails.application.executor.wrap do
-        yield
+    def promise(&)
+      # Evaluation starts immediately
+      ::Concurrent::Promises.future do
+        # https://github.com/rails/rails/issues/26847
+        Rails.application.executor.wrap(&)
       end
     end
-  end
 
-  def wait(promise)
-    # https://github.com/rails/rails/issues/26847
-    ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-      # Make sure to set a timeout to avoid infinite wait
-      value = promise.value!(60)
-      raise promise.reason unless promise.reason.nil?
-      if value.nil? && promise.state != :fulfilled
-        # Could be https://github.com/ruby-concurrency/concurrent-ruby/issues/585
-        Rails.logger.warn("Unable to run promise #{promise_as_string(promise)}")
-        raise Timeout::Error
+    def wait(promise)
+      # https://github.com/rails/rails/issues/26847
+      ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+        # Make sure to set a timeout to avoid infinite wait
+        value = promise.value!(60)
+        raise promise.reason unless promise.reason.nil?
+
+        if value.nil? && promise.state != :fulfilled
+          # Could be https://github.com/ruby-concurrency/concurrent-ruby/issues/585
+          Rails.logger.warn("Unable to run promise #{promise_as_string(promise)}")
+          raise Timeout::Error
+        end
+        value
       end
-      value
     end
-  end
 
-  def promise_as_string(promise)
-    return 'nil' if promise.nil?
-    executor = promise.instance_variable_get('@executor')
-    executor_as_string = "queue_length=#{executor.queue_length}, pool_size=#{executor.length}"
-    "#{promise.instance_variable_get('@promise_body')}[state=#{promise.state}, parent=#{promise_as_string(promise.instance_variable_get('@parent'))}, executor=[#{executor_as_string}]]"
-  end
+    def promise_as_string(promise)
+      return 'nil' if promise.nil?
 
-  # Used to format flash error messages
-  def as_string(e)
-    if e.is_a?(KillBillClient::API::ResponseError)
-      as_string_from_response(e.response.body)
-    elsif e.respond_to?(:cause) && !e.cause.nil?
-      as_string(e.cause)
-    else
-      log_rescue_error(e)
-      e.message
+      executor = promise.instance_variable_get('@executor')
+      executor_as_string = "queue_length=#{executor.queue_length}, pool_size=#{executor.length}"
+      "#{promise.instance_variable_get('@promise_body')}[state=#{promise.state}, parent=#{promise_as_string(promise.instance_variable_get('@parent'))}, executor=[#{executor_as_string}]]"
     end
-  end
 
-  def log_rescue_error(error)
-    Rails.logger.warn "#{error.class} #{error.to_s}. #{error.backtrace.join("\n")}"
-  end
+    # Used to format flash error messages
+    def as_string(exception)
+      if exception.is_a?(KillBillClient::API::ResponseError)
+        as_string_from_response(exception.response.body)
+      elsif exception.is_a?(ActionController::ParameterMissing)
+        # e.message contains corrections, which we don't want
+        "missing parameter #{exception.param}"
+      elsif exception.respond_to?(:cause) && !exception.cause.nil?
+        as_string(exception.cause)
+      else
+        log_rescue_error(exception)
+        exception.message
+      end
+    end
 
-  def as_string_from_response(response)
-    error_message = response
-    begin
-      # BillingExceptionJson?
-      error_message = JSON.parse response
-    rescue => _
+    def log_rescue_error(error)
+      Rails.logger.warn "#{error.class} #{error}. #{error.backtrace.join("\n")}"
     end
 
-    if error_message.respond_to? :[] and error_message['message'].present?
-      # Likely BillingExceptionJson
-      error_message = error_message['message']
-      error_message += " (code=#{error_message['code']})" unless error_message['code'].blank?
+    def as_string_from_response(response)
+      error_message = response
+      begin
+        # BillingExceptionJson?
+        error_message = JSON.parse response
+      rescue StandardError => _e
+        # Ignore
+      end
+
+      if error_message.respond_to?(:[]) && error_message['message'].present?
+        # Likely BillingExceptionJson
+        error_message = error_message['message']
+        error_message += " (code=#{error_message['code']})" unless error_message['code'].blank?
+      end
+      # Limit the error size to avoid ActionDispatch::Cookies::CookieOverflow
+      error_message[0..1000]
     end
-    # Limit the error size to avoid ActionDispatch::Cookies::CookieOverflow
-    error_message[0..1000]
-  end
 
-  def nested_hash_value(obj, key)
-    if obj.respond_to?(:key?) && obj.key?(key)
-      obj[key]
-    elsif obj.is_a?(Hash) or obj.is_a?(Array)
-      r = nil
-      obj.find { |*a| r = nested_hash_value(a.last, key) }
-      r
-    else
-      nil
+    def nested_hash_value(obj, key)
+      if obj.respond_to?(:key?) && obj.key?(key)
+        obj[key]
+      elsif obj.is_a?(Hash) || obj.is_a?(Array)
+        r = nil
+        obj.find { |*a| r = nested_hash_value(a.last, key) }
+        r
+      else
+        nil
+      end
     end
-  end
 
-  def json_response
-    begin
-      response = yield
-      response_status = 200
-    rescue KillBillClient::API::ResponseError => e
-      response = as_string_from_response(e.response.body)
-      response_status = e.code
-    rescue Exception => e
-      response = e.message
-      response_status = 500
+    def json_response
+      begin
+        response = yield
+        response_status = 200
+      rescue KillBillClient::API::ResponseError => e
+        response = as_string_from_response(e.response.body)
+        response_status = e.code
+      rescue StandardError => e
+        response = e.message
+        response_status = 500
+      end
+      render json: response, status: response_status
     end
-    render :json => response,  :status => response_status
   end
 end