kaui 0.16.2 → 1.0.0

data/app/controllers/kaui/admin_tenants_controller.rb

@@ -50,6 +50,10 @@ class Kaui::AdminTenantsController < Kaui::EngineController
       tenant_model.save!
       # Make sure at least the current user can access the tenant
       tenant_model.kaui_allowed_users << Kaui::AllowedUser.where(:kb_username => current_user.kb_username).first_or_create
+    rescue KillBillClient::API::Conflict => e
+      # tenant api_key was found but has a wrong api_secret
+      flash[:error] = "Submitted credentials for #{param_tenant[:api_key]} did not match the expected credentials."
+      redirect_to admin_tenants_path and return
     rescue => e
       flash[:error] = "Failed to create the tenant: #{as_string(e)}"
       redirect_to admin_tenants_path and return
@@ -73,18 +77,26 @@ class Kaui::AdminTenantsController < Kaui::EngineController
     options[:api_key] = @tenant.api_key
     options[:api_secret] = @tenant.api_secret
 
-    fetch_catalogs = promise { Kaui::Catalog::get_catalog_json(false, options) rescue @catalogs = [] }
-    fetch_catalogs_xml = promise { Kaui::Catalog::get_catalog_xml(options) rescue @catalogs_xml = [] }
+    fetch_catalog_versions = promise { Kaui::Catalog::get_tenant_catalog_versions(options) rescue @catalog_versions = []}
     fetch_overdue = promise { Kaui::Overdue::get_overdue_json(options) rescue @overdue = nil }
     fetch_overdue_xml = promise { Kaui::Overdue::get_tenant_overdue_config('xml', options) rescue @overdue_xml = nil }
 
     plugin_repository = Kaui::AdminTenant::get_plugin_repository
+    # hack:: replace paypal key with paypal_express, to set configuration and allow the ui to find the right configuration inputs
+    plugin_repository = plugin_repository.inject({}) { |p, (k,v)| p[k.to_s.sub(/\Apaypal/, 'paypal_express').to_sym] = v; p }
+
 
     fetch_plugin_config = promise { Kaui::AdminTenant::get_oss_plugin_info(plugin_repository) }
     fetch_tenant_plugin_config = promise { Kaui::AdminTenant::get_tenant_plugin_config(plugin_repository, options) }
 
-    @catalogs = wait(fetch_catalogs)
-    @catalogs_xml = wait(fetch_catalogs_xml)
+    @catalog_versions = []
+    wait(fetch_catalog_versions).each_with_index do |effective_date, idx|
+      @catalog_versions << {:version => idx,
+                            :version_date => effective_date}
+    end
+
+    @latest_version = @catalog_versions[@catalog_versions.length - 1][:version_date] rescue nil
+
     @overdue = wait(fetch_overdue)
     @overdue_xml = wait(fetch_overdue_xml)
     @plugin_config = wait(fetch_plugin_config) rescue ''
@@ -118,7 +130,7 @@ class Kaui::AdminTenantsController < Kaui::EngineController
     options[:api_key] = @tenant.api_key
     options[:api_secret] = @tenant.api_secret
 
-    latest_catalog = Kaui::Catalog::get_catalog_json(true, options)
+    latest_catalog = Kaui::Catalog::get_catalog_json(true, nil, options)
 
     @ao_mapping = Kaui::Catalog::build_ao_mapping(latest_catalog)
 
@@ -163,7 +175,7 @@ class Kaui::AdminTenantsController < Kaui::EngineController
     options[:api_key] = @tenant.api_key
     options[:api_secret] = @tenant.api_secret
 
-    catalog = Kaui::Catalog::get_catalog_json(true, options)
+    catalog = Kaui::Catalog::get_catalog_json(true, nil, options)
 
     # seek if plan id exists
     catalog.products.each do |product|
@@ -300,11 +312,11 @@ class Kaui::AdminTenantsController < Kaui::EngineController
     plugin_name = params[:plugin_name]
     plugin_properties = params[:plugin_properties]
     plugin_type = params[:plugin_type]
+    plugin_key = params[:plugin_key]
 
