kaui 1.0.0 → 1.1.0

data/app/controllers/kaui/audit_logs_controller.rb

@@ -8,7 +8,8 @@ class Kaui::AuditLogsController < Kaui::EngineController
 
 
     formatter = lambda do |log|
-      object_id_text = view_context.content_tag(:span, view_context.truncate_uuid(log.object_id), title: log.object_id )
+      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: {
@@ -29,7 +30,7 @@ class Kaui::AuditLogsController < Kaui::EngineController
           log.changed_by,
           log.reason_code,
           log.comments,
-          view_context.content_tag(:span, view_context.truncate_uuid(log.user_token), title: log.user_token )
+          view_context.object_id_popover(log.user_token, 'left')
       ]
     end
 

data/app/controllers/kaui/charges_controller.rb

@@ -5,7 +5,7 @@ class Kaui::ChargesController < Kaui::EngineController
     amount = params[:amount]
 
     if invoice_id.present?
-      @invoice = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
+      @invoice = Kaui::Invoice.find_by_id(invoice_id, true, 'NONE', options_for_klient)
       amount ||= @invoice.balance
       currency = @invoice.currency
     else

data/app/controllers/kaui/credits_controller.rb

@@ -5,7 +5,7 @@ class Kaui::CreditsController < Kaui::EngineController
     amount = params[:amount]
 
     if invoice_id.present?
-      @invoice = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
+      @invoice = Kaui::Invoice.find_by_id(invoice_id, true, 'NONE', options_for_klient)
       amount ||= @invoice.balance
       currency = @invoice.currency
     else

data/app/controllers/kaui/home_controller.rb

@@ -1,25 +1,288 @@
 class Kaui::HomeController < Kaui::EngineController
 
+  QUERY_PARSE_REGEX = ['FIND:(?<object_type>.*) BY:(?<search_by>.*) FOR:(?<search_for>.*) ONLY_FIRST:(?<fast>.*)',
+                       'FIND:(?<object_type>.*) BY:(?<search_by>.*) FOR:(?<search_for>.*)',
+                       'FIND:(?<object_type>.*) FOR:(?<search_for>.*) ONLY_FIRST:(?<fast>.*)',
+                       'FIND:(?<object_type>.*) FOR:(?<search_for>.*)']
+
+  SIMPLE_PARSE_REGEX = '(?<search_for>.*)'
+
   def index
     @search_query = params[:q]
   end
 
   def search
-    search_type, search_query = parse_query(params[:q])
-    if search_type == 'invoice'
-      redirect_to invoice_path(:id => search_query)
-    elsif search_type == 'payment'
-      redirect_to payment_path(:id => search_query)
-    elsif search_type == 'transaction'
-      redirect_to transaction_path(:id => search_query)
-    else
-      redirect_to accounts_path(:q => search_query, :fast => params[:fast])
+    object_type, search_query, search_by, fast = parse_query(params[:q])
+
+    unless object_type.nil?
+      cached_options_for_klient = options_for_klient
+      send("#{object_type}_search", search_query, search_by, fast, cached_options_for_klient)
     end
   end
 
   private
 
