kaui 0.15.5 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 156564f2fffc9ed94c485edefc7d203528625c26
-  data.tar.gz: f0384c9f2e24c0a68346becaa2c6a823ec4b5ed9
+  metadata.gz: '02096d784525a4eaa7d45645e56699a9c7913ee9'
+  data.tar.gz: 584dd82a66ca09755b318672908b013b7592c4d9
 SHA512:
-  metadata.gz: 3e4931a11ef92ca0dd389d9b63ca96a73213fb978c8c77aa7f6da209b6f2beec685c07fb7806cf51fcb7a4c0cd4948968156a7045779eff2ab65341ed4aca7bc
-  data.tar.gz: 040d8c650dd2a709828d98f4270eccf9a6d981a3c7df388273680ae2d6aef65d0fa6c9e760cfa547bdecf7abdcd9ea6e2fb06328701a82fb18df3ea34532d2c1
+  metadata.gz: d2e52f6432a66ce3a535bf6c62522f475e7dfa254ae34621498f89cae7b4edf7ea8087c730968778d92bbb96991a8036e96569cf4cdee71bf0e6a39805596b3f
+  data.tar.gz: 6259714f3f8fc9263de0fcdb7eaf72254a0645707f99a7f7db8f219b04b809a240f7dd9223d1cd73aa75b43bf494d351548c3a9c10b9013530359c3a0a1b71c7

data/README.md

@@ -9,23 +9,32 @@ Kill Bill compatibility
 | Kaui version | Kill Bill version |
 | -----------: | ----------------: |
 | 0.14.y       | 0.16.z            |
-| 0.15.y       | 0.18.z            |
+| 0.15.y       | 0.18.z (Rails 4)  |
+| 0.16.y       | 0.18.z (Rails 5)  |
+
+
+Dependencies
+------------
+
+Ruby 2.2.2+ or JRuby 9.1.9.0+ required.
 
 Running Kaui locally
 ---------------------
 
 You can run Kaui locally by using the test/dummy app provided:
+
 ```
-bundle install
-cd test/dummy
 export RAILS_ENV=development
 bundle install
-rake kaui:install:migrations
-rake db:migrate
-bundle exec rake assets:precompile
-rails server
+rails db:migrate
+rails s
 ```
 
+The Kill Bill URL can be configured through the `KILLBILL_URL` environment variable, e.g.
+
+```
+KILLBILL_URL='http://killbill.acme:8080'
+```
 
 Mounting Kaui into your own Rails app
 -------------------------------------
@@ -35,44 +44,23 @@ The Kaui gem comes with a `kaui` script to mount it in your existing Rails app.
 Kaui expects the container app to define the <tt>current_user</tt> method, which returns the
 name of the logged-in user. This is used by Kill Bill for auditing purposes.
 
-Finally, a Kill Bill server needs to be running for Kaui to fetch its information (see the Configuration section below).
-The default login credentials are admin/password.  Users, Credentials, Roles and Permissions are 
-passed through to Kill Bill. It uses Basic Auth by default, but the backend is pluggable (LDAP, 
-ActiveDirectory, etc.).
-
-
-Configuration
--------------
-
-Specify your Kill Bill server url, api key and secret in ```config/initializers/killbill_client.rb```:
+Migrations can be copied over to your app via:
 
 ```
-KillBillClient.url = 'http://127.0.0.1:8080/'
+bundle exec rake kaui:install:migrations
 ```
 
-Sharing a Kaui instance across multiple tenants is not supported yet (you need to spawn one instance per tenant).
+Finally, a Kill Bill server needs to be running for Kaui to fetch its information (see the Configuration section below).
+The default login credentials are admin/password.  Users, Credentials, Roles and Permissions are
+passed through to Kill Bill. It uses Basic Auth by default, but the backend is pluggable (LDAP,
+ActiveDirectory, etc.).
 
 
 Running tests
 -------------
 
-Go into 'test/dummy': 
 ```
-cd test/dummy/
-```
-
-Run migrations:
-```
-export RAILS_ENV=test
-rake kaui:install:migrations
-rake db:migrate
-```
-
-Run the tests:
-(Move back to top level)
-```
-cd ../..
-rake test
+rails t
 ```
 
 Note: functional and integration tests require an instance of Kill Bill to test against.