-    plugin_config = Kaui::AdminTenant.format_plugin_config(plugin_name, plugin_type, plugin_properties)
+    plugin_config = Kaui::AdminTenant.format_plugin_config(plugin_key, plugin_type, plugin_properties)
 
-    key = plugin_type.present? ? "killbill-#{plugin_name}" : plugin_name
-    Kaui::AdminTenant.upload_tenant_plugin_config(key, plugin_config, options[:username], nil, comment, options)
+    Kaui::AdminTenant.upload_tenant_plugin_config(plugin_name, plugin_config, options[:username], nil, comment, options)
 
     redirect_to admin_tenant_path(current_tenant.id), :notice => 'Config for plugin was successfully uploaded'
   end
@@ -323,9 +335,53 @@ class Kaui::AdminTenantsController < Kaui::EngineController
     render :json => '{}', :status => 200
   end
 
+  def add_allowed_user
+    current_tenant = safely_find_tenant_by_id(params[:tenant_id])
+    allowed_user = Kaui::AllowedUser.find_by_kb_username(params.require(:allowed_user).require(:kb_username))
+
+    if !current_user.root?
+      flash[:error] = 'Only the root user can add users from tenants'
+      redirect_to admin_tenant_path(current_tenant.id)
+      return
+    end
+
+    if allowed_user.nil?
+      flash[:error] = "User #{params.require(:allowed_user).require(:kb_username)} does not exist!"
+      redirect_to admin_tenant_path(current_tenant.id)
+      return
+    end
+
+    tenants_ids = allowed_user.kaui_tenants.map(&:id) || []
+    tenants_ids << current_tenant.id
+    allowed_user.kaui_tenant_ids = tenants_ids
+    redirect_to admin_tenant_path(current_tenant.id), :notice => 'Allowed user was successfully added'
+  end
+
+  def allowed_users
+    json_response do
+      tenant = safely_find_tenant_by_id(params[:tenant_id])
+      actual_allowed_users = tenant.kaui_allowed_users.map {|au| au.id}
+
+      retrieve_allowed_users_for_current_user.select {|au| !actual_allowed_users.include? au.id }
+    end
+  end
+
   def display_catalog_xml
-    @catalog_xml = params.require(:xml)
-    render xml: @catalog_xml
+    current_tenant = safely_find_tenant_by_id(params[:id])
+    effective_date = params.require(:effective_date)
+
+    options = tenant_options_for_client
+    options[:api_key] = current_tenant.api_key
+    options[:api_secret] = current_tenant.api_secret
+
+    response = Kaui::Catalog.get_catalog_xml(effective_date, options) rescue response = {}
+
+    catalog_xml = {}
+    unless response.nil? && response.size > 0
+      catalog_xml = response[0][:xml]
+    end
+
+    render xml: catalog_xml
   end
 
 
@@ -333,6 +389,56 @@ class Kaui::AdminTenantsController < Kaui::EngineController
     render xml: params.require(:xml)
   end
 
+  def catalog_by_effective_date
+    json_response do
+      current_tenant = safely_find_tenant_by_id(params[:id])
+      effective_date = params.require(:effective_date)
+
+      options = tenant_options_for_client
+      options[:api_key] = current_tenant.api_key
+      options[:api_secret] = current_tenant.api_secret
+
+      catalog = []
+      result = Kaui::Catalog::get_catalog_json(false, effective_date, options) rescue catalog = []
+
+      # convert result to a full hash since dynamic attributes of a class are ignored when converting to json
+      result.each do |data|
+        plans = []
+        data[:plans].each do |plan|
+          plans << plan.instance_variables.each_with_object({}) {|var, hash_plan| hash_plan[var.to_s.delete("@")] = plan.instance_variable_get(var) }
+        end
+
+        catalog << {:version_date => data[:version_date],
+            :currencies => data[:currencies],
+            :plans => plans
+          }
+      end
+
+      {:catalog => catalog }
+    end
+  end
+
+  def suggest_plugin_name
+    json_response do
+      message = nil
+      entered_plugin_name = params.require(:plugin_name)
+      plugin_repository = view_context.plugin_repository
+
+      found_plugin, weights = fuzzy_match(entered_plugin_name, plugin_repository)
+
+      if weights.size > 0
+        plugin_anchor = view_context.link_to(weights[0][:plugin_name], '#', id: 'suggested',
+                                            data: {
+                                                plugin_name: weights[0][:plugin_name],
+                                                plugin_key: weights[0][:plugin_key],
+                                                plugin_type: weights[0][:plugin_type],
+                                            })
+        message = "Similar plugin already installed: '#{plugin_anchor}'" if weights[0][:worth_weight].to_f >= 1.0 && weights[0][:installed]
+        message = "Did you mean '#{plugin_anchor}'?" if weights[0][:worth_weight].to_f < 1.0 || !weights[0][:installed]
+      end
+      { suggestion: message, plugin: found_plugin }
+    end
+  end
 
   private
 