+  def account_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by == 'ID'
+      begin
+        account = Kaui::Account.find_by_id(search_query, false, false, options)
+        redirect_to account_path(account.account_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No account matches \"#{search_query}\"")
+      end
+    elsif search_by == 'EXTERNAL_KEY'
+      begin
+        account = Kaui::Account.find_by_external_key(search_query, false, false, options)
+        redirect_to account_path(account.account_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No account matches \"#{search_query}\"")
+      end
+    else
+      account = Kaui::Account.list_or_search(search_query, 0, 1, options).first
+      if account.blank?
+        search_error("No account matches \"#{search_query}\"")
+      elsif true?(fast)
+        redirect_to account_path(account.account_id) and return
+      else
+        redirect_to accounts_path(:q => search_query, :fast => fast) and return
+      end
+    end
+  end
+
+  def invoice_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by == 'ID'
+      begin
+        invoice = Kaui::Invoice.find_by_id(search_query, false, 'NONE', options)
+        redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No invoice matches \"#{search_query}\"")
+      end
+    elsif search_by == 'EXTERNAL_KEY'
+      unsupported_external_key_search('INVOICE')
+    else
+      invoice = Kaui::Invoice.list_or_search(search_query, 0, 1, options).first
+      if invoice.blank?
+        begin
+          invoice = Kaui::Invoice.find_by_invoice_item_id(search_query, false, false, 'NONE', options)
+          redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id) and return
+        rescue KillBillClient::API::NotFound => _
+          search_error("No invoice matches \"#{search_query}\"")
+        end
+      elsif true?(fast)
+        redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id) and return
+      else
+        redirect_to account_invoices_path(:account_id => invoice.account_id, :q => search_query, :fast => fast) and return
+      end
+    end
+  end
+
+  def payment_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by == 'ID'
+      begin
+        payment = Kaui::Payment.find_by_id(search_query, false, false, options)
+        redirect_to account_payment_path(payment.account_id, payment.payment_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No payment matches \"#{search_query}\"")
+      end
+    elsif search_by == 'EXTERNAL_KEY'
+      begin
+        payment = Kaui::Payment.find_by_external_key(search_query, false, false, options)
+        redirect_to account_payment_path(payment.account_id, payment.payment_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No payment matches \"#{search_query}\"")
+      end
+    else
+      payment = Kaui::Payment.list_or_search(search_query, 0, 1, options).first
+      if payment.blank?
+        search_error("No payment matches \"#{search_query}\"")
+      elsif true?(fast)
+        redirect_to account_payment_path(payment.account_id, payment.payment_id) and return
+      else
+        redirect_to account_payments_path(:account_id => payment.account_id, :q => search_query, :fast => fast) and return
+      end
+    end
+  end
+
+  def transaction_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by.blank? || search_by == 'ID'
+      begin
+        payment = Kaui::Payment.find_by_transaction_id(search_query, false, true, options)
+        redirect_to account_payment_path(payment.account_id, payment.payment_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No transaction matches \"#{search_query}\"")
+      end
+    else
+      begin
+        payment = Kaui::Payment.find_by_transaction_external_key(search_query, false, true, 'NONE', options)
+        redirect_to account_payment_path(payment.account_id, payment.payment_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No transaction matches \"#{search_query}\"")
+      end
+    end
+  end
+
+  def bundle_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by == 'ID'
+      begin
+        bundle = Kaui::Bundle.find_by_id(search_query, options)
+        redirect_to kaui_engine.account_bundles_path(bundle.account_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No bundle matches \"#{search_query}\"")
+      end
+    elsif search_by == 'EXTERNAL_KEY'
+      begin
+        bundle = Kaui::Bundle.find_by_external_key(search_query, false, options)
+        redirect_to kaui_engine.account_bundles_path(bundle.account_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No bundle matches \"#{search_query}\"")
+      end
+    else
+      bundle = Kaui::Bundle.list_or_search(search_query, 0, 1, options).first
+      if bundle.blank?
+        search_error("No bundle matches \"#{search_query}\"")
+      else
+        redirect_to kaui_engine.account_bundles_path(bundle.account_id) and return
+      end
+    end
+  end
+
+  def credit_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by.blank? || search_by == 'ID'
+      begin
+        credit = Kaui::Credit.find_by_id(search_query, options)
+        redirect_to account_invoice_path(credit.account_id, credit.invoice_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No credit matches \"#{search_query}\"")
+      end
+    else
+      unsupported_external_key_search('CREDIT')
+    end
+  end
+
+  def custom_field_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by.blank? || search_by == 'ID'
+      custom_field = Kaui::CustomField.list_or_search(search_query, 0, 1, options)
+      if custom_field.blank?
+        search_error("No custom field matches \"#{search_query}\"")
+      else
+        redirect_to custom_fields_path(:q => search_query, :fast => fast) and return
+      end
+    else
+      unsupported_external_key_search('CUSTOM FIELD')
+    end
+  end
+
+  def invoice_payment_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by.blank? || search_by == 'ID'
+      begin
+        invoice_payment = Kaui::InvoicePayment.find_safely_by_id(search_query, options)
+        redirect_to account_payment_path(invoice_payment.account_id, invoice_payment.payment_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No invoice payment matches \"#{search_query}\"")
+      end
+    else
+      unsupported_external_key_search('INVOICE PAYMENT')
+    end
+  end
+
+  def subscription_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by.blank? || search_by == 'ID'
+      begin
+        subscription = Kaui::Subscription.find_by_id(search_query, options)
+        redirect_to account_bundles_path(subscription.account_id) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No subscription matches \"#{search_query}\"")
+      end
+    else
+      unsupported_external_key_search('SUBSCRIPTION')
+    end
+  end
+
+  def tag_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by.blank? || search_by == 'ID'
+      tag = Kaui::Tag.list_or_search(search_query, 0, 1, options)
+      if tag.blank?
+        search_error("No tag matches \"#{search_query}\"")
+      else
+        redirect_to tags_path(:q => search_query, :fast => fast) and return
+      end
+    else
+      unsupported_external_key_search('TAG')
+    end
+  end
+
+  def tag_definition_search(search_query, search_by = nil, fast = 0, options = {})
+    if search_by == 'ID'
+      begin
+        Kaui::TagDefinition.find_by_id(search_query, 'NONE', options)
+        redirect_to tag_definitions_path(:q => search_query, :fast => fast) and return
+      rescue KillBillClient::API::NotFound => _
+        search_error("No tag definition matches \"#{search_query}\"")
+      end
+    elsif search_by == 'EXTERNAL_KEY'
+      unsupported_external_key_search('TAG DEFINITION')
+    else
+      tag_definition = Kaui::TagDefinition.find_by_name(search_query, 'NONE', options)
+      if tag_definition.blank?
+        begin
+          Kaui::TagDefinition.find_by_id(search_query, 'NONE', options)
+          redirect_to tag_definitions_path(:q => search_query, :fast => fast) and return
+        rescue KillBillClient::API::NotFound => _
+          search_error("No tag definition matches \"#{search_query}\"")
+        end
+      else
+        redirect_to tag_definitions_path(:q => search_query, :fast => fast) and return
+      end
+    end
+  end
+
+  def unsupported_external_key_search(object_type)
+    search_error("\"#{object_type}\": Search by \"EXTERNAL KEY\" is not supported.")
+  end
+
+  def search_error(message)
+    flash[:error] = message
+    redirect_to kaui_engine.home_path and return
+  end
+
   def parse_query(query)
