kaui 0.11.0 → 0.12.0

data/app/controllers/kaui/admin_tenants_controller.rb

@@ -1,195 +1,200 @@
-module Kaui
-  class AdminTenantsController < Kaui::EngineController
+class Kaui::AdminTenantsController < Kaui::EngineController
 
-    skip_before_filter :check_for_redirect_to_tenant_screen
+  skip_before_filter :check_for_redirect_to_tenant_screen
 
-    def index
-      # Display the configured tenants in KAUI (which could be different than the existing tenants known by Kill Bill)
-      @tenants = Kaui::Tenant.all
-      render
+  def index
+    # Display the configured tenants in KAUI (which could be different than the existing tenants known by Kill Bill)
+    tenants_for_current_user = retrieve_tenants_for_current_user
+    @tenants = Kaui::Tenant.all.select { |tenant| tenants_for_current_user.include?(tenant.kb_tenant_id) }
+  end
+
+  def new
+    @tenant = Kaui::Tenant.new
+  end
+
+  def create
+    param_tenant = params[:tenant]
+    old_tenant = Kaui::Tenant.find_by_name(param_tenant[:name])
+    if old_tenant
+      flash.now[:error] = "Tenant with name #{param_tenant[:name]} already exists!"
+      @tenant = Kaui::Tenant.new
+      render :new and return
     end
 
-    def new
+    old_tenant = Kaui::Tenant.find_by_api_key(param_tenant[:api_key])
+    if old_tenant
+      flash.now[:error] = "Tenant with api key #{param_tenant[:api_key]} already exists!"
       @tenant = Kaui::Tenant.new
+      render :new and return
     end
 
-    def create
-      param_tenant = params[:tenant]
-      old_tenant = Kaui::Tenant.find_by_name(param_tenant[:name])
-      if old_tenant
-        flash[:error] = "Tenant with name #{param_tenant[:name]} already exists!"
-        redirect_to admin_tenants_path and return
-      end
+    begin
+      options = tenant_options_for_client
+      new_tenant = nil
 
       begin
-
-        options = tenant_options_for_client
-        new_tenant = nil
-
-        if params[:create_tenant]
-          # Create the tenant in Kill Bill
-          new_tenant = Kaui::AdminTenant.new
-          new_tenant.external_key = param_tenant[:name]
-          new_tenant.api_key = param_tenant[:api_key]
-          new_tenant.api_secret = param_tenant[:api_secret]
-          new_tenant = new_tenant.create(options[:username], nil, comment, options)
-        else
-          options[:api_key] = param_tenant[:api_key]
-          options[:api_secret] = param_tenant[:api_secret]
-          new_tenant = Kaui::AdminTenant.find_by_api_key(param_tenant[:api_key], options)
-        end
-
-        # Transform object to Kaui model
-        tenant_model = Kaui::Tenant.new
-        tenant_model.name = new_tenant.external_key
-        tenant_model.kb_tenant_id = new_tenant.tenant_id
-        tenant_model.api_key = new_tenant.api_key
-        tenant_model.api_secret = param_tenant[:api_secret]
-
-        # Save in KAUI tables
-        tenant_model.save!
-      rescue => e
-        flash[:error] = "Failed to create the tenant : #{as_string(e)}"
-        redirect_to admin_tenants_path and return
+        options[:api_key] = param_tenant[:api_key]
+        options[:api_secret] = param_tenant[:api_secret]
+        new_tenant = Kaui::AdminTenant.find_by_api_key(param_tenant[:api_key], options)
+      rescue KillBillClient::API::Unauthorized, KillBillClient::API::NotFound
+        # Create the tenant in Kill Bill
+        new_tenant = Kaui::AdminTenant.new
+        new_tenant.external_key = param_tenant[:name]
+        new_tenant.api_key = param_tenant[:api_key]
+        new_tenant.api_secret = param_tenant[:api_secret]
+        new_tenant = new_tenant.create(options[:username], nil, comment, options)
       end
 