@@ -365,4 +471,39 @@ class Kaui::AdminTenantsController < Kaui::EngineController
     end
   end
 
+  def split_camel_dash_underscore_space(data)
+    data.split(/(?=[A-Z])|(?=[_])|(?=[-])|(?=[ ])/).select {|member| !member.gsub(/[_-]/,'').strip.empty?}.map { |member| member.gsub(/[_-]/,'').strip.downcase }
+  end
+
+  def fuzzy_match(entered_plugin_name, plugin_repository)
+    splitted_entered_plugin_name = split_camel_dash_underscore_space(entered_plugin_name)
+    worth_of_non_words = 0.5 / splitted_entered_plugin_name.size.to_i
+
+    weights = []
+
+    plugin_repository.each do |plugin|
+      return plugin, [] if plugin[:plugin_name] == entered_plugin_name || plugin[:plugin_key] == entered_plugin_name
+
+      splitted_plugin_name = split_camel_dash_underscore_space(plugin[:plugin_name])
+      weight = { :plugin_name => plugin[:plugin_name], :plugin_key => plugin[:plugin_key],
+                 :plugin_type => plugin[:plugin_type], :installed => plugin[:installed], :worth_weight => 0.0 }
+      splitted_entered_plugin_name.each do |entered|
+        if splitted_plugin_name.include?(entered)
+          weight[:worth_weight] = weight[:worth_weight] + 1.0
+        end
+
+        splitted_plugin_name.each do |splitted|
+          if entered.chars.all? { |ch| splitted.include?(ch) }
+            weight[:worth_weight] = weight[:worth_weight] + worth_of_non_words
+            break
+          end
+        end
+      end
+      weights << weight if weight[:worth_weight] > 0
+
+    end
+
+    weights.sort! { |a,b| b[:worth_weight] <=> a[:worth_weight] } if weights.size > 1
+    return nil, weights
+  end
 end

data/app/controllers/kaui/audit_logs_controller.rb

