kaui 0.15.0 → 0.15.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bf008611430663168c6e6f8ef1adca13ef8b0929
-  data.tar.gz: 55cd8e91ff9c1798881a5e8af70dfede6f9576de
+  metadata.gz: 4208468a561fd0c2e15a06de685932b20eb28933
+  data.tar.gz: 32231b5c4acd5c8ed70e425c185e28cd2efd658d
 SHA512:
-  metadata.gz: 90239db91f63b3eeff5170aa41f6e7b75b34c3b4f17eceabe1830f86134193c8a44f3e09c28450b4e6851fdec534e346cd599c97094dd28039f480dd38b690f0
-  data.tar.gz: 7ee1407b3378494668e50879f686c6c33809ad3a3a086572c4abe9572b5a10c460298a5a6058977fe39c1ddcfc62195fc0cf7d461f4c062c6ebdc58ac4f20e23
+  metadata.gz: 3be5d4c9eb3f8c88cd3938403be9d22f36e61655e398a034dfd02b744a4ad309c6361858f70c5552cb781d3d5eede2cb333ad3f318d1ce1e553e0ceb806017c8
+  data.tar.gz: 50a33a56415bbde528bf403040b76695d0abe9c7e375920f658c60078015e173b8b6fa6f06a673012b2bf7f2438a0e44e1cc5b7d1e2bf1dad2c21480c91f9402

data/README.md

@@ -6,10 +6,10 @@ Kaui core mountable engine. For Kaui the UI, see [killbill-admin-ui-standalone](
 Kill Bill compatibility
 -----------------------
 
-| API version | Kill Bill version |
-| ----------: | ----------------: |
-| 0.14.y      | 0.16.z            |
-| 0.15.y      | 0.18.z            |
+| Kaui version | Kill Bill version |
+| -----------: | ----------------: |
+| 0.14.y       | 0.16.z            |
+| 0.15.y       | 0.18.z            |
 
 Running Kaui locally
 ---------------------

data/app/assets/stylesheets/kaui/common.less

@@ -77,12 +77,6 @@ a {
     }
 }
 
-small {
-    font-size: 14px;
-    display: inline-block;
-    text-transform: uppercase;
-}
-
 span {
     &.success, &.fail {
         display: inline-block;

data/app/assets/stylesheets/kaui/datatable.less

@@ -12,6 +12,20 @@
             }
         }
     }
+
+    table.table-small-padding {
+        th, td {
+            white-space: nowrap;
+
+            &:first-of-type {
+                padding-left: 20px;
+            }
+        }
+    }
+
+    tr.disabled {
+        background-color: #f5f5f5;
+    }
 }
 
 table.dataTable {

data/app/assets/stylesheets/kaui/home.less

@@ -47,6 +47,10 @@
         }
     }
 
