kaui 2.1.0 → 3.0.1

data/app/controllers/kaui/subscriptions_controller.rb

@@ -1,233 +1,244 @@
-class Kaui::SubscriptionsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def new
-    @base_product_name = params[:base_product_name]
-    @subscription = Kaui::Subscription.new(:bundle_id => params[:bundle_id],
-                                           :account_id => params[:account_id],
-                                           :product_category => params[:product_category] || 'BASE')
+module Kaui
+  class SubscriptionsController < Kaui::EngineController
+    def new
+      @base_product_name = params[:base_product_name]
+      @subscription = Kaui::Subscription.new(bundle_id: params[:bundle_id],
+                                             account_id: params[:account_id],
+                                             product_category: params[:product_category] || 'BASE')
 
-    @bundle, plans_details = lookup_bundle_and_plan_details(@subscription, @base_product_name)
-    @plans = plans_details.map { |p| p.plan }
+      @bundle, plans_details = lookup_bundle_and_plan_details(@subscription, @base_product_name)
+      @plans = plans_details.map(&:plan)
 
-    if @plans.empty?
-      if @subscription.product_category == 'BASE'
-        flash[:error] = 'No plan available in the catalog'
-      else
-        flash[:error] = "No add-on available in the catalog for product #{@base_product_name}"
-      end
-      redirect_to kaui_engine.account_bundles_path(@subscription.account_id), :error => 'No available plan'
+      return unless @plans.empty?
+
+      flash[:error] = if @subscription.product_category == 'BASE'
+                        'No plan available in the catalog'
+                      else
+                        "No add-on available in the catalog for product #{@base_product_name}"
+                      end
+      redirect_to kaui_engine.account_bundles_path(@subscription.account_id), error: 'No available plan'
     end
-  end
 
-  def create
-    plan_name = params.require(:plan_name)
-    @base_product_name = params[:base_product_name]
-    @subscription = Kaui::Subscription.new(params.require(:subscription).delete_if { |key, value| value.blank? })
+    def create
+      plan_name = params.require(:plan_name)
+      @base_product_name = params[:base_product_name]
+      @subscription = Kaui::Subscription.new(params.require(:subscription).delete_if { |_key, value| value.blank? })
 
-    begin
-      @bundle, plans_details = lookup_bundle_and_plan_details(@subscription, @base_product_name)
+      begin
+        @bundle, plans_details = lookup_bundle_and_plan_details(@subscription, @base_product_name)
 
-      plan_details = plans_details.find { |p| p.plan == plan_name }
-      raise "Unable to find plan #{plan_name}" if plan_details.nil?
+        plan_details = plans_details.find { |p| p.plan == plan_name }
+        raise "Unable to find plan #{plan_name}" if plan_details.nil?
 
-      @subscription.plan_name = plan_name
-      requested_date = params[:type_change] == "DATE" ? params[:requested_date].presence : nil
+        @subscription.plan_name = plan_name
+        requested_date = params[:type_change] == 'DATE' ? params[:requested_date].presence : nil
 
-      # price override?
-      override_fixed_price = plan_details.phases.first.prices.blank? rescue false
-      override_recurring_price = !override_fixed_price
-      phase_type = @bundle.nil? ? plan_details.phases.first.type : @bundle.subscriptions.first.phase_type
-      overrides = price_overrides(phase_type, override_fixed_price, override_recurring_price)
-      @subscription.price_overrides = overrides unless overrides.blank?
-
-      # 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
-      @plans = plans_details.nil? ? [] : plans_details.map { |p| p.plan }
-
-      if e.is_a?(::KillBillClient::API::BadRequest) && !e.response.nil? && !e.response.body.nil?
-        error_message = JSON.parse(e.response.body) rescue nil
-        if !error_message.nil? & !error_message['code'].nil? && error_message['code'] == 2010 # CAT_NO_PRICE_FOR_CURRENCY
-          # Hack for lack of proper Kill Bill messaging (https://github.com/killbill/killbill-admin-ui/issues/266)
-          flash.now[:error] = "Unable to create the subscription: a price for this currency hasn't been specified in the catalog"
-          render :new and return
+        # price override?
+        override_fixed_price = begin
+          plan_details.phases.first.prices.blank?
+        rescue StandardError
+          false
+        end
+        override_recurring_price = !override_fixed_price
+        phase_type = @bundle.nil? ? plan_details.phases.first.type : @bundle.subscriptions.first.phase_type
+        overrides = price_overrides(phase_type, override_fixed_price, override_recurring_price)
+        @subscription.price_overrides = overrides unless overrides.blank?
+
+        # 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 StandardError => e
+        @plans = plans_details.nil? ? [] : plans_details.map(&:plan)
+
+        if e.is_a?(::KillBillClient::API::BadRequest) && !e.response.nil? && !e.response.body.nil?
+          error_message = begin
+            JSON.parse(e.response.body)
+          rescue StandardError
+            nil
+          end
+          if (!error_message.nil? & !error_message['code'].nil?) && error_message['code'] == 2010 # CAT_NO_PRICE_FOR_CURRENCY
+            # Hack for lack of proper Kill Bill messaging (https://github.com/killbill/killbill-admin-ui/issues/266)
+            flash.now[:error] = "Unable to create the subscription: a price for this currency hasn't been specified in the catalog"
+            render :new and return
+          end
         end