-    /((invoice|payment|transaction):)?(.*)/.match(query).captures.drop(1)
+    statements, simple_regex_used = regex_parse_query(query)
+
+    object_type = statements[:object_type].strip.downcase rescue 'account'
+    search_for = statements[:search_for].strip
+    search_by = statements[:search_by].strip.upcase rescue simple_regex_used && uuid?(search_for) ? 'ID' : nil
+    fast = statements[:fast] rescue '0'
+
+    if !search_by.blank? && !(search_by == 'ID' || search_by == 'EXTERNAL_KEY')
+      search_error("\"#{search_by}\" is not a valid search by value")
+    end
+
+    return object_type, search_for, search_by, fast
+  end
+
+  def regex_parse_query(query)
+    statements = nil
+    simple_regex_used = false
+    QUERY_PARSE_REGEX.each do |query_regex|
+      regex_exp = Regexp.new(query_regex, true)
+      statements = regex_exp.match(query)
+      break unless statements.nil?
+    end
+
+    if statements.nil?
+      regex_exp = Regexp.new(SIMPLE_PARSE_REGEX, true)
+      statements = regex_exp.match(query)
+      simple_regex_used = true
+    end
+
+    return statements, simple_regex_used
+  end
+
+  def true?(statement)
+    [1,'1',true,'true'].include? ((statement.instance_of? String) ? statement.downcase : statement)
+  end
+
+  def uuid?(value)
+    value =~ /[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}/
   end
 end

data/app/controllers/kaui/invoice_items_controller.rb

@@ -5,7 +5,7 @@ class Kaui::InvoiceItemsController < Kaui::EngineController
     invoice_id = params.require(:invoice_id)
 
     # See https://github.com/killbill/killbill/issues/7
-    invoice = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
+    invoice = Kaui::Invoice.find_by_id(invoice_id, true, 'NONE', options_for_klient)
     @invoice_item = invoice.items.find { |ii| ii.invoice_item_id == invoice_item_id }
 
     if @invoice_item.nil?

data/app/controllers/kaui/invoices_controller.rb