+    .legend {
+        margin-top: 40px;
+    }
+
     .duck_help {
         width: 352px;
         height: 260px;

data/app/controllers/kaui/accounts_controller.rb

@@ -2,6 +2,16 @@ class Kaui::AccountsController < Kaui::EngineController
 
   def index
     @search_query = params[:q]
+
+    @limit = 50
+    if @search_query.blank?
+      max_nb_records = Kaui::Account.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records
+      @offset = [0, max_nb_records - @limit].max
+      @ordering = 'desc'
+    else
+      @offset = 0
+      @ordering = 'asc'
+    end
   end
 
   def pagination
@@ -66,6 +76,33 @@ class Kaui::AccountsController < Kaui::EngineController
     run_in_parallel fetch_overdue_state, fetch_account_tags, fetch_account_emails, fetch_payment_methods, fetch_available_tags
   end
 
+  def trigger_invoice
+    account_id = params.require(:account_id)
+    target_date = params[:target_date].presence
+    dry_run = params[:dry_run] == '1'
+
+    invoice = nil
+    begin
+      invoice = dry_run ? Kaui::Invoice.trigger_invoice_dry_run(account_id, target_date, false, options_for_klient) :
+                          Kaui::Invoice.trigger_invoice(account_id, target_date, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    rescue KillBillClient::API::NotFound
+      # Null invoice
+    end
+
+    if invoice.nil?
+      redirect_to account_path(account_id), :notice => "Nothing to generate for target date #{target_date.nil? ? 'today' : target_date}"
+    elsif dry_run
+      @invoice = Kaui::Invoice.build_from_raw_invoice(invoice)
+      @payments = []
+      @payment_methods = nil
+      @account = Kaui::Account.find_by_id(account_id, false, false, options_for_klient)
+      render :template => 'kaui/invoices/show'
+    else
+      # Redirect to fetch payments, etc.
+      redirect_to invoice_path(invoice.invoice_id, :account_id => account_id), :notice => "Generated invoice #{invoice.invoice_number} for target date #{invoice.target_date}"
+    end
+  end
+
   # Fetched asynchronously, as it takes time. This also helps with enforcing permissions.
   def next_invoice_date
     next_invoice = Kaui::Invoice.trigger_invoice_dry_run(params.require(:account_id), nil, true, options_for_klient)

data/app/controllers/kaui/admin_allowed_users_controller.rb

@@ -25,7 +25,7 @@ class Kaui::AdminAllowedUsersController < Kaui::EngineController
 
   def show
     @allowed_user = Kaui::AllowedUser.find(params.require(:id))
-    raise ActiveRecord::RecordNotFound.new("Could not find user #{@allowed_user.id}") unless (Kaui.root_username == current_user.kb_username || @allowed_user.kb_username == current_user.kb_username)
+    raise ActiveRecord::RecordNotFound.new("Could not find user #{@allowed_user.id}") unless (current_user.root? || @allowed_user.kb_username == current_user.kb_username)
 
     tenants_for_current_user = retrieve_tenants_for_current_user
     @tenants = Kaui::Tenant.all.select { |tenant| tenants_for_current_user.include?(tenant.kb_tenant_id) }
@@ -34,7 +34,7 @@ class Kaui::AdminAllowedUsersController < Kaui::EngineController
   def add_tenant
     allowed_user = Kaui::AllowedUser.find(params.require(:allowed_user).require(:id))
 
-    if Kaui.root_username != current_user.kb_username
+    if !current_user.root?
       redirect_to admin_allowed_user_path(allowed_user.id), :alert => 'Only the root user can set tenants for user'
       return
     end

data/app/controllers/kaui/admin_controller.rb

@@ -0,0 +1,27 @@
+class Kaui::AdminController < Kaui::EngineController
+
+  skip_before_filter :check_for_redirect_to_tenant_screen
+
+  def index
+    @clock = Kaui::Admin.get_clock(nil, options_for_klient)
+
+    respond_to do |format|
+      format.html
+      format.js
+    end
+  end
+
+  def set_clock
+    if params[:commit] == 'Submit'
+      current_datetime = DateTime.parse(Kaui::Admin.get_clock(nil, options_for_klient)['currentUtcTime'])
+      new_local_date = Date.parse(params[:new_date])
+      new_datetime = DateTime.new(new_local_date.year, new_local_date.month, new_local_date.day, current_datetime.hour, current_datetime.min, current_datetime.sec, 'Z').to_s
+      msg = "Clock was successfully updated to #{new_datetime}"
+    else
+      new_datetime = nil
+      msg = 'Clock was successfully reset'
+    end
+    Kaui::Admin.set_clock(new_datetime, nil, options_for_klient)
+    redirect_to admin_path, :notice => msg
+  end
+end

data/app/controllers/kaui/admin_tenants_controller.rb

@@ -79,6 +79,9 @@ class Kaui::AdminTenantsController < Kaui::EngineController
 
     @plugin_config =  Kaui::AdminTenant::get_oss_plugin_info(plugin_repository) rescue @plugin_config = ""
     @tenant_plugin_config = Kaui::AdminTenant::get_tenant_plugin_config(plugin_repository, options) rescue @tenant_plugin_config = ""
+
+    # When reloading page from the view, it sends the last tab that was active
+    @active_tab = params[:active_tab] || "CatalogShow"
   end
 
   def upload_catalog
@@ -97,6 +100,8 @@ class Kaui::AdminTenantsController < Kaui::EngineController
   end
 
   def new_catalog
+
+
     @tenant = safely_find_tenant_by_id(params[:id])
 
     options = tenant_options_for_client
@@ -115,7 +120,7 @@ class Kaui::AdminTenantsController < Kaui::EngineController
         latest_catalog.products.select { |p| p.type == 'STANDALONE' }.map { |p| p.name } : []
     @product_categories = [:BASE, :ADD_ON, :STANDALONE]
     @billing_period = [:DAILY, :WEEKLY, :BIWEEKLY, :THIRTY_DAYS, :MONTHLY, :QUARTERLY, :BIANNUAL, :ANNUAL, :BIENNIAL]
-    @time_units = [:UNLIMITED, :DAYS, :MONTHS, :YEARS]
+    @time_units = [:UNLIMITED, :DAYS, :WEEKS, :MONTHS, :YEARS]
 
     @simple_plan = Kaui::SimplePlan.new
   end
@@ -257,7 +262,7 @@ class Kaui::AdminTenantsController < Kaui::EngineController
     current_tenant = safely_find_tenant_by_id(params[:id])
     au = Kaui::AllowedUser.find(params.require(:allowed_user).require(:id))
 
-    if Kaui.root_username != current_user.kb_username
+    if !current_user.root?
       render :json => {:alert => 'Only the root user can remove users from tenants'}.to_json, :status => 401
       return
     end
@@ -280,6 +285,7 @@ class Kaui::AdminTenantsController < Kaui::EngineController
 
   private
 
+
   def safely_find_tenant_by_id(tenant_id)
     tenant = Kaui::Tenant.find_by_id(tenant_id)
     raise ActiveRecord::RecordNotFound.new('Could not find tenant ' + tenant_id) unless retrieve_tenants_for_current_user.include?(tenant.kb_tenant_id)

data/app/controllers/kaui/engine_controller.rb

@@ -36,7 +36,7 @@ class Kaui::EngineController < ApplicationController
   end
 
   def retrieve_tenants_for_current_user
-    if Kaui.root_username == current_user.kb_username
+    if current_user.root?
       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)
@@ -49,7 +49,7 @@ class Kaui::EngineController < ApplicationController
     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
+        current_user.root?
       else
         (tenants_for_user - tenants_for_current_user).empty?
       end

data/app/controllers/kaui/engine_controller_util.rb

@@ -38,7 +38,7 @@ module Kaui::EngineControllerUtil
       b = data_extractor.call(b, ordering_column)
       sort = a <=> b
       sort.nil? ? -1 : sort
-    end
+    end unless search_key.nil? # Keep DB ordering when listing all entries
     pages.reverse! if ordering_dir == 'desc'
 
     pages.each { |page| json[:data] << formatter.call(page) }

data/app/controllers/kaui/home_controller.rb

@@ -10,6 +10,8 @@ class Kaui::HomeController < Kaui::EngineController
       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)
     end