-      redirect_to admin_tenant_path(tenant_model[:id]), :notice => 'Tenant was successfully configured'
-    end
-
-    def show
-      @tenant = Kaui::Tenant.find(params[:id])
-      user = current_user
-      if @tenant.kaui_allowed_users.index { |e| e.kb_username == user.kb_username}.nil?
-        flash[:error] = "Does not have permissions to see tenant id #{params[:id]}"
-        redirect_to admin_tenants_path and return
-      end
-      render
+      # Transform object to Kaui model
+      tenant_model = Kaui::Tenant.new
+      tenant_model.name = new_tenant.external_key
+      tenant_model.kb_tenant_id = new_tenant.tenant_id
+      tenant_model.api_key = new_tenant.api_key
+      tenant_model.api_secret = param_tenant[:api_secret]
+
+      # Save in KAUI tables
+      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 => e
+      flash[:error] = "Failed to create the tenant: #{as_string(e)}"
+      redirect_to admin_tenants_path and return
     end
 
-    def upload_catalog
+    # Select the tenant, see TenantsController
+    session[:kb_tenant_id] = tenant_model.kb_tenant_id
+    session[:kb_tenant_name] = tenant_model.name
 
-      current_tenant = Kaui::Tenant.find_by_id(params[:id])
-
-      options = tenant_options_for_client
-      options[:api_key] = current_tenant.api_key
-      options[:api_secret] = current_tenant.api_secret
-
-      uploaded_catalog = params[:catalog]
-      catalog_xml = uploaded_catalog.read
-
-      Kaui::AdminTenant.upload_catalog(catalog_xml, options[:username], nil, comment, options)
-
-      redirect_to admin_tenants_path, :notice => 'Catalog was successfully uploaded'
-    end
+    redirect_to admin_tenant_path(tenant_model[:id]), :notice => 'Tenant was successfully configured'
+  end
 
-    def upload_overdue_config
-      current_tenant = Kaui::Tenant.find_by_id(params[:id])
+  def show
+    @tenant = safely_find_tenant_by_id(params[:id])
+    @allowed_users = retrieve_allowed_users_for_current_user
+  end
 
-      options = tenant_options_for_client
-      options[:api_key] = current_tenant.api_key
-      options[:api_secret] = current_tenant.api_secret
+  def upload_catalog
+    current_tenant = safely_find_tenant_by_id(params[:id])
 
-      uploaded_overdue_config = params[:overdue]
-      overdue_config_xml = uploaded_overdue_config.read
+    options = tenant_options_for_client
+    options[:api_key] = current_tenant.api_key
+    options[:api_secret] = current_tenant.api_secret
 
-      Kaui::AdminTenant.upload_overdue_config(overdue_config_xml, options[:username], nil, comment, options)
+    uploaded_catalog = params[:catalog]
+    catalog_xml = uploaded_catalog.read
 
-      redirect_to admin_tenants_path, :notice => 'Overdue config was successfully uploaded'
-    end
+    Kaui::AdminTenant.upload_catalog(catalog_xml, options[:username], nil, comment, options)
 
+    redirect_to admin_tenant_path(current_tenant.id), :notice => 'Catalog was successfully uploaded'
+  end
 
-    def upload_invoice_template
-      current_tenant = Kaui::Tenant.find_by_id(params[:id])
+  def upload_overdue_config
+    current_tenant = safely_find_tenant_by_id(params[:id])
 
-      options = tenant_options_for_client
-      options[:api_key] = current_tenant.api_key
-      options[:api_secret] = current_tenant.api_secret
+    options = tenant_options_for_client
+    options[:api_key] = current_tenant.api_key
+    options[:api_secret] = current_tenant.api_secret
 
-      is_manual_pay = params[:manual_pay]
-      uploaded_invoice_template = params[:invoice_template]
-      invoice_template = uploaded_invoice_template.read
+    uploaded_overdue_config = params[:overdue]
+    overdue_config_xml = uploaded_overdue_config.read
 