@@ -0,0 +1,93 @@
+class Kaui::AuditLogsController < Kaui::EngineController
+  OBJECT_WITH_HISTORY = %w[ACCOUNT ACCOUNT_EMAIL CUSTOM_FIELD PAYMENT_ATTEMPT PAYMENT PAYMENT_METHOD TRANSACTION TAG TAG_DEFINITION]
+
+  def index
+    cached_options_for_klient = options_for_klient
+    @account = Kaui::Account::find_by_id_or_key(params.require(:account_id), false, false, cached_options_for_klient)
+    audit_logs = @account.audit(cached_options_for_klient)
+
+
+    formatter = lambda do |log|
+      object_id_text = view_context.content_tag(:span, view_context.truncate_uuid(log.object_id), title: log.object_id )
+      if object_with_history?(log.object_type)
+        object_id_text = view_context.link_to(object_id_text, '#showHistoryModal',
+                                              data: {
+                                                  toggle: 'modal',
+                                                  object_id: log.object_id,
+                                                  object_type: log.object_type,
+                                                  change_date: log.change_date,
+                                                  change_type: log.change_type,
+                                                  account_id: @account.account_id
+                                              })
+      end
+
+      [
+          log.change_date,
+          object_id_text,
+          log.object_type,
+          log.change_type,
+          log.changed_by,
+          log.reason_code,
+          log.comments,
+          view_context.content_tag(:span, view_context.truncate_uuid(log.user_token), title: log.user_token )
+      ]
+    end
+
+    @audit_logs_json = []
+    audit_logs.each { |page| @audit_logs_json << formatter.call(page) }
+
+    @audit_logs_json = @audit_logs_json.to_json
+  end
+
+  def history
+    json_response do
+      account_id = params.require(:account_id)
+      object_id = params.require(:object_id)
+      object_type = params.require(:object_type)
+      cached_options_for_klient = options_for_klient
+
+      audit_logs_with_history = []
+      error = nil
+      
+      begin
+        if object_type == 'ACCOUNT'
+          account = Kaui::Account::find_by_id_or_key(object_id, false, false, cached_options_for_klient)
+          audit_logs_with_history = account.audit_logs_with_history(cached_options_for_klient)
+        elsif object_type == 'ACCOUNT_EMAIL'
+          account = Kaui::Account::find_by_id_or_key(account_id, false, false, cached_options_for_klient)
+          audit_logs_with_history = account.email_audit_logs_with_history(object_id, cached_options_for_klient)
+        elsif object_type == 'CUSTOM_FIELD'
+          audit_logs_with_history = Kaui::CustomField.new({:custom_field_id => object_id}).audit_logs_with_history(cached_options_for_klient)
+        elsif object_type == 'PAYMENT_ATTEMPT'
+          audit_logs_with_history = Kaui::Payment::attempt_audit_logs_with_history(object_id, cached_options_for_klient)
+        elsif object_type == 'PAYMENT'
+          payment = Kaui::Payment::find_by_id(object_id, false, false, cached_options_for_klient)
+          audit_logs_with_history = payment.audit_logs_with_history(cached_options_for_klient)
+        elsif object_type == 'PAYMENT_METHOD'
+          payment_method = Kaui::PaymentMethod::find_by_id(object_id, false, cached_options_for_klient)
+          audit_logs_with_history = payment_method.audit_logs_with_history(cached_options_for_klient)
+        elsif object_type == 'TRANSACTION'
+          audit_logs_with_history = Kaui::Transaction::new({:transaction_id => object_id}).audit_logs_with_history(cached_options_for_klient)
+        elsif object_type == 'TAG'
+          audit_logs_with_history = Kaui::Tag.new({:tag_id => object_id}).audit_logs_with_history(cached_options_for_klient)
+        elsif object_type == 'TAG_DEFINITION'
+          audit_logs_with_history = Kaui::TagDefinition.new({:id => object_id}).audit_logs_with_history(cached_options_for_klient)
+        else
+          error = "Object [#{object_type}] history is not supported."
+        end
+      rescue Exception => e
+        error = e.message
+      end
+
+      { audits: audit_logs_with_history, error: error }
+    end
+  end
+
+  private
+
+    def object_with_history?(object_type)
+      return false if object_type.nil?
+      OBJECT_WITH_HISTORY.include?(object_type)
+    end
+
+end

data/app/controllers/kaui/bundles_controller.rb

@@ -6,22 +6,34 @@ class Kaui::BundlesController < Kaui::EngineController
       all_bundle_tags = @account.all_tags(:BUNDLE, false, 'NONE', options_for_klient)
       all_bundle_tags.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
     }
+    fetch_subscription_tags = promise {
+      all_subscription_tags = @account.all_tags(:SUBSCRIPTION, false, 'NONE', options_for_klient)
+      all_subscription_tags.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
+    }
     fetch_bundle_fields = promise {
       all_bundle_fields = @account.all_custom_fields(:BUNDLE, 'NONE', options_for_klient)
       all_bundle_fields.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
     }
+    fetch_subscription_fields = promise {
+      all_subscription_fields = @account.all_custom_fields(:SUBSCRIPTION, 'NONE', options_for_klient)
+      all_subscription_fields.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
+    }
     fetch_available_tags = promise { Kaui::TagDefinition.all_for_bundle(options_for_klient) }