@@ -18,6 +20,6 @@ class Kaui::HomeController < Kaui::EngineController
   private
 
   def parse_query(query)
-    /((invoice|payment):)?(.*)/.match(query).captures.drop(1)
+    /((invoice|payment|transaction):)?(.*)/.match(query).captures.drop(1)
   end
 end

data/app/controllers/kaui/invoices_controller.rb

@@ -2,6 +2,16 @@ class Kaui::InvoicesController < Kaui::EngineController
 
   def index
     @search_query = params[:account_id]
+
+    @limit = 50
+    if @search_query.blank?
+      max_nb_records = Kaui::Invoice.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records
+      @offset = [0, max_nb_records - @limit].max
+      @ordering = 'desc'
+    else
+      @offset = 0
+      @ordering = 'asc'
+    end
   end
 
   def pagination

data/app/controllers/kaui/payments_controller.rb

@@ -1,16 +1,39 @@
 class Kaui::PaymentsController < Kaui::EngineController
 
   def index
-    @search_query = params[:account_id]
+    @search_query = params[:q] || params[:account_id]
+
+    @limit = 50
+    if @search_query.blank?
+      max_nb_records = Kaui::Payment.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records
+      @offset = [0, max_nb_records - @limit].max
+      @ordering = 'desc'
+    else
+      @offset = 0
+      @ordering = 'asc'
+    end
   end
 
   def pagination
     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?