-      end
 
-      flash.now[:error] = "Error while creating the subscription: #{as_string(e)}"
-      render :new
+        flash.now[:error] = "Error while creating the subscription: #{as_string(e)}"
+        render :new
+      end
     end
-  end
 
-  def edit
-    @subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
-    _, plans_details = lookup_bundle_and_plan_details(@subscription)
-    # Use a Set to deal with multiple pricelists
-    @plans = Set.new.merge(plans_details.map { |p| p.plan })
-  end
-
-  def update
-    plan_name = params.require(:plan_name)
-
-    requested_date = params[:type_change] == "DATE" ? params[:requested_date].presence : nil
-    billing_policy = params[:type_change] == "POLICY" ? params[:policy].presence : nil
-
-    wait_for_completion = params[:wait_for_completion] == '1'
-
-    subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
-
-    input = { :planName => plan_name }
+    def edit
+      @subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
+      _, plans_details = lookup_bundle_and_plan_details(@subscription)
+      # Use a Set to deal with multiple pricelists
+      @plans = Set.new.merge(plans_details.map(&:plan))
+    end
 
-    # price override?
-    current_plan = subscription.prices.select { |price| price['phaseType'] == subscription.phase_type }
-    override_fixed_price = current_plan.last['recurringPrice'].nil?
-    override_recurring_price = !override_fixed_price
-    overrides = price_overrides(subscription.phase_type, override_fixed_price, override_recurring_price)
-    input[:priceOverrides] = overrides unless overrides.blank?
+    def update
+      plan_name = params.require(:plan_name)
 
-    subscription.change_plan(input,
-                             current_user.kb_username,
-                             params[:reason],
-                             params[:comment],
-                             requested_date,
-                             billing_policy,
-                             nil,
-                             wait_for_completion,
-                             options_for_klient)
+      requested_date = params[:type_change] == 'DATE' ? params[:requested_date].presence : nil
+      billing_policy = params[:type_change] == 'POLICY' ? params[:policy].presence : nil
 
-    redirect_to kaui_engine.account_bundles_path(subscription.account_id), :notice => 'Subscription plan successfully changed'
-  rescue => e
-    redirect_to edit_subscription_path(params.require(:id)), :flash => { :error => "Error while changing subscription: #{as_string(e)}" }
-  end
+      wait_for_completion = params[:wait_for_completion] == '1'
 
-  def destroy
-    requested_date = params[:requested_date].presence
-    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
+      subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
 
-    # true by default
-    use_requested_date_for_billing = (params[:use_requested_date_for_billing] || '1') == '1'
+      input = { planName: plan_name }
 
-    subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
+      # price override?
+      current_plan = subscription.prices.select { |price| price['phaseType'] == subscription.phase_type }
+      override_fixed_price = current_plan.last['recurringPrice'].nil?
+      override_recurring_price = !override_fixed_price
+      overrides = price_overrides(subscription.phase_type, override_fixed_price, override_recurring_price)
+      input[:priceOverrides] = overrides unless overrides.blank?
+
+      subscription.change_plan(input,
+                               current_user.kb_username,
+                               params[:reason],
+                               params[:comment],
+                               requested_date,
+                               billing_policy,
+                               nil,
+                               wait_for_completion,
+                               options_for_klient)
+
+      redirect_to kaui_engine.account_bundles_path(subscription.account_id), notice: 'Subscription plan successfully changed'
+    rescue StandardError => e
+      redirect_to edit_subscription_path(params.require(:id)), flash: { error: "Error while changing subscription: #{as_string(e)}" }
+    end
 
-    subscription.cancel(current_user.kb_username, params[:reason], params[:comment], requested_date, entitlement_policy, billing_policy, use_requested_date_for_billing, options_for_klient)
+    def destroy
+      requested_date = params[:requested_date].presence
+      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 except default policy
+      use_requested_date_for_billing = if requested_date
+                                         (params[:use_requested_date_for_billing] || '1') == '1'
+                                       else
+                                         nil
+                                       end
+      subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
+      subscription.cancel(current_user.kb_username, params[:reason], params[:comment], requested_date, entitlement_policy, billing_policy, use_requested_date_for_billing, options_for_klient)
+      redirect_to kaui_engine.account_bundles_path(subscription.account_id), notice: 'Subscription was successfully cancelled'
+    end
 