@@ -99,7 +87,7 @@ Then, install and run it from a local directory:
 Alternatively, you can run the `kaui` script under `bin` by setting your loadpath correctly:
 
     ruby -Ilib bin/kaui /path/to/rails/app --path=$PWD --skip-bundle
-    
+
 Releases
 ========
 
@@ -123,7 +111,7 @@ Those roles and permissions are defined the same way other permissions are defin
 * TENANT_CAN_VIEW
 * TENANT_CAN_CREATE
 * OVERDUE_CAN_UPLOAD
-* CATALOG_CAN_UPLOAD 
+* CATALOG_CAN_UPLOAD
 
 The [enforcement in KAUI](https://github.com/killbill/killbill-admin-ui/blob/master/app/models/kaui/ability.rb) is based on the CanCan gem.
 

data/app/assets/javascripts/application.js

@@ -6,11 +6,10 @@
 //
 //= require js-routes
 //= require jquery
-//= require jquery-ui/autocomplete
+//= require jquery-ui/widgets/autocomplete
 //= require jquery_ujs
 //= require dataTables/jquery.dataTables
 //= require dataTables/bootstrap/3/jquery.dataTables.bootstrap
-//= require d3
 //= require twitter/bootstrap
 //= require bootstrap-datepicker
 //= require kaui/bootstrap-tweaks

data/app/assets/javascripts/kaui/kaui.js

@@ -96,4 +96,91 @@ jQuery(document).ready(function ($) {
         }
     });
 
+    /*
+     * Toggle between combobox (US only) and text when entering the state.
+     */
+    $('#account_country').on('change', function(e){
+        toggle_state_input_type($('#account_country').val());
+    });
+
+    function toggle_state_input_type(state){
+        if (state == 'US'){
+            $('.text-state').hide().attr('name','hide');
+            $('.select-state').show().attr('name','account[state]');
+        }else{
+            $('.select-state').hide().attr('name','hide');
+            $('.text-state').show().attr('name','account[state]');
+        }
+    }
+
+    toggle_state_input_type($('#account_country').val());
+
+    /*
+     * Calculate first name length
+     */
+    $('#account_name').on('keyup', function(e){
+        set_first_name_length($(this).val());
+    });
+
+    $('#account_name').on('change', function(e){
+        if ($('#account_first_name_length').empty() ){
+            set_first_name_length($(this).val());
+        }
+    });
+
+    function set_first_name_length(name){
+        var name_in_parts = name.trim().split(' ');
+
+        if (name_in_parts.length > 1){
+            $('#account_first_name_length').val(name_in_parts[0].length);
+        }else{
+            $('#account_first_name_length').val('');
+        }
+    }
+
+    /*
+     *  Validate external key
+     */
+    const VALIDATE_EXTERNAL_KEY = {
+        account: { url: Routes.kaui_engine_accounts_validate_external_key_path(), invalid_msg_class_name: '.account_external_key_invalid_msg' },
+        payment_method: {url: Routes.kaui_engine_payment_methods_validate_external_key_path(), invalid_msg_class_name: '.payment_method_external_key_invalid_msg'},
+        subscription: {url: Routes.kaui_engine_subscriptions_validate_external_key_path(), invalid_msg_class_name: '.subscription_external_key_invalid_msg'}
+    }
+
+    validate_external_key($('#account_external_key').val(),'account');
+    $('#account_external_key').on('change', function(e){
+        validate_external_key($(this).val(),'account');
+    });
+
+    validate_external_key($('#payment_method_external_key').val(),'payment_method');
+    $('#payment_method_external_key').on('change', function(e){
+        validate_external_key($(this).val(),'payment_method');
+    });
+
+    validate_external_key($('#external_key').val(),'subscription');
+    $('#external_key').on('change', function(e){
+        validate_external_key($(this).val(),'subscription');
+    });
+
+    function validate_external_key(external_key, key_for){
+        if (external_key == undefined || external_key == null || external_key.trim().length == 0){
+            $(VALIDATE_EXTERNAL_KEY[key_for].invalid_msg_class_name).hide();
+        }else {
+            $.ajax(
+                {
+                    url: VALIDATE_EXTERNAL_KEY[key_for].url,
+                    type: "GET",
+                    dataType: "json",
+                    data: {external_key: external_key},
+                    success: function (data) {
+                        if (data.is_found) {
+                            $(VALIDATE_EXTERNAL_KEY[key_for].invalid_msg_class_name).show();
+                        } else {
+                            $(VALIDATE_EXTERNAL_KEY[key_for].invalid_msg_class_name).hide();
+                        }
+                    }
+                });
+        }
+    }
+
 })