+    fetch_available_subscription_tags = promise { Kaui::TagDefinition.all_for_subscription(options_for_klient) }
 
     @bundles = wait(fetch_bundles)
     @tags_per_bundle = wait(fetch_bundle_tags)
+    @tags_per_subscription = wait(fetch_subscription_tags)
     @custom_fields_per_bundle = wait(fetch_bundle_fields)
+    @custom_fields_per_subscription = wait(fetch_subscription_fields)
     @available_tags = wait(fetch_available_tags)
+    @available_subscription_tags = wait(fetch_available_subscription_tags)
 
-    @base_subscription = {}
+    @subscription = {}
     @bundles.each do |bundle|
       bundle.subscriptions.each do |sub|
-        next unless sub.product_category == 'BASE'
-        @base_subscription[bundle.bundle_id] = sub
+        next if sub.product_category == 'ADD_ON'
+        @subscription[bundle.bundle_id] = sub
         break
       end
     end

data/app/controllers/kaui/custom_fields_controller.rb

@@ -55,6 +55,8 @@ class Kaui::CustomFieldsController < Kaui::EngineController
                 Kaui::Invoice.new(:invoice_id => @custom_field.object_id)
               when :PAYMENT
                 Kaui::Payment.new(:payment_id => @custom_field.object_id)
+              when :INVOICE_ITEM
+                Kaui::InvoiceItem.new(:invoice_item_id => @custom_field.object_id)
               else
                 flash.now[:error] = "Invalid object type #{@custom_field.object_type}"
                 render :new and return

data/app/controllers/kaui/engine_controller_util.rb

@@ -119,4 +119,18 @@ module Kaui::EngineControllerUtil
       nil
     end
   end
+
+  def json_response
+    begin
+      response = yield
+      response_status = 200
+    rescue KillBillClient::API::ResponseError => e
+      response = e.response.message
+      response_status = e.code
+    rescue Exception => e
+      response = e.message
+      response_status = 500
+    end
+    render :json => response,  :status => response_status
+  end
 end

data/app/controllers/kaui/invoice_items_controller.rb

@@ -34,4 +34,21 @@ class Kaui::InvoiceItemsController < Kaui::EngineController
     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
+
+  def update_tags
+    @invoice_item = Kaui::InvoiceItem.new(:invoice_item_id => params.require(:id))
+    invoice_id = params.require(:invoice_id)
+    account_id = params.require(:account_id)
+    @invoice_item.account_id = account_id
+
+    tags = []
+    params.each do |tag|
+      tag_info = tag.split('_')
+      next if tag_info.size != 2 or tag_info[0] != 'tag'
+      tags << tag_info[1]
+    end
+
+    @invoice_item.set_tags(tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    redirect_to account_invoice_path(account_id, invoice_id), :notice => 'Invoice Item tags successfully set'
+  end
 end

data/app/controllers/kaui/invoices_controller.rb

@@ -42,20 +42,37 @@ class Kaui::InvoicesController < Kaui::EngineController
   end
 
   def show
-    @invoice = Kaui::Invoice.find_by_id_or_number(params.require(:id), true, 'FULL', options_for_klient)
+    # Go to the database once
+    cached_options_for_klient = options_for_klient
 
-    fetch_payments = promise { @invoice.payments(true, true, 'FULL', 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, options_for_klient) }
-    fetch_invoice_fields = promise { @invoice.custom_fields('NONE', options_for_klient).sort { |cf_a, cf_b| cf_a.name.downcase <=> cf_b.name.downcase } }
+    @invoice = Kaui::Invoice.find_by_id_or_number(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) }
+    fetch_invoice_fields = promise { @invoice.custom_fields('NONE', cached_options_for_klient).sort { |cf_a, cf_b| cf_a.name.downcase <=> cf_b.name.downcase } }
     fetch_payment_fields = promise {
-      all_payment_fields = @account.all_custom_fields(:PAYMENT, 'NONE', options_for_klient)
+      all_payment_fields = @account.all_custom_fields(:PAYMENT, 'NONE', cached_options_for_klient)
       all_payment_fields.inject({}) { |hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh }
     }
 
