kaui 0.11.0 → 0.12.0

data/app/controllers/kaui/custom_fields_controller.rb

@@ -4,28 +4,56 @@ class Kaui::CustomFieldsController < Kaui::EngineController
   end
 
   def pagination
-    search_key = params[:sSearch]
-    offset     = params[:iDisplayStart] || 0
-    limit      = params[:iDisplayLength] || 10
-
-    custom_fields = Kaui::CustomField.list_or_search(search_key, offset, limit, options_for_klient)
+    searcher = lambda do |search_key, offset, limit|
+      Kaui::CustomField.list_or_search(search_key, offset, limit, options_for_klient)
+    end
 
-    json = {
-        :sEcho                => params[:sEcho],
-        :iTotalRecords        => custom_fields.pagination_max_nb_records,
-        :iTotalDisplayRecords => custom_fields.pagination_total_nb_records,
-        :aaData               => []
-    }
+    data_extractor = lambda do |custom_field, column|
+      [
+          custom_field.object_id,
+          custom_field.object_type,
+          custom_field.name,
+          custom_field.value
+      ][column]
+    end
 
-    custom_fields.each do |custom_field|
-      json[:aaData] << [
+    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
 
-    respond_to do |format|
-      format.json { render :json => json }
-    end
+    paginate searcher, data_extractor, formatter
+  end
+
+  def new
+    @custom_field = Kaui::CustomField.new
+  end
+
+  def create
+    @custom_field = Kaui::CustomField.new(params.require(:custom_field))
+
+    model = case @custom_field.object_type.to_sym
+              when :ACCOUNT
+                Kaui::Account.new(:account_id => @custom_field.object_id)
+              when :BUNDLE
+                Kaui::Bundle.new(:bundle_id => @custom_field.object_id)
+              when :SUBSCRIPTION
+                Kaui::Subscription.new(:subscription_id => @custom_field.object_id)
+              when :INVOICE
+                Kaui::Invoice.new(:invoice_id => @custom_field.object_id)
+              when :PAYMENT
+                Kaui::Payment.new(:payment_id => @custom_field.object_id)
+              else
+                flash.now[:error] = "Invalid object type #{@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)
+
+    redirect_to custom_fields_path, :notice => 'Custom field was successfully created'
   end
 end

data/app/controllers/kaui/engine_controller.rb

@@ -25,13 +25,54 @@ class Kaui::EngineController < ApplicationController
   end
 
   def check_for_redirect_to_tenant_screen
-    if !Kaui.is_user_assigned_valid_tenant?(current_user, session)
-      flash[:error] = "No tenants configured for users AND KillBillClient.api_key, KillBillClient.api_secret have not been set"
+    unless Kaui.is_user_assigned_valid_tenant?(current_user, session)
+      flash[:error] = 'No tenants configured for users AND KillBillClient.api_key, KillBillClient.api_secret have not been set'
       session[:kb_tenant_id] = nil
-      redirect_to Kaui.tenant_home_path.call and return
+      redirect_to Kaui.tenant_home_path.call
     end
   end
 
+  def retrieve_tenants_for_current_user
+    if Kaui.root_username == current_user.kb_username
+      Kaui::Tenant.all.map(&:kb_tenant_id)
+    else
+      Kaui::AllowedUser.preload(:kaui_tenants).find_by_kb_username(current_user.kb_username).kaui_tenants.map(&:kb_tenant_id)
+    end
+  end
+
+  def retrieve_allowed_users_for_current_user
+    tenants_for_current_user = retrieve_tenants_for_current_user
+
+    Kaui::AllowedUser.preload(:kaui_tenants).all.select do |user|
+      tenants_for_user = user.kaui_tenants.map(&:kb_tenant_id)
+      if tenants_for_user.empty?
+        Kaui.root_username == current_user.kb_username
+      else
+        (tenants_for_user - tenants_for_current_user).empty?
+      end
+    end
+  end
+
+  # Note! Order matters, StandardError needs to be first
+  rescue_from(StandardError) do |error|
+    log_rescue_error error
+    flash[:error] = "Error: #{error.to_s}"
+    try_to_redirect_to_account_path = !params[:controller].ends_with?('accounts')
+    perform_redirect_after_error try_to_redirect_to_account_path
+  end
+
+  rescue_from(ActionController::ParameterMissing) do |parameter_missing_exception|
+    log_rescue_error parameter_missing_exception
+    flash[:error] = "Required parameter missing: #{parameter_missing_exception.param}"
+    perform_redirect_after_error
+  end
+
+  rescue_from(KillBillClient::API::ResponseError) do |killbill_exception|
+    log_rescue_error killbill_exception
+    flash[:error] = "Error while communicating with the Kill Bill server: #{as_string(killbill_exception)}"
+    try_to_redirect_to_account_path = !(killbill_exception.is_a?(KillBillClient::API::NotFound) && params[:controller].ends_with?('accounts'))
+    perform_redirect_after_error try_to_redirect_to_account_path
+  end
 
   private
 
@@ -51,4 +92,16 @@ class Kaui::EngineController < ApplicationController
     result
   end
 
+  def log_rescue_error(error)
+    Rails.logger.warn "#{error.class} #{error.to_s}. #{error.backtrace.join("\n")}"
+  end
+
+  def perform_redirect_after_error(try_to_redirect_to_account_path = true)
+    account_id = nested_hash_value(params, :account_id)
+    if try_to_redirect_to_account_path && account_id.present?
+      redirect_to kaui_engine.account_path(account_id)
+    else
+      redirect_to kaui_engine.home_path
+    end
+  end
 end

data/app/controllers/kaui/engine_controller_util.rb

@@ -6,6 +6,69 @@ module Kaui::EngineControllerUtil
     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 = 2147483647 if limit == -1
+
+    begin
+      pages = searcher.call(search_key, offset, limit)
+    rescue => e
+      error = e.to_s
+    end
+
+    json = {
+        :draw => (params[:draw] || 0).to_i,
+        :recordsTotal => pages.nil? ? 0 : pages.pagination_max_nb_records,
+        :recordsFiltered => pages.nil? ? 0 : pages.pagination_total_nb_records,
+        :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
+    pages.reverse! if ordering_dir == 'desc'
+
+    pages.each { |page| json[:data] << formatter.call(page) }
+
+    respond_to do |format|
+      format.json { render :json => json }
+    end
+  end
+
+  def run_in_parallel(*tasks)
+    latch = Concurrent::CountDownLatch.new(tasks.size)
+    exceptions = Concurrent::Array.new
+
+    tasks.each do |task|
+      Kaui.thread_pool.post do
+        begin
+          task.call
+        rescue => e
+          exceptions << e
+        ensure
+          latch.count_down
+        end
+      end
+    end
+    latch.wait
+
+    exception = exceptions.shift
+    raise exception unless exception.nil?
+  end
+
   def as_string(e)
     if e.is_a?(KillBillClient::API::ResponseError)
       "Error #{e.response.code}: #{as_string_from_response(e.response.body)}"
@@ -30,4 +93,15 @@ module Kaui::EngineControllerUtil
     error_message[0..1000]
   end
 
-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
+    end
+  end
+end

data/app/controllers/kaui/home_controller.rb

@@ -1,4 +1,23 @@
 class Kaui::HomeController < Kaui::EngineController
+
   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)
+    else
+      redirect_to accounts_path(:q => search_query)
+    end
+  end
+
+  private
+
+  def parse_query(query)
+    /((invoice|payment):)?(.*)/.match(query).captures.drop(1)
   end
 end

data/app/controllers/kaui/invoice_items_controller.rb

@@ -1,25 +1,25 @@
 class Kaui::InvoiceItemsController < Kaui::EngineController
 
   def edit
-    invoice_item_id = params[:id]
-    invoice_id      = params[:invoice_id]
-
-    begin
-      invoice = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
-    rescue => e
-      flash[:error] = "Error while getting information for invoice #{invoice_id}: #{as_string(e)}"
-      redirect_to :back
-    end
+    invoice_item_id = params.require(:id)
+    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_item = invoice.items.find { |ii| ii.invoice_item_id == invoice_item_id }
+
+    if @invoice_item.nil?
+      flash[:error] = "Unable to find invoice item #{invoice_item_id}"
+      redirect_to account_invoice_path(params.require(:account_id), invoice_id)
+    end
   end
 
   def update
-    @invoice_item = Kaui::InvoiceItem.new(params[:invoice_item])
+    @invoice_item = Kaui::InvoiceItem.new(params.require(:invoice_item))
 
     begin
       invoice = @invoice_item.update(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.invoice_path(invoice.invoice_id), :notice => 'Adjustment item was successfully created'
+      redirect_to kaui_engine.account_invoice_path(invoice.account_id, invoice.invoice_id), :notice => 'Adjustment item was successfully created'
     rescue => e
       flash.now[:error] = "Error while adjusting invoice item: #{as_string(e)}"
       render :action => :edit
@@ -27,16 +27,11 @@ class Kaui::InvoiceItemsController < Kaui::EngineController
   end
 
   def destroy
-    @invoice_item = Kaui::InvoiceItem.new(:invoice_item_id => params[:id],
-                                          :invoice_id      => params[:invoice_id],
-                                          :account_id      => params[:account_id])
+    invoice_item = Kaui::InvoiceItem.new(:invoice_item_id => params.require(:id),
+                                         :invoice_id => params.require(:invoice_id),
+                                         :account_id => params.require(:account_id))
 
-    begin
-      @invoice_item.delete(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.invoice_path(@invoice_item.invoice_id), :notice => 'CBA item was successfully deleted'
-    rescue => e
-      flash.now[:error] = "Error while deleting CBA item: #{as_string(e)}"
-      render :action => :edit
-    end
+    invoice_item.delete(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    redirect_to kaui_engine.account_invoice_path(invoice_item.account_id, invoice_item.invoice_id), :notice => 'CBA item was successfully deleted'
   end
 end

data/app/controllers/kaui/invoices_controller.rb

@@ -1,80 +1,58 @@
 class Kaui::InvoicesController < Kaui::EngineController
 
   def index
-    if params[:invoice_id].present?
-      redirect_to kaui_engine.invoice_path(params[:invoice_id])
-    end
+    @search_query = params[:account_id]
   end
 
   def pagination
-    json = {:sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => []}
+    searcher = lambda do |search_key, offset, limit|
+      account = Kaui::Account::find_by_id_or_key(search_key, false, false, options_for_klient) rescue nil
+      if account.nil?
+        Kaui::Invoice.list_or_search(search_key, offset, limit, options_for_klient)
+      else
+        account.invoices(true, options_for_klient).map! { |invoice| Kaui::Invoice.build_from_raw_invoice(invoice) }
+      end
+    end
 
-    search_key = params[:sSearch]
-    if search_key.present?
-      invoices = Kaui::Invoice.find_in_batches_by_search_key(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    else
-      invoices = Kaui::Invoice.find_in_batches(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
+    data_extractor = lambda do |invoice, column|
+      [
+          invoice.invoice_number.to_i,
+          invoice.invoice_date,
+          invoice.amount,
+          invoice.balance
+      ][column]
     end
-    json[:iTotalDisplayRecords] = invoices.pagination_total_nb_records
-    json[:iTotalRecords]        = invoices.pagination_max_nb_records
 
-    invoices.each do |invoice|
-      json[:aaData] << [
-          view_context.link_to(view_context.truncate_uuid(invoice.invoice_id), view_context.url_for(:controller => :invoices, :action => :show, :id => invoice.invoice_id)),
-          invoice.invoice_number,
+    formatter = lambda do |invoice|
+      [
+          view_context.link_to(invoice.invoice_number, view_context.url_for(:controller => :invoices, :action => :show, :account_id => invoice.account_id, :id => invoice.invoice_id)),
           view_context.format_date(invoice.invoice_date),
           view_context.humanized_money_with_symbol(invoice.amount_to_money),
           view_context.humanized_money_with_symbol(invoice.balance_to_money)
       ]
     end
 
-    respond_to do |format|
-      format.json { render :json => json }
-    end
+    paginate searcher, data_extractor, formatter
   end
 
   def show
-    invoice_id_or_number = params[:id]
-    unless invoice_id_or_number.present?
-      flash.now[:error] = 'No id given'
-      render :index and return
-    end
+    @invoice = Kaui::Invoice.find_by_id_or_number(params.require(:id), true, 'FULL', options_for_klient)
 
-    begin
-      @invoice         = Kaui::Invoice.find_by_id_or_number(invoice_id_or_number, true, 'FULL', options_for_klient)
-      @invoice_id      = @invoice.invoice_id
-      @account         = Kaui::Account.find_by_id(@invoice.account_id, false, false, options_for_klient)
-      @payments        = Kaui::Invoice.new(:invoice_id => @invoice_id).payments(false, 'FULL', options_for_klient)
+    fetch_payments_and_pms = lambda do
+      @payments = @invoice.payments(true, 'FULL', options_for_klient).map { |payment| Kaui::InvoicePayment.build_from_raw_payment(payment) }
       @payment_methods = Kaui::PaymentMethod.payment_methods_for_payments(@payments, options_for_klient)
+    end
+    fetch_account = lambda { @account = Kaui::Account.find_by_id(@invoice.account_id, false, false, options_for_klient) }
 
-      @subscriptions            = {}
-      @bundles                  = {}
-      @cba_items_not_deleteable = []
-      if @invoice.items.present?
-        @invoice.items.each do |item|
-          @cba_items_not_deleteable << item.linked_invoice_item_id if item.description =~ /account credit/ and item.amount < 0
+    run_in_parallel fetch_payments_and_pms, fetch_account
+  end
 
-          unless item.subscription_id.nil? || @subscriptions.has_key?(item.subscription_id)
-            @subscriptions[item.subscription_id] = Kaui::Subscription::find_by_id(item.subscription_id, options_for_klient)
-          end
-          unless item.bundle_id.nil? || @bundles.has_key?(item.bundle_id)
-            @bundles[item.bundle_id] = Kaui::Bundle::find_by_id(item.bundle_id, options_for_klient)
-          end
-        end
-      else
-        flash.now[:error] = "Invoice items for #{@invoice_id} not found"
-      end
-    rescue => e
-      flash.now[:error] = "Error while getting information for invoice #{invoice_id_or_number}: #{as_string(e)}"
-    end
+  def restful_show
+    invoice = Kaui::Invoice.find_by_id_or_number(params.require(:id), false, 'NONE', options_for_klient)
+    redirect_to account_invoice_path(invoice.account_id, invoice.invoice_id)
   end
 
   def show_html
-    begin
-      render :text => Kaui::Invoice.as_html(params[:id], options_for_klient)
-    rescue => e
-      flash.now[:error] = "Error rendering invoice html #{params[:id]}: #{as_string(e)}"
-      render :action => :index
-    end
+    render :text => Kaui::Invoice.as_html(params.require(:id), options_for_klient)
   end
 end

data/app/controllers/kaui/payment_methods_controller.rb

@@ -1,38 +1,5 @@
 class Kaui::PaymentMethodsController < Kaui::EngineController
 
-  def index
-  end
-
-  def pagination
-    search_key = params[:sSearch]
-    offset     = params[:iDisplayStart] || 0
-    limit      = params[:iDisplayLength] || 10
-
-    payment_methods = Kaui::PaymentMethod.list_or_search(search_key, offset, limit, options_for_klient)
-
-    json = {
-        :sEcho                => params[:sEcho],
-        :iTotalRecords        => payment_methods.pagination_max_nb_records,
-        :iTotalDisplayRecords => payment_methods.pagination_total_nb_records,
-        :aaData               => []
-    }
-
-    payment_methods.each do |payment_method|
-      info_plugin = payment_method.plugin_info || OpenStruct.new
-      json[:aaData] << [
-          view_context.link_to(view_context.truncate_uuid(payment_method.payment_method_id), view_context.url_for(:controller => :payment_methods, :action => :show, :id => payment_method.payment_method_id)),
-          view_context.link_to(view_context.truncate_uuid(payment_method.account_id), view_context.url_for(:controller => :accounts, :action => :show, :id => payment_method.account_id)),
-          info_plugin.external_payment_id,
-          find_value_from_properties(info_plugin.properties, 'ccName'),
-          find_value_from_properties(info_plugin.properties, 'ccLast4'),
-      ]
-    end
-
-    respond_to do |format|
-      format.json { render :json => json }
-    end
-  end
-
   def new
     @payment_method = Kaui::PaymentMethod.new(:account_id  => params[:account_id],
                                               :plugin_name => params[:plugin_name] || Kaui.creditcard_plugin_name.call)
@@ -79,34 +46,35 @@ class Kaui::PaymentMethodsController < Kaui::EngineController
 
     begin
       @payment_method = @payment_method.create(@payment_method.is_default, current_user.kb_username, @reason, @comment, options_for_klient)
-      redirect_to payment_method_path(@payment_method.payment_method_id), :notice => 'Payment method was successfully created'
+      redirect_to kaui_engine.account_path(@payment_method.account_id), :notice => 'Payment method was successfully created'
     rescue => e
       flash.now[:error] = "Error while creating payment method: #{as_string(e)}"
       render :action => :new
     end
   end
 
-  def show
-    begin
-      @payment_methods = [Kaui::PaymentMethod.find_by_id(params[:id], true, options_for_klient)]
-    rescue => e
-      flash.now[:error] = "Error while retrieving payment method #{params[:id]}: #{as_string(e)}"
-      render :action => :index
-    end
-  end
-
   def destroy
     payment_method_id = params[:id]
 
+    payment_method = Kaui::PaymentMethod.find_by_id(payment_method_id, false, options_for_klient)
     begin
       Kaui::PaymentMethod.destroy(payment_method_id, params[:set_auto_pay_off], current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to payment_methods_path, :notice => "Payment method #{payment_method_id} successfully deleted"
+      redirect_to kaui_engine.account_path(payment_method.account_id), :notice => "Payment method #{payment_method_id} successfully deleted"
     rescue => e
-      flash.now[:error] = "Error while deleting payment method #{payment_method_id}: #{as_string(e)}"
-      render :action => :index
+      flash[:error] = "Error while deleting payment method #{payment_method_id}: #{as_string(e)}"
+      redirect_to kaui_engine.account_path(payment_method.account_id)
     end
   end
 
+  def show
+    restful_show
+  end
+
+  def restful_show
+    payment_method = Kaui::PaymentMethod.find_by_id(params.require(:id), false, options_for_klient)
+    redirect_to kaui_engine.account_path(payment_method.account_id)
+  end
+
   private
 
   def find_value_from_properties(properties, key)