data/app/assets/stylesheets/{bootstrap_and_overrides.less → bootstrap_and_overrides.css.less}

@@ -12,16 +12,16 @@
 @fontAwesomeSvgPath: font-url("fontawesome-webfont.svg#fontawesomeregular");
 
 // Font Awesome
-@import "fontawesome/font-awesome";
+@import "font-awesome.css";
 
 /* Override Bootstrap 3 font locations */
 @font-face {
   font-family: 'Glyphicons Halflings';
-  src: url('../assets/glyphicons-halflings-regular.eot');
-  src: url('../assets/glyphicons-halflings-regular.eot?#iefix') format('embedded-opentype'),
-  url('../assets/glyphicons-halflings-regular.woff') format('woff'),
-  url('../assets/glyphicons-halflings-regular.ttf') format('truetype'),
-  url('../assets/glyphicons-halflings-regular.svg#glyphicons_halflingsregular') format('svg');
+  src: image-url('glyphicons-halflings-regular.eot');
+  src: image-url('glyphicons-halflings-regular.eot?#iefix') format('embedded-opentype'),
+  image-url('glyphicons-halflings-regular.woff') format('woff'),
+  image-url('glyphicons-halflings-regular.ttf') format('truetype'),
+  image-url('glyphicons-halflings-regular.svg#glyphicons_halflingsregular') format('svg');
 }
 
 // Glyphicons

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

@@ -0,0 +1,20 @@
+h1 span.account-child-label{
+  float: right;
+}
+
+.account-child-label{
+  color: white !important;
+}
+
+.naked {
+  background-color: transparent;
+  color: #00919d;
+  padding: 0;
+  font-size: inherit;
+}
+
+.naked:hover{
+  background-color: transparent;
+  color: #2a6496;
+
+}

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

@@ -14,3 +14,6 @@
 @import "timeline.less";
 
 @import "datatable.less";
+
+@import "account.less";
+@import "overdue.less";

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

@@ -0,0 +1,9 @@
+#existing-overdue-config-for-tenants.table tr td>select{
+  max-width: 140px;
+}
+
+#existing-overdue-config-for-tenants.table tr td>input[type=number]{
+  max-width: 100px;
+}
+
+

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

@@ -27,3 +27,13 @@
         }
     }
 }
+
+.gateway-link {
+    float: right;
+    padding-top: 5px;
+
+    span {
+        padding: 5px 20px;
+        text-align: center;
+    }
+}

data/app/controllers/kaui/account_children_controller.rb

@@ -0,0 +1,50 @@
+
+class Kaui::AccountChildrenController < Kaui::EngineController
+
+  def index
+
+    # check that the required parent account id is provided and get its data
+    begin
+      @account = Kaui::Account::find_by_id(params.require(:account_id), false, false, options_for_klient)
+    rescue KillBillClient::API::NotFound
+      flash[:error] = "Invalid parent account id supplied #{params.require(:account_id)}"
+      redirect_to kaui_engine.home_path and return
+    end
+
+  end
+
+  # It will fetch all the children. It use the paginate to fetch all children as permitting for future exchange
+  # when killbill account/{account_id}/children endpoint includes offset and limit parameters.
+  def pagination
+
+    searcher = lambda do |parent_account_id, offset, limit|
+      Kaui::Account.find_children(parent_account_id, true, true, 'NONE', options_for_klient)
+    end
+
+    data_extractor = lambda do |account_child, column|
+      [
+          account_child.name,
+          account_child.account_id,
+          account_child.external_key,
+          account_child.account_balance,
+          account_child.city,
+          account_child.country
+      ][column]
+    end
+
+    formatter = lambda do |account_child|
+      [
+          view_context.link_to(account_child.name || '(not set)', account_path(account_child.account_id)),
+          view_context.truncate_uuid(account_child.account_id),
+          account_child.external_key,
+          view_context.humanized_money_with_symbol(account_child.balance_to_money),
+          account_child.city,
+          account_child.country
+      ]
+    end
+
+    paginate searcher, data_extractor, formatter
+  end
+
+
+end