-    redirect_to kaui_engine.account_bundles_path(subscription.account_id), :notice => 'Subscription was successfully cancelled'
-  end
+    def reinstate
+      subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
 
-  def reinstate
-    subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
+      subscription.uncancel(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
 
-    subscription.uncancel(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.account_bundles_path(subscription.account_id), notice: 'Subscription was successfully reinstated'
+    end
 
-    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 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']
 
-  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']
 
-    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
 
-    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
 
-  def show
-    restful_show
-  end
+    def restful_show
+      subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
+      redirect_to kaui_engine.account_bundles_path(subscription.account_id)
+    end
 
-  def restful_show
-    subscription = Kaui::Subscription.find_by_id(params.require(:id), options_for_klient)
-    redirect_to kaui_engine.account_bundles_path(subscription.account_id)
-  end
+    def validate_bundle_external_key
+      json_response do
+        external_key = params.require(:external_key)
 
-  def validate_bundle_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
+        end
 
-      begin
-        bundle = Kaui::Bundle.find_by_external_key(external_key, false, options_for_klient)
-      rescue KillBillClient::API::NotFound
-        bundle = nil
+        { is_found: !bundle.nil? }
       end
-
-      { :is_found => !bundle.nil? }
     end
-  end
 
+    def validate_external_key
+      json_response do
+        external_key = params.require(:external_key)
 
-  def validate_external_key
-    json_response do
-      external_key = params.require(:external_key)
+        begin
+          subscription = Kaui::Subscription.find_by_external_key(external_key, options_for_klient)
+        rescue KillBillClient::API::NotFound
+          subscription = nil
+        end
 
-      begin
-        subscription = Kaui::Subscription.find_by_external_key(external_key, options_for_klient)
-      rescue KillBillClient::API::NotFound
-        subscription = nil
+        { is_found: !subscription.nil? }
       end
-
-      { :is_found => !subscription.nil? }
     end
-  end
 
-  def update_tags
-    subscription_id = params.require(:id)
-    subscription = Kaui::Subscription.find_by_id(subscription_id, options_for_klient)
+    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
+      tags = []
+      params.each do |tag|
+        tag_info = tag.split('_')
+        next if (tag_info.size != 2) || (tag_info[0] != 'tag')
 
-    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
+        tags << tag_info[1]
+      end
 
-  private
+      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
 
-  def lookup_bundle_and_plan_details(subscription, base_product_name = nil)
-    if subscription.product_category == 'ADD_ON'
-      bundle = Kaui::Bundle.find_by_id(@subscription.bundle_id, options_for_klient)
-      if base_product_name.blank?
-        bundle.subscriptions.each do |sub|
-          if sub.product_category == 'BASE'
-            base_product_name = sub.product_name
-            break
+    private
+
+    def lookup_bundle_and_plan_details(subscription, base_product_name = nil)
+      if subscription.product_category == 'ADD_ON'
+        bundle = Kaui::Bundle.find_by_id(@subscription.bundle_id, options_for_klient)
+        if base_product_name.blank?
+          bundle.subscriptions.each do |sub|
+            if sub.product_category == 'BASE'
+              base_product_name = sub.product_name
+              break
+            end
           end
         end
+        plans_details = Kaui::Catalog.available_addons(base_product_name, subscription.account_id, options_for_klient)
+      else
+        bundle = nil
+        plans_details = catalog_plans(subscription.product_category == 'BASE' ? nil : subscription.product_category)
       end
-      plans_details = Kaui::Catalog.available_addons(base_product_name, options_for_klient)
-    else
-      bundle = nil
-      plans_details = catalog_plans(subscription.product_category == 'BASE' ? nil : subscription.product_category)
+      [bundle, plans_details]
     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
+    def catalog_plans(product_category = nil)
+      return Kaui::Catalog.available_base_plans(@subscription.account_id, options_for_klient) if product_category == 'BASE'
+
       options = options_for_klient
 
-      catalog = Kaui::Catalog.get_tenant_catalog_json(DateTime.now.to_s, options)
+      catalog = Kaui::Catalog.get_tenant_catalog_json(DateTime.now.to_s, @subscription.account_id, 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
@@ -238,23 +249,22 @@ class Kaui::SubscriptionsController < Kaui::EngineController
         end
       end
 
-      return plans
-
+      plans
     end
-  end
 
-  def price_overrides(phase_type, override_fixed_price = true, override_recurring_price = false)
-    return nil if params[:price_override].blank?
+    def price_overrides(phase_type, override_fixed_price, override_recurring_price)
+      return nil if params[:price_override].blank? || params[:price_override].to_i.negative?
 
-    price_override = params[:price_override]
-    overrides = []
-    override = KillBillClient::Model::PhasePriceAttributes.new
-    override.phase_type = phase_type
-    override.fixed_price = price_override if override_fixed_price
-    override.recurring_price = price_override if override_recurring_price
+      price_override = params[:price_override]
+      overrides = []
+      override = KillBillClient::Model::PhasePriceAttributes.new
+      override.phase_type = phase_type
+      override.fixed_price = price_override if override_fixed_price
+      override.recurring_price = price_override if override_recurring_price
 
-    overrides << override
+      overrides << override
 
-    overrides
+      overrides
+    end
   end
 end

data/app/controllers/kaui/tag_definitions_controller.rb

@@ -1,40 +1,41 @@
-class Kaui::TagDefinitionsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def index
-    begin
+module Kaui
+  class TagDefinitionsController < Kaui::EngineController
+    def index
       @tag_definitions = Kaui::TagDefinition.all('NONE', options_for_klient)
-    rescue => e
+    rescue StandardError => e
       flash.now[:error] = "Error while retrieving tag definitions: #{as_string(e)}"
-      @tag_definitions  = []
+      @tag_definitions = []
     end
-  end
 
-  def new
-    @tag_definition = Kaui::TagDefinition.new
-  end
+    def new
+      @tag_definition = Kaui::TagDefinition.new
+    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])
+    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
-      @tag_definition = @tag_definition.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.tag_definitions_path, :notice => 'Tag definition successfully created'
-    rescue => e
-      flash.now[:error] = "Error while creating tag definition: #{as_string(e)}"
-      render :action => :new
+      begin
+        @tag_definition = @tag_definition.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+        redirect_to kaui_engine.tag_definitions_path, notice: 'Tag definition successfully created'
+      rescue StandardError => e
+        flash.now[:error] = "Error while creating tag definition: #{as_string(e)}"
+        render action: :new
+      end
     end
-  end
 
-  def destroy
-    @tag_definition = Kaui::TagDefinition.find_by_id(params[:id], 'NONE', options_for_klient)
+    def destroy
+      @tag_definition = Kaui::TagDefinition.find_by_id(params[:id], 'NONE', options_for_klient)
 
-    begin
-      @tag_definition.delete(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.tag_definitions_path, :notice => 'Tag definition successfully deleted'
-    rescue => e
-      flash.now[:error] = "Error while deleting tag definition: #{as_string(e)}"
-      render :action => :index
+      begin
+        @tag_definition.delete(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+        redirect_to kaui_engine.tag_definitions_path, notice: 'Tag definition successfully deleted'
+      rescue StandardError => e
+        flash.now[:error] = "Error while deleting tag definition: #{as_string(e)}"
+        render action: :index
+      end
     end
   end
 end

data/app/controllers/kaui/tags_controller.rb

@@ -1,39 +1,42 @@
-class Kaui::TagsController < Kaui::EngineController
+# frozen_string_literal: true
 
-  def index
-    @search_query = params[:q]
+module Kaui
+  class TagsController < Kaui::EngineController
+    def index
+      @search_query = params[:q]
 
-    @ordering = params[:ordering] || (@search_query.blank? ? 'desc' : 'asc')
-    @offset = params[:offset] || 0
-    @limit = params[:limit] || 50
+      @ordering = params[:ordering] || (@search_query.blank? ? 'desc' : 'asc')
+      @offset = params[:offset] || 0
+      @limit = params[:limit] || 50
 
-    @max_nb_records = @search_query.blank? ? Kaui::Tag.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
-  end
-
-  def pagination
-    searcher = lambda do |search_key, offset, limit|
-      Kaui::Tag.list_or_search(search_key, offset, limit, options_for_klient)
+      @max_nb_records = @search_query.blank? ? Kaui::Tag.list_or_search(nil, 0, 0, options_for_klient).pagination_max_nb_records : 0
     end
 
-    data_extractor = lambda do |tag, column|
-      [
+    def pagination
+      searcher = lambda do |search_key, offset, limit|
+        Kaui::Tag.list_or_search(search_key, offset, limit, options_for_klient)
+      end
+
+      data_extractor = lambda do |tag, column|
+        [
           tag.tag_id,
           tag.object_id,
           tag.object_type,
           tag.tag_definition_name
-      ][column]
-    end
+        ][column]
+      end
 
-    formatter = lambda do |tag|
-      url_for_object = view_context.url_for_object(tag.object_id, tag.object_type)
-      [
+      formatter = lambda do |tag|
+        url_for_object = view_context.url_for_object(tag.object_id, tag.object_type)
+        [
           tag.tag_id,
           url_for_object ? view_context.link_to(tag.object_id, url_for_object) : tag.object_id,
           tag.object_type,
           tag.tag_definition_name
-      ]
-    end
+        ]
+      end
 
-    paginate searcher, data_extractor, formatter
+      paginate searcher, data_extractor, formatter
+    end
   end
 end