-      Kaui::AdminTenant.upload_invoice_template(invoice_template, is_manual_pay, true, options[:username], nil, comment, options)
+    Kaui::AdminTenant.upload_overdue_config(overdue_config_xml, options[:username], nil, comment, options)
 
-      redirect_to admin_tenants_path, :notice => 'Invoice template was successfully uploaded'
+    redirect_to admin_tenant_path(current_tenant.id), :notice => 'Overdue config was successfully uploaded'
+  end
 
-    end
 
-    def upload_invoice_translation
-      current_tenant = Kaui::Tenant.find_by_id(params[:id])
+  def upload_invoice_template
+    current_tenant = safely_find_tenant_by_id(params[:id])
 
-      options = tenant_options_for_client
-      options[:api_key] = current_tenant.api_key
-      options[:api_secret] = current_tenant.api_secret
+    options = tenant_options_for_client
+    options[:api_key] = current_tenant.api_key
+    options[:api_secret] = current_tenant.api_secret
 
-      locale = params[:translation_locale]
-      uploaded_invoice_translation = params[:invoice_translation]
-      invoice_translation = uploaded_invoice_translation.read
+    is_manual_pay = params[:manual_pay]
+    uploaded_invoice_template = params[:invoice_template]
+    invoice_template = uploaded_invoice_template.read
 
-      Kaui::AdminTenant.upload_invoice_translation(invoice_translation, locale, true, options[:username], nil, comment, options)
+    Kaui::AdminTenant.upload_invoice_template(invoice_template, is_manual_pay, true, options[:username], nil, comment, options)
 
-      redirect_to admin_tenants_path, :notice => 'Invoice translation was successfully uploaded'
+    redirect_to admin_tenant_path(current_tenant.id), :notice => 'Invoice template was successfully uploaded'
+  end
 
-    end
+  def upload_invoice_translation
+    current_tenant = safely_find_tenant_by_id(params[:id])
 
-    def upload_catalog_translation
+    options = tenant_options_for_client
+    options[:api_key] = current_tenant.api_key
+    options[:api_secret] = current_tenant.api_secret
 
-      current_tenant = Kaui::Tenant.find_by_id(params[:id])
+    locale = params[:translation_locale]
+    uploaded_invoice_translation = params[:invoice_translation]
+    invoice_translation = uploaded_invoice_translation.read
 
-      options = tenant_options_for_client
-      options[:api_key] = current_tenant.api_key
-      options[:api_secret] = current_tenant.api_secret
+    Kaui::AdminTenant.upload_invoice_translation(invoice_translation, locale, true, options[:username], nil, comment, options)
 
-      locale = params[:translation_locale]
-      uploaded_catalog_translation = params[:catalog_translation]
-      catalog_translation = uploaded_catalog_translation.read
+    redirect_to admin_tenant_path(current_tenant.id), :notice => 'Invoice translation was successfully uploaded'
+  end
 
-      Kaui::AdminTenant.upload_catalog_translation(catalog_translation, locale, true, options[:username], nil, comment, options)
+  def upload_catalog_translation
+    current_tenant = safely_find_tenant_by_id(params[:id])
 
-      redirect_to admin_tenants_path, :notice => 'Catalog translation was successfully uploaded'
-    end
+    options = tenant_options_for_client
+    options[:api_key] = current_tenant.api_key
+    options[:api_secret] = current_tenant.api_secret
 
+    locale = params[:translation_locale]
+    uploaded_catalog_translation = params[:catalog_translation]
+    catalog_translation = uploaded_catalog_translation.read
 
-    def  upload_plugin_config
+    Kaui::AdminTenant.upload_catalog_translation(catalog_translation, locale, true, options[:username], nil, comment, options)
 
-      current_tenant = Kaui::Tenant.find_by_id(params[:id])
+    redirect_to admin_tenant_path(current_tenant.id), :notice => 'Catalog translation was successfully uploaded'
+  end
 