data/app/controllers/kaui/account_tags_controller.rb

@@ -3,10 +3,11 @@ class Kaui::AccountTagsController < Kaui::EngineController
   def edit
     @account_id = params.require(:account_id)
 
-    fetch_tag_names = lambda { @tag_names = (Kaui::Tag.all_for_account(@account_id, false, 'NONE', options_for_klient).map { |tag| tag.tag_definition_name }).sort }
-    fetch_available_tags = lambda { @available_tags = Kaui::TagDefinition.all_for_account(options_for_klient) }
+    fetch_tag_names = promise { (Kaui::Tag.all_for_account(@account_id, false, 'NONE', options_for_klient).map { |tag| tag.tag_definition_name }).sort }
+    fetch_available_tags = promise { Kaui::TagDefinition.all_for_account(options_for_klient) }
 
-    run_in_parallel fetch_tag_names, fetch_available_tags
+    @tag_names = wait(fetch_tag_names)
+    @available_tags = wait(fetch_available_tags)
   end
 
   def update

data/app/controllers/kaui/account_timelines_controller.rb

@@ -25,9 +25,7 @@ class Kaui::AccountTimelinesController < Kaui::EngineController
       end
     end
 
-    if params.has_key?(:external_key)
-      @selected_bundle = @bundle_names[params[:external_key]]
-    end
+    @selected_bundle = params.has_key?(:external_key) ? @bundle_names[params[:external_key]] : nil
   end
 
   private

data/app/controllers/kaui/accounts_controller.rb