+    fetch_available_invoice_item_tags = promise { Kaui::TagDefinition.all_for_invoice_item(cached_options_for_klient) }
+    fetch_tags_per_invoice_item = promise {
+      tags_per_invoice_item = @account.all_tags(:INVOICE_ITEM, false, 'NONE', cached_options_for_klient)
+      tags_per_invoice_item.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
+    }
+
+    fetch_custom_fields_per_invoice_item = promise {
+      custom_fields_per_invoice_item = @account.all_custom_fields(:INVOICE_ITEM, 'NONE', cached_options_for_klient)
+      custom_fields_per_invoice_item.inject({}) { |hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh }
+    }
+
     @payments = wait(fetch_payments)
     @payment_methods = wait(fetch_pms)
     @custom_fields = wait(fetch_invoice_fields)
     @payment_custom_fields = wait(fetch_payment_fields)
+    @custom_fields_per_invoice_item = wait(fetch_custom_fields_per_invoice_item)
+    @tags_per_invoice_item = wait(fetch_tags_per_invoice_item)
+    @available_invoice_item_tags = wait(fetch_available_invoice_item_tags)
   end
 
   def restful_show

data/app/controllers/kaui/payment_methods_controller.rb

@@ -44,7 +44,7 @@ class Kaui::PaymentMethodsController < Kaui::EngineController
         'state'               => @state
     }
 
-    @plugin_properties = params[:plugin_properties].values.select{ |item| !(item['value'].blank? || item['key'].blank?) } unless params[:plugin_properties].blank?
+    @plugin_properties = params[:plugin_properties].values.select{ |item| !(item['value'].blank? || item['key'].blank?) } rescue @plugin_properties = nil
     @plugin_properties.map! do |property|
       KillBillClient::Model::PluginPropertyAttributes.new(property)
     end unless @plugin_properties.blank?
@@ -82,16 +82,17 @@ class Kaui::PaymentMethodsController < Kaui::EngineController
   end
 
   def validate_external_key
-    external_key = params.require(:external_key)
+    json_response do
+      external_key = params.require(:external_key)
 
-    begin
-      payment_methods = Kaui::PaymentMethod::find_by_external_key(external_key,false,false,'NONE', options_for_klient)
-    rescue KillBillClient::API::NotFound
-      payment_methods = nil
-    end
-
-    render json: {:is_found => !payment_methods.nil?}
+      begin
+        payment_methods = Kaui::PaymentMethod::find_by_external_key(external_key,false,false,'NONE', options_for_klient)
+      rescue KillBillClient::API::NotFound
+        payment_methods = nil
+      end
 
+      { :is_found => !payment_methods.nil? }
+    end
   end
 
   private

data/app/controllers/kaui/subscriptions_controller.rb

@@ -32,6 +32,9 @@ class Kaui::SubscriptionsController < Kaui::EngineController
 
       @subscription.plan_name = plan_name
       requested_date = params[:type_change] == "DATE" ? params[:requested_date].presence : nil
+
+      # un-set product_category since is not needed if plan name exist
+      @subscription.product_category = nil
       @subscription = @subscription.create(current_user.kb_username, params[:reason], params[:comment], requested_date, false, options_for_klient)
       redirect_to kaui_engine.account_bundles_path(@subscription.account_id), :notice => 'Subscription was successfully created'
     rescue => e
@@ -126,16 +129,32 @@ class Kaui::SubscriptionsController < Kaui::EngineController
   end
 
   def validate_external_key
-    external_key = params.require(:external_key)
+    json_response do
+      external_key = params.require(:external_key)
 
-    begin
-      bundle = Kaui::Bundle.find_by_external_key(external_key, false, options_for_klient)
-    rescue KillBillClient::API::NotFound
-      bundle = nil
+      begin
+        bundle = Kaui::Bundle.find_by_external_key(external_key, false, options_for_klient)
+      rescue KillBillClient::API::NotFound
+        bundle = nil
+      end
+
+      { :is_found => !bundle.nil? }
     end
+  end
 
-    render json: {:is_found => !bundle.nil?}
+  def update_tags
+    subscription_id = params.require(:id)
+    subscription = Kaui::Subscription.find_by_id(subscription_id, options_for_klient)
 