@@ -45,7 +45,7 @@ class Kaui::InvoicesController < Kaui::EngineController
     # Go to the database once
     cached_options_for_klient = options_for_klient
 
-    @invoice = Kaui::Invoice.find_by_id_or_number(params.require(:id), true, 'FULL', cached_options_for_klient)
+    @invoice = Kaui::Invoice.find_by_id(params.require(:id), true, 'FULL', cached_options_for_klient)
 
     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) }
@@ -76,7 +76,7 @@ class Kaui::InvoicesController < Kaui::EngineController
   end
 
   def restful_show
-    invoice = Kaui::Invoice.find_by_id_or_number(params.require(:id), false, 'NONE', options_for_klient)
+    invoice = Kaui::Invoice.find_by_id(params.require(:id), false, 'NONE', options_for_klient)
     redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id)
   end
 
@@ -85,7 +85,7 @@ class Kaui::InvoicesController < Kaui::EngineController
   end
 
   def commit_invoice
-    invoice = KillBillClient::Model::Invoice.find_by_id_or_number(params.require(:id), false, 'NONE', options_for_klient)
+    invoice = KillBillClient::Model::Invoice.find_by_id(params.require(:id), false, 'NONE', options_for_klient)
     invoice.commit(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
     redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id), :notice => 'Invoice successfully committed'
   end

data/app/controllers/kaui/payments_controller.rb

@@ -52,7 +52,8 @@ class Kaui::PaymentsController < Kaui::EngineController
           payment.total_authed_amount_to_money,
           payment.paid_amount_to_money,
           payment.returned_amount_to_money,
-          payment.transactions.empty? ? nil : payment.transactions[-1].status
+          payment.transactions.empty? ? nil : payment.transactions[-1].status,
+          payment.payment_external_key
       ][column]
     end
 
@@ -63,7 +64,8 @@ class Kaui::PaymentsController < Kaui::EngineController
           view_context.humanized_money_with_symbol(payment.total_authed_amount_to_money),
           view_context.humanized_money_with_symbol(payment.paid_amount_to_money),
           view_context.humanized_money_with_symbol(payment.returned_amount_to_money),
-          payment.transactions.empty? ? nil : view_context.colored_transaction_status(payment.transactions[-1].status)
+          payment.transactions.empty? ? nil : view_context.colored_transaction_status(payment.transactions[-1].status),
+          payment.payment_external_key
       ]
     end
 
@@ -71,7 +73,7 @@ class Kaui::PaymentsController < Kaui::EngineController
   end
 
   def new
-    fetch_invoice = promise { Kaui::Invoice.find_by_id_or_number(params.require(:invoice_id), true, 'NONE', options_for_klient) }
+    fetch_invoice = promise { Kaui::Invoice.find_by_id(params.require(:invoice_id), true, 'NONE', options_for_klient) }
     fetch_payment_methods = promise { Kaui::PaymentMethod.find_all_by_account_id(params.require(:account_id), false, options_for_klient) }
 
     @invoice = wait(fetch_invoice)

data/app/controllers/kaui/refunds_controller.rb

@@ -1,7 +1,7 @@
 class Kaui::RefundsController < Kaui::EngineController
 
   def new
-    fetch_invoice = promise { Kaui::Invoice.find_by_id_or_number(params.require(:invoice_id), true, 'NONE', options_for_klient) }
+    fetch_invoice = promise { Kaui::Invoice.find_by_id(params.require(:invoice_id), true, 'NONE', options_for_klient) }
     fetch_payment = promise { Kaui::InvoicePayment::find_by_id(params.require(:payment_id), false, false, options_for_klient) }
     fetch_bundles = promise { @account.bundles(options_for_klient) }
 
@@ -13,7 +13,7 @@ class Kaui::RefundsController < Kaui::EngineController
   end
 
   def create
-    invoice = Kaui::Invoice.find_by_id_or_number(params.require(:invoice_id), true, 'NONE', options_for_klient)
+    invoice = Kaui::Invoice.find_by_id(params.require(:invoice_id), true, 'NONE', options_for_klient)
 
     if params[:adjustment_type] == 'invoiceItemAdjustment'
       items = []

data/app/controllers/kaui/subscriptions_controller.rb