-      options = tenant_options_for_client
-      options[:api_key] = current_tenant.api_key
-      options[:api_secret] = current_tenant.api_secret
+  def upload_plugin_config
+    current_tenant = safely_find_tenant_by_id(params[:id])
 
-      plugin_name = params[:plugin_name]
-      uploaded_plugin_config = params[:plugin_config]
-      plugin_config = uploaded_plugin_config.read
+    options = tenant_options_for_client
+    options[:api_key] = current_tenant.api_key
+    options[:api_secret] = current_tenant.api_secret
 
-      Kaui::AdminTenant.upload_tenant_plugin_config(plugin_name, plugin_config, options[:username], nil, comment, options)
+    plugin_name = params[:plugin_name]
+    uploaded_plugin_config = params[:plugin_config]
+    plugin_config = uploaded_plugin_config.read
 
-      redirect_to admin_tenants_path, :notice => 'Config for plugin was successfully uploaded'
+    Kaui::AdminTenant.upload_tenant_plugin_config(plugin_name, plugin_config, options[:username], nil, comment, options)
 
-    end
+    redirect_to admin_tenant_path(current_tenant.id), :notice => 'Config for plugin was successfully uploaded'
+  end
 
-    def remove_allowed_user
+  def remove_allowed_user
+    current_tenant = safely_find_tenant_by_id(params[:id])
+    au = Kaui::AllowedUser.find(params[:allowed_user][:id])
+    # remove the association
+    au.kaui_tenants.delete current_tenant
+    render :json => '{}', :status => 200
+  end
 
-      current_tenant = Kaui::Tenant.find_by_id(params[:id])
-      au = Kaui::AllowedUser.find(params[:allowed_user][:id])
-      # remove the association
-      au.kaui_tenants.delete current_tenant
-      render :json => '{}', :status => 200
-    end
+  private
 
-    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)
+    tenant
+  end
 
-    def tenant_options_for_client
-      user = current_user
-      {
-          :username => user.kb_username,
-          :password => user.password,
-          :session_id => user.kb_session_id
-      }
-    end
+  def tenant_options_for_client
+    user = current_user
+    {
+        :username => user.kb_username,
+        :password => user.password,
+        :session_id => user.kb_session_id
+    }
+  end
 
-    def comment
-      'Multi-tenant Administrative operation'
-    end
+  def comment
+    'Multi-tenant Administrative operation'
   end
 end

data/app/controllers/kaui/bundle_tags_controller.rb

@@ -1,35 +1,17 @@
 class Kaui::BundleTagsController < Kaui::EngineController
 
-  def show
-    bundle_id_or_key = params[:bundle_id]
-    account_id       = params[:account_id]
-
-    begin
-      @bundle  = Kaui::Bundle::find_by_id_or_key(bundle_id_or_key, account_id, options_for_klient)
-      @account = Kaui::Account::find_by_id_or_key(@bundle.account_id, false, false, options_for_klient)
-      @tags    = @bundle.tags(true, 'FULL', options_for_klient).sort { |tag_a, tag_b| tag_a <=> tag_b }
-    rescue => e
-      flash[:error] = "Error while getting tags: #{as_string(e)}"
-      redirect_to :back
-    end
-  end
-
   def edit
-    bundle_id_or_key = params[:bundle_id]
-    account_id       = params[:account_id]
+    @bundle_id = params.require(:bundle_id)
 
-    begin
-      @bundle         = Kaui::Bundle::find_by_id_or_key(bundle_id_or_key, account_id, options_for_klient)
-      @tag_names      = (@bundle.tags(false, 'NONE', options_for_klient).map { |tag| tag.tag_definition_name }).sort
-      @available_tags = Kaui::TagDefinition.all_for_bundle(options_for_klient)
-    rescue => e
-      flash[:error] = "Error while editing tags: #{as_string(e)}"
-      redirect_to kaui_engine.bundle_tags_path(:bundle_id => bundle_id_or_key)
-    end
+    fetch_tag_names = lambda { @tag_names = (Kaui::Tag.all_for_bundle(@bundle_id, false, 'NONE', options_for_klient).map { |tag| tag.tag_definition_name }).sort }
+    fetch_available_tags = lambda { @available_tags = Kaui::TagDefinition.all_for_bundle(options_for_klient) }
+
+    run_in_parallel fetch_tag_names, fetch_available_tags
   end
 
   def update