+    tags = []
+    params.each do |tag|
+      tag_info = tag.split('_')
+      next if tag_info.size != 2 or tag_info[0] != 'tag'
+      tags << tag_info[1]
+    end
+
+    Kaui::Tag.set_for_subscription(subscription_id, tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    redirect_to kaui_engine.account_bundles_path(subscription.account_id), :notice => 'Subscription tags successfully set'
   end
 
   private
@@ -154,8 +173,36 @@ class Kaui::SubscriptionsController < Kaui::EngineController
       plans_details = Kaui::Catalog.available_addons(base_product_name, options_for_klient)
     else
       bundle = nil
-      plans_details = Kaui::Catalog.available_base_plans(options_for_klient)
+      plans_details = catalog_plans(subscription.product_category == 'BASE' ? nil : subscription.product_category)
     end
     [bundle, plans_details]
   end
+
+  def catalog_plans(product_category = nil)
+    if product_category == 'BASE'
+      return Kaui::Catalog.available_base_plans(options_for_klient)
+    else
+      options = options_for_klient
+
+      catalog = Kaui::Catalog.get_tenant_catalog('json', DateTime.now.to_s, options)
+
+      return [] if catalog.blank?
+
+      plans = []
+      catalog[catalog.size - 1].products.each do |product|
+        next if product.type == 'ADD_ON' || (!product_category.nil? && product.type != product_category)
+        product.plans.each do |plan|
+          class << plan
+            attr_accessor :plan
+          end
+          plan.plan = plan.name
+
+          plans << plan
+        end
+      end
+
+      return plans
+
+    end
+  end
 end

data/app/controllers/kaui/tag_definitions_controller.rb

@@ -14,6 +14,7 @@ class Kaui::TagDefinitionsController < Kaui::EngineController
   end
 
   def create
+    params[:tag_definition][:applicable_object_types] = params[:tag_definition][:applicable_object_types].values unless params[:tag_definition][:applicable_object_types].blank?
     @tag_definition = Kaui::TagDefinition.new(params[:tag_definition])
 
     begin

data/app/helpers/kaui/account_helper.rb

@@ -12,5 +12,33 @@ module Kaui
       return false
     end
 
+    def account_closed?
+      return false if @account.nil?
+      blocking_states = @account.blocking_states('ACCOUNT','account-service','NONE', Kaui.current_tenant_user_options(current_user, session))
+
+      is_account_closed = false
+      blocking_states.each do |blocking_state|
+        if blocking_state.state_name.eql?('CLOSE_ACCOUNT')
+          is_account_closed = true
+          break
+        end
+      end
+      is_account_closed
+    end
+
+    def billing_info_margin
+      style = ''
+      unless can?(:trigger, Kaui::Payment) && can?(:credit, Kaui::Account) && can?(:charge, Kaui::Account)
+        style = "#{style}margin-top:15px;"
+      end
+
+      unless can? :trigger, Kaui::Invoice
+        style = "#{style}margin-bottom:15px;"
+      end
+
+      style = "style='#{style}'" unless style.empty?
+      style
+    end
+
   end
 end

data/app/helpers/kaui/object_helper.rb

@@ -20,5 +20,9 @@ module Kaui
       end
     end
 
+    def object_types
+      [:ACCOUNT, :BUNDLE, :INVOICE, :INVOICE_ITEM, :INVOICE_PAYMENT, :PAYMENT, :SUBSCRIPTION, :TRANSACTION]
+    end
+
   end
 end

data/app/helpers/kaui/permissions_helper.rb

@@ -0,0 +1,15 @@
+module Kaui
+  module PermissionsHelper
+
+    def can_close_account?
+      isAuthorizedWhen = true
+      isAuthorizedWhen &= can? :cancel, Kaui::Subscription
+      isAuthorizedWhen &= can? :pause_resume, Kaui::Subscription
+      isAuthorizedWhen &= can? :add, Kaui::Tag
+      isAuthorizedWhen &= can? :item_adjust, Kaui::Invoice
+
+      isAuthorizedWhen
+    end
+
+  end
+end