@@ -73,6 +73,7 @@ class Kaui::SubscriptionsController < Kaui::EngineController
                              params[:comment],
                              requested_date,
                              billing_policy,
+                             nil,
                              wait_for_completion,
                              options_for_klient)
 
@@ -184,7 +185,7 @@ class Kaui::SubscriptionsController < Kaui::EngineController
     else
       options = options_for_klient
 
-      catalog = Kaui::Catalog.get_tenant_catalog('json', DateTime.now.to_s, options)
+      catalog = Kaui::Catalog.get_tenant_catalog_json( DateTime.now.to_s, options)
 
       return [] if catalog.blank?
 

data/app/helpers/kaui/object_helper.rb

@@ -24,5 +24,9 @@ module Kaui
       [:ACCOUNT, :BUNDLE, :INVOICE, :INVOICE_ITEM, :INVOICE_PAYMENT, :PAYMENT, :SUBSCRIPTION, :TRANSACTION]
     end
 
+    def object_types_for_advanced_search
+      [:ACCOUNT, :BUNDLE, :INVOICE, :CREDIT, :CUSTOM_FIELD, :INVOICE_PAYMENT, :INVOICE, :PAYMENT, :SUBSCRIPTION, :TRANSACTION, :TAG, :TAG_DEFINITION]
+    end
+
   end
 end

data/app/helpers/kaui/plugin_helper.rb

@@ -3,30 +3,22 @@ module Kaui
     # including plugin that are installed
     def plugin_repository
       plugins = []
-      plugin_repository = Kaui::AdminTenant::get_plugin_repository
-      installed_plugins = installed_plugins()
-
+      plugin_repository = Kaui::AdminTenant.get_plugin_repository
       plugin_repository.each_pair do |key, info|
-        found_plugin = installed_plugins.reject! { |p| p.plugin_key.eql?(key.to_s) }
         plugins << {
-            plugin_key: plugin_key(key.to_s, info),
-            plugin_name: plugin_name(key.to_s, info),
-            plugin_type: info[:type],
-            installed: !found_plugin.nil?
+          plugin_key: plugin_key(key.to_s, info),
+          plugin_name: plugin_name(key.to_s, info),
+          plugin_type: info[:type],
+          installed: false
         }
       end
 
-      installed_plugins.each do |plugin|
-        plugins << {
-            plugin_key: plugin.plugin_key,
-            plugin_name: plugin.plugin_name,
-            plugin_type: nil,
-            installed: true
-        }
-      end
+      installed_plugins = installed_plugins(plugins)
+
+      plugins.sort! { |a, b| a[:plugin_key] <=> b[:plugin_key] }
+      plugins.each { |plugin| installed_plugins << plugin }
 
-      plugins.sort! { |a,b| a[:plugin_key] <=> b[:plugin_key] && b[:installed].to_s <=> a[:installed].to_s }
-      plugins
+      installed_plugins
     end
 
     private
@@ -48,11 +40,35 @@ module Kaui
         end
       end
 
-      def installed_plugins
+      def installed_plugins(plugins)
+        installed_plugins = []
         nodes_info = KillBillClient::Model::NodesInfo.nodes_info(Kaui.current_tenant_user_options(current_user, session)) || []
         plugins_info = nodes_info.first.plugins_info || []
 
-        plugins_info.select { |plugin| !plugin.version.nil?}
+        plugins_info.each do |plugin|
+          next if plugin.version.nil?
+          # do not allow duplicate
+          next if installed_plugins.any? { |p| p[:plugin_name].eql?(plugin.plugin_name) }
+          plugin_key = Kaui::AdminTenant.rewrite_plugin_key(plugin.plugin_key)
+          installed_plugins << {
+              plugin_key: plugin_key,
+              plugin_name: plugin.plugin_name,
+              plugin_type: find_plugin_type(plugins, plugin_key),
+              installed: true
+          }
+        end
+
+        installed_plugins.sort! { |a,b| a[:plugin_key] <=> b[:plugin_key] }
+      end
+
+      def find_plugin_type(plugins, plugin_key_to_search)
+        plugins.each do |plugin|
+          if plugin[:plugin_key] == plugin_key_to_search
+            return plugin[:plugin_type]
+          end
+        end
+
+        return nil
       end
   end
 end