-    bundle_id = params[:bundle_id]
+    account_id = params.require(:account_id)
+    bundle_id = params.require(:bundle_id)
 
     tags = []
     params.each do |tag, tag_name|
@@ -38,13 +20,7 @@ class Kaui::BundleTagsController < Kaui::EngineController
       tags << tag_info[1]
     end
 
-    begin
-      bundle = Kaui::Bundle.new(:bundle_id => bundle_id)
-      bundle.set_tags(tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.bundle_tags_path(:bundle_id => bundle_id), :notice => 'Bundle tags successfully set'
-    rescue => e
-      flash[:error] = "Error while updating tags: #{as_string(e)}"
-      redirect_to kaui_engine.bundle_tags_path(:bundle_id => bundle_id)
-    end
+    Kaui::Tag.set_for_bundle(bundle_id, tags, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    redirect_to kaui_engine.account_bundles_path(account_id), :notice => 'Bundle tags successfully set'
   end
 end

data/app/controllers/kaui/bundles_controller.rb

@@ -1,82 +1,43 @@
 class Kaui::BundlesController < Kaui::EngineController
 
   def index
-  end
-
-  def pagination
-    search_key = params[:sSearch]
-    offset     = params[:iDisplayStart] || 0
-    limit      = params[:iDisplayLength] || 10
-
-    bundles = Kaui::Bundle.list_or_search(search_key, offset, limit, options_for_klient)
+    @account = Kaui::Account::find_by_id_or_key(params.require(:account_id), false, false, options_for_klient)
 
-    json = {
-        :sEcho                => params[:sEcho],
-        :iTotalRecords        => bundles.pagination_max_nb_records,
-        :iTotalDisplayRecords => bundles.pagination_total_nb_records,
-        :aaData               => []
+    fetch_bundles = lambda { @bundles = @account.bundles(options_for_klient) }
+    fetch_bundle_tags = lambda {
+      all_bundle_tags = @account.all_tags(:BUNDLE, false, 'NONE', options_for_klient)
+      @tags_per_bundle = all_bundle_tags.inject({}) {|hsh, entry| (hsh[entry.object_id] ||= []) << entry; hsh}
     }
 
-    bundles.each do |bundle|
-      json[:aaData] << [
-          view_context.link_to(view_context.truncate_uuid(bundle.bundle_id), view_context.url_for(:action => :show, :id => bundle.bundle_id)),
-          view_context.link_to(view_context.truncate_uuid(bundle.account_id), view_context.url_for(:controller => :accounts, :action => :show, :id => bundle.account_id)),
-          bundle.external_key,
-          bundle.subscriptions.nil? ? '' : (bundle.subscriptions.map { |s| s.product_name }).join(', ')
-      ]
-    end
+    fetch_available_tags = lambda { @available_tags = Kaui::TagDefinition.all_for_bundle(options_for_klient) }
 
-    respond_to do |format|
-      format.json { render :json => json }
-    end
-  end
+    run_in_parallel fetch_bundles, fetch_bundle_tags, fetch_available_tags
 
-  def show
-    begin
-      @bundle  = Kaui::Bundle::find_by_id_or_key(params[:id], nil, options_for_klient)
-      @account = Kaui::Account::find_by_id(@bundle.account_id, false, false, options_for_klient)
-      @tags    = @bundle.tags(false, 'NONE', options_for_klient).sort { |tag_a, tag_b| tag_a <=> tag_b }
-    rescue => e
-      flash.now[:error] = "Error while retrieving bundle information: #{as_string(e)}"
-      render :action => :index
+    @base_subscription = {}
+    @bundles.each do |bundle|
+      bundle.subscriptions.each do |sub|
+        next unless sub.product_category == 'BASE'
+        @base_subscription[bundle.bundle_id] = sub
+        break
+      end
     end
   end
 
   def transfer
-    begin
-      @bundle  = Kaui::Bundle::find_by_id_or_key(params[:id], nil, options_for_klient)
-      @account = Kaui::Account::find_by_id(@bundle.account_id, false, false, options_for_klient)
-    rescue => e
-      flash.now[:error] = "Error while preparing to transfer bundle: #{as_string(e)}"
-      render :action => :index
-    end
+    @bundle_id = params.require(:id)
   end
 
   def do_transfer
-    key = params[:new_account_key]
-    unless key.present?
-      flash.now[:error] = 'No new account key given'
-      render :action => :index and return
-    end
-
-    begin
-      # Retrieve the new account to get the account id
-      new_account = Kaui::Account::find_by_id_or_key(params[:new_account_key], false, false, options_for_klient)
-    rescue => e
-      flash.now[:error] = "Error while retrieving new account: #{as_string(e)}"
-      render :action => :index and return
-    end
+    new_account = Kaui::Account::find_by_id_or_key(params.require(:new_account_key), false, false, options_for_klient)
 
-    begin
-      billing_policy = params[:billing_policy]
+    bundle = Kaui::Bundle::new(:bundle_id => params.require(:id), :account_id => new_account.account_id)
+    bundle.transfer(nil, params[:billing_policy], current_user.kb_username, params[:reason], params[:comment], options_for_klient)
 
-      bundle = Kaui::Bundle::new(:bundle_id => params[:id], :account_id => new_account.account_id)
-      bundle.transfer(nil, billing_policy, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    redirect_to kaui_engine.account_bundles_path(new_account.account_id), :notice => 'Bundle was successfully transferred'
+  end
 
-      redirect_to account_path(new_account.account_id), :notice => 'Bundle was successfully transferred'
-    rescue => e
-      flash.now[:error] = "Error while transferring bundle: #{as_string(e)}"
-      render :action => :index
-    end
+  def restful_show
+    bundle = Kaui::Bundle.find_by_id_or_key(params.require(:id), options_for_klient)
+    redirect_to kaui_engine.account_bundles_path(bundle.account_id)
   end
 end

data/app/controllers/kaui/chargebacks_controller.rb

@@ -1,20 +1,14 @@
 class Kaui::ChargebacksController < Kaui::EngineController
 
   def new
-    begin
-      payment = Kaui::Payment::find_by_id(params[:payment_id], options_for_klient)
-    rescue => e
-      flash[:error] = "Error while retrieving payment: #{as_string(e)}"
-      redirect_to :back
-    end
-
+    payment = Kaui::Payment::find_by_id(params.require(:payment_id), options_for_klient)
     @chargeback = Kaui::Chargeback.new(:payment_id => payment.payment_id,
-                                       :amount     => payment.paid_amount_to_money.to_f,
-                                       :currency   => payment.currency)
+                                       :amount => payment.paid_amount_to_money.to_f,
+                                       :currency => payment.currency)
   end
 
   def create
-    @chargeback        = Kaui::Chargeback.new(params[:chargeback])
+    @chargeback = Kaui::Chargeback.new(params.require(:chargeback))
     should_cancel_subs = (params[:cancel_all_subs] == '1')
 
     begin
@@ -44,6 +38,6 @@ class Kaui::ChargebacksController < Kaui::EngineController
       end
     end
 
-    redirect_to kaui_engine.account_timeline_path(:id => payment.account_id), :notice => 'Chargeback created'
+    redirect_to kaui_engine.account_payment_path(payment.account_id, payment.payment_id), :notice => 'Chargeback created'
   end
 end

data/app/controllers/kaui/charges_controller.rb

@@ -2,31 +2,24 @@ class Kaui::ChargesController < Kaui::EngineController
 
   def new
     invoice_id = params[:invoice_id]
-    account_id = params[:account_id]
-    currency   = params[:currency] || 'USD'
+    amount = params[:amount]
 
     if invoice_id.present?
-      begin
-        @invoice   = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
-        account_id = @invoice.account_id
-        currency   = @invoice.currency
-      rescue => e
-        flash.now[:error] = "Unable to retrieve invoice: #{as_string(e)}"
-      end
+      @invoice = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
+      amount ||= @invoice.balance
+      currency = @invoice.currency
+    else
+      currency = params[:currency] || 'USD'
     end
 
-    @charge = Kaui::InvoiceItem.new(:account_id => account_id, :invoice_id => invoice_id, :currency => currency)
+    @charge = Kaui::InvoiceItem.new(:account_id => params.require(:account_id), :invoice_id => invoice_id, :amount => amount, :currency => currency)
   end
 
   def create
-    @charge = Kaui::InvoiceItem.new(params[:invoice_item].delete_if { |key, value| value.blank? })
+    charge = Kaui::InvoiceItem.new(params.require(:invoice_item).delete_if { |key, value| value.blank? })
+    charge.account_id ||= params.require(:account_id)
 
-    begin
-      @charge = @charge.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.invoice_path(:id => @charge.invoice_id), :notice => 'Charge was successfully created'
-    rescue => e
-      flash.now[:error] = "Error while creating a charge: #{as_string(e)}"
-      render :action => :new
-    end
+    charge = charge.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    redirect_to kaui_engine.account_invoice_path(charge.account_id, charge.invoice_id), :notice => 'Charge was successfully created'
   end
 end

data/app/controllers/kaui/credits_controller.rb

@@ -2,36 +2,33 @@ class Kaui::CreditsController < Kaui::EngineController
 
   def new
     invoice_id = params[:invoice_id]
-    account_id = params[:account_id]
-    amount     = params[:amount]
-    currency   = params[:currency] || 'USD'
+    amount = params[:amount]
 
     if invoice_id.present?
-      begin
-        @invoice   = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
-        account_id = @invoice.account_id
-        amount     ||= @invoice.balance
-        currency   = @invoice.currency
-      rescue => e
-        flash.now[:error] = "Unable to retrieve invoice: #{as_string(e)}"
-      end
+      @invoice = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
+      amount ||= @invoice.balance
+      currency = @invoice.currency
+    else
+      currency = params[:currency] || 'USD'
     end
 
-    # TODO Specifying a custom currency is not supported yet
-    @credit = Kaui::Credit.new(:invoice_id    => invoice_id,
-                               :account_id    => account_id,
-                               :credit_amount => amount)
+    @credit = Kaui::Credit.new(:account_id => params.require(:account_id), :invoice_id => invoice_id, :credit_amount => amount, :currency => currency)
   end
 
   def create
-    @credit = Kaui::Credit.new(params[:credit].delete_if { |key, value| value.blank? })
+    credit = Kaui::Credit.new(params[:credit].delete_if { |key, value| value.blank? })
+    credit.account_id ||= params.require(:account_id)
 
-    begin
-      @credit = @credit.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
-      redirect_to kaui_engine.invoice_path(:id => @credit.invoice_id), :notice => 'Credit was successfully created'
-    rescue => e
-      flash.now[:error] = "Error while creating a credit: #{as_string(e)}"
-      render :action => :new
+    # No need to show the newly created invoice for account level credits
+    should_redirect_to_invoice = credit.invoice_id.present?
+
+    credit = credit.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    flash[:notice] = 'Credit was successfully created'
+
+    if should_redirect_to_invoice
+      redirect_to kaui_engine.account_invoice_path(credit.account_id, credit.invoice_id)
+    else
+      redirect_to kaui_engine.account_path(credit.account_id)
     end
   end
 end