-        payments = Kaui::Payment.list_or_search(search_key, offset, limit, options_for_klient)
+      if Kaui::Payment::TRANSACTION_STATUSES.include?(search_key)
+        # Search is done by payment state on the server side, see http://docs.killbill.io/latest/userguide_payment.html#_payment_states
+        payment_state = if %w(PLUGIN_FAILURE UNKNOWN).include?(search_key)
+                          '_ERRORED'
+                        elsif search_key == 'PAYMENT_FAILURE'
+                          '_FAILED'
+                        else
+                          '_' + search_key
+                        end
+        payments = Kaui::Payment.list_or_search(payment_state, offset, limit, options_for_klient)
+        payments.reject! { |payment| payment.transactions[-1].status != search_key }
       else
-        payments = account.payments(options_for_klient).map! { |payment| Kaui::Payment.build_from_raw_payment(payment) }
+        account = Kaui::Account::find_by_id_or_key(search_key, false, false, options_for_klient) rescue nil
+        if account.nil?
+          payments = Kaui::Payment.list_or_search(search_key, offset, limit, options_for_klient)
+        else
+          payments = account.payments(options_for_klient).map! { |payment| Kaui::Payment.build_from_raw_payment(payment) }
+        end
       end
 
       payments.each do |payment|
@@ -65,11 +88,12 @@ class Kaui::PaymentsController < Kaui::EngineController
   end
 
   def show
-    @payment = Kaui::InvoicePayment.build_from_raw_payment(Kaui::InvoicePayment.find_by_id(params.require(:id), true, true, options_for_klient))
+    invoice_payment = Kaui::InvoicePayment.find_safely_by_id(params.require(:id), options_for_klient)
+    @payment = Kaui::InvoicePayment.build_from_raw_payment(invoice_payment)
 
     fetch_account = lambda { @account = Kaui::Account.find_by_id(@payment.account_id, false, false, options_for_klient) }
     # The payment method may have been deleted
-    fetch_payment_method = lambda { @payment_method = Kaui::PaymentMethod.find_by_id(@payment.payment_method_id, true, options_for_klient) rescue nil }
+    fetch_payment_method = lambda { @payment_method = Kaui::PaymentMethod.find_safely_by_id(@payment.payment_method_id, options_for_klient) }
 
     run_in_parallel fetch_account, fetch_payment_method
   end

data/app/controllers/kaui/queues_controller.rb

@@ -0,0 +1,11 @@
+class Kaui::QueuesController < Kaui::EngineController
+
+  def index
+    @account_id = params[:account_id]
+    @now = Kaui::Admin.get_clock(nil, options_for_klient)['currentUtcTime'].to_datetime
+
+    min_date = params[:min_date]
+    with_history = params[:with_history] || false
+    @queues_entries = Kaui::Admin.get_queues_entries(@account_id, options_for_klient.merge(:withHistory => with_history, :minDate => min_date))
+  end
+end

data/app/controllers/kaui/subscriptions_controller.rb

@@ -77,8 +77,10 @@ class Kaui::SubscriptionsController < Kaui::EngineController
 
   def destroy
     requested_date = params[:requested_date].presence