@@ -27,6 +27,7 @@ class Kaui::AccountsController < Kaui::EngineController
 
     data_extractor = lambda do |account, column|
       [
+          account.parent_account_id,
           account.name,
           account.account_id,
           account.external_key,
@@ -38,6 +39,7 @@ class Kaui::AccountsController < Kaui::EngineController
 
     formatter = lambda do |account|
       [
+          account.parent_account_id.nil? ? 0 : 1,
           view_context.link_to(account.name || '(not set)', view_context.url_for(:action => :show, :account_id => account.account_id)),
           view_context.truncate_uuid(account.account_id),
           account.external_key,
@@ -59,10 +61,10 @@ class Kaui::AccountsController < Kaui::EngineController
 
     # Transform "1" into boolean
     @account.is_migrated = @account.is_migrated == '1'
-    @account.is_notified_for_invoices = @account.is_notified_for_invoices == '1'
 
     begin
       @account = @account.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+
       redirect_to account_path(@account.account_id), :notice => 'Account was successfully created'
     rescue => e
       flash.now[:error] = "Error while creating account: #{as_string(e)}"
@@ -71,15 +73,73 @@ class Kaui::AccountsController < Kaui::EngineController
   end
 
   def show
+    # Go to the database once
+    cached_options_for_klient = options_for_klient
+
     # Re-fetch the account with balance and CBA
-    @account = Kaui::Account::find_by_id_or_key(params.require(:account_id), true, true, options_for_klient)
+    @account = Kaui::Account::find_by_id_or_key(params.require(:account_id), true, true, cached_options_for_klient)
+
+    fetch_children = promise { @account.children(false, false, 'NONE',cached_options_for_klient)}
+    fetch_parent = promise (!@account.parent_account_id.nil?){ Kaui::Account::find_by_id(@account.parent_account_id,false,false,cached_options_for_klient)}
+    fetch_overdue_state = promise { @account.overdue(cached_options_for_klient) }
+    fetch_account_tags = promise { @account.tags(false, 'NONE', cached_options_for_klient).sort { |tag_a, tag_b| tag_a <=> tag_b } }
+    fetch_account_fields = promise { @account.custom_fields('NONE', cached_options_for_klient).sort { |cf_a, cf_b| cf_a.name.downcase <=> cf_b.name.downcase } }
+    fetch_account_emails = promise { Kaui::AccountEmail.find_all_sorted_by_account_id(@account.account_id, 'NONE', cached_options_for_klient) }
+    fetch_payments = promise { @account.payments(cached_options_for_klient).map! { |payment| Kaui::Payment.build_from_raw_payment(payment) } }
+    fetch_payment_methods = promise(false) { Kaui::PaymentMethod.find_all_by_account_id(@account.account_id, false, cached_options_for_klient) }
+
+    # is email notification plugin available
+    is_email_notifications_plugin_available = Kenui::EmailNotificationService.email_notification_plugin_available?(cached_options_for_klient).first
+    fetch_email_notification_configuration = promise(is_email_notifications_plugin_available) do
+      Kenui::EmailNotificationService.get_configuration_per_account(params.require(:account_id),cached_options_for_klient)
+    end.then do |configuration|
+      if configuration.first.is_a?(FalseClass)
+        Rails.logger.warn(configuration[1])
+        configuration = []
+      end
+      configuration
+    end
+
+    fetch_payment_methods_with_details = fetch_payment_methods.then do |pms|
+      ops = []
+      pms.each do |pm|
+        ops << promise(false) {
+          begin
+            Kaui::PaymentMethod.find_by_id(pm.payment_method_id, true, cached_options_for_klient)
+          rescue => e
+            # Maybe the plugin is not registered or the plugin threw an exception
+            Rails.logger.warn(e)
+            nil
+          end
+        }
+      end
+      ops
+    end
+    fetch_available_tags = promise { Kaui::TagDefinition.all_for_account(cached_options_for_klient) }
+
+    @overdue_state = wait(fetch_overdue_state)
+    @tags = wait(fetch_account_tags)
+    @custom_fields = wait(fetch_account_fields)
+    @account_emails = wait(fetch_account_emails)
+    wait(fetch_payment_methods)
+    @payment_methods = wait(fetch_payment_methods_with_details).map { |pm_f| pm_f.execute }.map { |pm_f| wait(pm_f) }.reject { |pm| pm.nil? }
+    @available_tags = wait(fetch_available_tags)
+    @children = wait(fetch_children)
+    @account_parent = wait(fetch_parent) unless @account.parent_account_id.nil?
+    @email_notification_configuration = wait(fetch_email_notification_configuration) if is_email_notifications_plugin_available
+
+    @last_transaction_by_payment_method_id = {}
+    wait(fetch_payments).each do |payment|
+      transaction = payment.transactions.last
+      transaction_date = Date.parse(transaction.effective_date)
+
+      last_seen_transaction_date = @last_transaction_by_payment_method_id[payment.payment_method_id]
+      if last_seen_transaction_date.nil? || Date.parse(last_seen_transaction_date.effective_date) < transaction_date
+        @last_transaction_by_payment_method_id[payment.payment_method_id] = transaction
+      end
+    end
 
-    fetch_overdue_state = lambda { @overdue_state = @account.overdue(options_for_klient) }
-    fetch_account_tags = lambda { @tags = @account.tags(false, 'NONE', options_for_klient).sort { |tag_a, tag_b| tag_a <=> tag_b } }
-    fetch_account_emails = lambda { @account_emails = Kaui::AccountEmail.find_all_sorted_by_account_id(@account.account_id, 'NONE', options_for_klient) }
-    fetch_payment_methods = lambda { @payment_methods = Kaui::PaymentMethod.find_all_safely_by_account_id(@account.account_id, options_for_klient) }
-    fetch_available_tags = lambda { @available_tags = Kaui::TagDefinition.all_for_account(options_for_klient) }
-    run_in_parallel fetch_overdue_state, fetch_account_tags, fetch_account_emails, fetch_payment_methods, fetch_available_tags
+    params.permit!
   end
 
   def trigger_invoice
@@ -124,7 +184,6 @@ class Kaui::AccountsController < Kaui::EngineController
 
     # Transform "1" into boolean
     @account.is_migrated = @account.is_migrated == '1'
-    @account.is_notified_for_invoices = @account.is_notified_for_invoices == '1'
 
     @account.update(true, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
 
@@ -143,14 +202,6 @@ class Kaui::AccountsController < Kaui::EngineController
     redirect_to account_path(account_id), :notice => "Successfully set #{payment_method_id} as default"
   end
 
-  def toggle_email_notifications
-    account = Kaui::Account.new(:account_id => params.require(:account_id), :is_notified_for_invoices => params[:is_notified] == 'true')
-
-    account.update_email_notifications(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-
-    redirect_to account_path(account.account_id), :notice => 'Email preferences updated'
-  end
-
   def pay_all_invoices
     payment = Kaui::InvoicePayment.new(:account_id => params.require(:account_id))
 
@@ -158,4 +209,96 @@ class Kaui::AccountsController < Kaui::EngineController
 
     redirect_to account_path(payment.account_id), :notice => 'Successfully triggered a payment for all unpaid invoices'
   end
+
+  def validate_external_key
+    external_key = params.require(:external_key)
+
+    begin
+      account = Kaui::Account::find_by_external_key(external_key, false, false, options_for_klient)
+    rescue KillBillClient::API::NotFound
+      account = nil
+    end
+    render json: {:is_found => !account.nil?}
+
+  end
+
+  def link_to_parent
+    @account = Kaui::Account.new(params.require(:account).delete_if { |key, value| value.blank? })
+    @account.account_id = params.require(:account_id)
+    @account.is_payment_delegated_to_parent = @account.is_payment_delegated_to_parent == '1'
+
+    raise('Account id and account parent id cannot be equal.') if @account.account_id == @account.parent_account_id
+
+    # check if parent id is valid
+    Kaui::Account.find_by_id(@account.parent_account_id,false,false,options_for_klient)
+
+    @account.update(false, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+
+    redirect_to account_path(@account.account_id), :notice => 'Account successfully updated'
+  rescue => e
+    if e.is_a?(KillBillClient::API::NotFound)
+      flash[:error] = "Parent account id not found: #{@account.parent_account_id}"
+    else
+      flash[:error] = "Error while linking parent account: #{as_string(e)}"
+    end
+    redirect_to account_path(@account.account_id)
+  end
+
+  def unlink_to_parent
+    account_id = params.require(:account_id)
+
+    # search for the account and remove the parent account id
+    # check if parent id is valid
+    account = Kaui::Account.find_by_id(account_id,false,false,options_for_klient)
+    account.is_payment_delegated_to_parent = false
+    account.parent_account_id = nil
+    account.update(true, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+
+    redirect_to account_path(@account.account_id), :notice => 'Account successfully updated'
+  rescue => e
+    flash[:error] = "Error while un-linking parent account: #{as_string(e)}"
+    redirect_to account_path(@account.account_id)
+  end
+
+  def set_email_notifications_configuration
+    configuration = params.require(:configuration)
+    account_id = configuration[:account_id]
+    event_types = configuration[:event_types]
+    cached_options_for_klient = options_for_klient
+
+    is_success, message = email_notification_plugin_available?(cached_options_for_klient)
+
+    is_success, message = Kenui::EmailNotificationService.set_configuration_per_account(account_id,
+                                                                                        event_types,
+                                                                                      current_user.kb_username,
+                                                                                      params[:reason],
+                                                                                      params[:comment],
+                                                                                        cached_options_for_klient) if is_success
+    if is_success
+      flash[:notice] = message
+    else
+      flash[:error] = message
+    end
+    redirect_to account_path(account_id)
+  end
+
+  def events_to_consider
+    data = Kenui::EmailNotificationService.get_events_to_consider(options_for_klient)
+
+    respond_to do |format|
+      format.json { render json: { data: data} }
+    end
+  end
+
+  private
+
+    def email_notification_plugin_available?(options_for_klient)
+      error_message = 'Email notification plugin is not installed'
+
+      is_available = Kenui::EmailNotificationService.email_notification_plugin_available?(options_for_klient).first
+      return is_available, is_available ? nil : error_message
+    rescue => e
+      return false, error_message
+    end
+
 end