-    entitlement_policy = params[:policy].presence
-    billing_policy = entitlement_policy
+    billing_policy = params[:policy].presence
+    # START_OF_TERM is *not* a valid entitlement_policy and so would default to IMMEDIATE
+    entitlement_policy = billing_policy && billing_policy == 'START_OF_TERM' ? 'IMMEDIATE' : billing_policy
+
     # true by default
     use_requested_date_for_billing = (params[:use_requested_date_for_billing] || '1') == '1'
 
@@ -97,6 +99,22 @@ class Kaui::SubscriptionsController < Kaui::EngineController
     redirect_to kaui_engine.account_bundles_path(subscription.account_id), :notice => 'Subscription was successfully reinstated'
   end
 
+  def edit_bcd
+    @subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
+  end
+
+  def update_bcd
+    input_subscription = params.require(:subscription)
+    subscription =  Kaui::Subscription.new
+    subscription.subscription_id = params.require(:id)
+    subscription.bill_cycle_day_local = input_subscription["bill_cycle_day_local"]
+
+    effective_from_date = params["effective_from_date"]
+
+    subscription.update_bcd(current_user.kb_username, params[:reason], params[:comment], effective_from_date, nil, options_for_klient)
+    redirect_to kaui_engine.account_bundles_path(input_subscription["account_id"]), :notice => 'Subscription BCD was successfully changed'
+  end
+
   def show
     restful_show
   end

data/app/controllers/kaui/tags_controller.rb

@@ -1,6 +1,17 @@
 class Kaui::TagsController < Kaui::EngineController
 
   def index
+    @search_query = params[:q]
+
+    @limit = 50
+    if @search_query.blank?
+      max_nb_records = Kaui::Tag.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records
+      @offset = [0, max_nb_records - @limit].max
+      @ordering = 'desc'
+    else
+      @offset = 0
+      @ordering = 'asc'
+    end
   end
 
   def pagination

data/app/controllers/kaui/transactions_controller.rb

@@ -1,12 +1,24 @@
 class Kaui::TransactionsController < Kaui::EngineController
 
+  def restful_show
+    payment = Kaui::Payment.find_by_transaction_id(params.require(:id), false, true, options_for_klient)
+    redirect_to account_payment_path(payment.account_id, payment.payment_id)
+  end
+
   def new
     @account_id = params[:account_id]
     @payment_method_id = params[:payment_method_id]
-    @transaction = Kaui::Transaction.new(:payment_id => params[:payment_id],
-                                         :amount => params[:amount],
-                                         :currency => params[:currency],
-                                         :transaction_type => params[:transaction_type])
+
+    transaction_id = params[:transaction_id].presence
+    if transaction_id.nil?
+      @transaction = Kaui::Transaction.new(:payment_id => params[:payment_id],
+                                           :amount => params[:amount],
+                                           :currency => params[:currency],
+                                           :transaction_type => params[:transaction_type])
+    else
+      payment = Kaui::Payment.find_by_transaction_id(transaction_id, false, false, options_for_klient)
+      @transaction = Kaui::Transaction.build_from_raw_transaction(payment.transactions.find { |tx| tx.transaction_id == transaction_id })
+    end
   end
 
   def create
@@ -15,4 +27,15 @@ class Kaui::TransactionsController < Kaui::EngineController
     payment = transaction.create(params.require(:account_id), params[:payment_method_id], current_user.kb_username, params[:reason], params[:comment], options_for_klient)
     redirect_to kaui_engine.account_payment_path(payment.account_id, payment.payment_id), :notice => 'Transaction successfully created'
   end
+
+  def fix_transaction_state
+    transaction = Kaui::Transaction.new(params[:transaction].delete_if { |key, value| value.blank? })
+    payment_id = transaction.payment_id
+    transaction_id = transaction.transaction_id
+    transaction_status = transaction.status
+
+    Kaui::Admin.fix_transaction_state(payment_id, transaction_id, transaction_status, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+
+    redirect_to kaui_engine.account_payment_path(params.require(:account_id), payment_id), :notice => "Transaction successfully transitioned to #{transaction_status}"
+  end
 end