kaui 0.6.6 → 0.7.0

data/app/controllers/kaui/accounts_controller.rb

@@ -1,31 +1,31 @@
 class Kaui::AccountsController < Kaui::EngineController
+
   def index
-    if params[:account_id].present?
-      redirect_to kaui_engine.account_path(params[:account_id])
-    end
   end
 
   def pagination
-    json = { :sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => [] }
-
     search_key = params[:sSearch]
-    if search_key.present?
-      accounts = Kaui::KillbillHelper::search_accounts(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    else
-      accounts = Kaui::KillbillHelper::get_accounts(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    end
-    json[:iTotalDisplayRecords] = accounts.pagination_total_nb_records
-    json[:iTotalRecords] = accounts.pagination_max_nb_records
+    offset     = params[:iDisplayStart] || 0
+    limit      = params[:iDisplayLength] || 10
+
+    accounts = Kaui::Account.list_or_search(search_key, offset, limit, options_for_klient)
+
+    json = {
+        :sEcho                => params[:sEcho],
+        :iTotalRecords        => accounts.pagination_max_nb_records,
+        :iTotalDisplayRecords => accounts.pagination_total_nb_records,
+        :aaData               => []
+    }
 
     accounts.each do |account|
       json[:aaData] << [
-                         view_context.link_to(account.account_id, view_context.url_for(:action => :show, :id => account.account_id)),
-                         account.name,
-                         account.external_key,
-                         account.currency,
-                         account.city,
-                         account.country
-                       ]
+          view_context.link_to(view_context.truncate_uuid(account.account_id), view_context.url_for(:action => :show, :id => account.account_id)),
+          account.name,
+          account.external_key,
+          account.currency,
+          account.city,
+          account.country
+      ]
     end
 
     respond_to do |format|
@@ -33,163 +33,83 @@ class Kaui::AccountsController < Kaui::EngineController
     end
   end
 
-  def show
-    @key = params[:id]
-    if @key.present?
-      # Remove extra whitespaces
-      @key.strip!
-
-      begin
-        @account = Kaui::KillbillHelper::get_account_by_key_with_balance_and_cba(@key, options_for_klient)
-      rescue URI::InvalidURIError => e
-        flash.now[:error] = "Error while retrieving the account for #{@key}: #{e.message}"
-        render :action => :index and return
-      rescue => e
-        flash.now[:error] = "Error while retrieving the account for #{@key}: #{as_string(e)}"
-        render :action => :index and return
-      end
-
-      if @account.present? and @account.is_a? Kaui::Account
-        begin
-          @tags = Kaui::KillbillHelper::get_tags_for_account(@account.account_id, false, "NONE", options_for_klient).sort { |tag_a, tag_b| tag_a.tag_definition_name.downcase <=> tag_b.tag_definition_name.downcase }
-          @account_emails = Kaui::AccountEmail.where({ :account_id => @account.account_id }, options_for_klient)
-          @overdue_state = Kaui::KillbillHelper::get_overdue_state_for_account(@account.account_id, options_for_klient)
-          @payment_methods = Kaui::KillbillHelper::get_non_external_payment_methods(@account.account_id, options_for_klient)
-          @bundles = Kaui::KillbillHelper::get_bundles_for_account(@account.account_id, options_for_klient)
-
-          @subscriptions_by_bundle_id = {}
-
-          @bundles.each do |bundle|
-            @subscriptions_by_bundle_id[bundle.bundle_id.to_s] = (@subscriptions_by_bundle_id[bundle.bundle_id.to_s] || []) + bundle.subscriptions
-          end
-        rescue => e
-          flash.now[:error] = "Error while retrieving account information for account: #{as_string(e)}"
-          render :action => :index
-        end
-      else
-        flash.now[:error] = "Account #{@account_id} not found: #{@account}"
-        render :action => :index
-      end
-    else
-      flash.now[:error] = "No id given"
-    end
+  def new
+    @account = Kaui::Account.new
   end
 
-  def payment_methods
-    @account_id = params[:id]
-    if @account_id.present?
-      begin
-        @payment_methods = Kaui::KillbillHelper::get_non_external_payment_methods(@account_id, options_for_klient)
-      rescue => e
-        flash.now[:error] = "Error while getting payment methods: #{as_string(e)}"
-      end
-      unless @payment_methods.is_a?(Array)
-        flash[:notice] = "No payment methods for account_id '#{@account_id}'"
-        redirect_to :action => :index
-        return
-      end
-    else
-      flash.now[:notice] = "No account_id given"
+  def create
+    @account                          = Kaui::Account.new(params[:account].delete_if { |key, value| value.blank? })
+
+    # 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)}"
+      render :action => :new
     end
   end
 
-  def add_payment_method
-    account_id = params[:id]
+  def show
     begin
-      @account = Kaui::KillbillHelper::get_account(account_id, false, false, options_for_klient)
+      @account       = Kaui::Account::find_by_id_or_key(params[:id], true, true, options_for_klient)
+      @overdue_state = @account.overdue(options_for_klient)
+      @bundles       = @account.bundles(options_for_klient)
+      @tags          = @account.tags(false, 'NONE', options_for_klient).sort { |tag_a, tag_b| tag_a <=> tag_b }
+
+      @account_emails  = Kaui::AccountEmail.find_all_sorted_by_account_id(@account.account_id, 'NONE', options_for_klient)
+      @payment_methods = Kaui::PaymentMethod.find_non_external_by_account_id(@account.account_id, true, options_for_klient)
     rescue => e
-      flash.now[:error] = "Error while adding payment methods: #{as_string(e)}"
+      flash.now[:error] = "Error while retrieving account information: #{as_string(e)}"
+      render :action => :index and return
     end
-    if @account.nil?
-      flash[:error] = "Account not found for id #{account_id}"
-      redirect_to :back
-    else
-      render "kaui/payment_methods/new"
+
+    @subscriptions_by_bundle_id = {}
+    @bundles.each do |bundle|
+      @subscriptions_by_bundle_id[bundle.bundle_id.to_s] = (@subscriptions_by_bundle_id[bundle.bundle_id.to_s] || []) + bundle.subscriptions
     end
   end
 
-  def do_add_payment_method
-    account_id = params[:id]
-    # Needed in the failure case scenario
-    @account = Kaui::KillbillHelper::get_account(account_id, false, false, options_for_klient)
-
-    # Implementation example using standard credit card fields
-    @card_type = params[:card_type]
-    @card_holder_name = params[:card_holder_name]
-    @expiration_year = params[:expiration_year]
-    @expiration_month = params[:expiration_month]
-    @credit_card_number = params[:credit_card_number]
-    @address1 = params[:address1]
-    @address2 = params[:address2]
-    @city = params[:city]
-    @country = params[:country]
-    @postal_code = params[:postal_code]
-    @state = params[:state]
-    @is_default = params[:is_default]
-    @reason = params[:reason]
-    @comment = params[:comment]
-
-    payment_method = KillBillClient::Model::PaymentMethod.new
-    payment_method.account_id = account_id
-    payment_method.plugin_name = params[:plugin_name] || Kaui.creditcard_plugin_name.call
-
-    payment_method.plugin_info = {
-      'type' => 'CreditCard',
-      'ccType' => @card_type,
-      'ccName' => @card_holder_name,
-      'ccExpirationMonth' => @expiration_month,
-      'ccExpirationYear' => @expiration_year,
-      'ccLast4' => @credit_card_number[-4,4],
-      'address1' => @address1,
-      'address2' => @address2,
-      'city' => @city,
-      'country' => @country,
-      'zip' => @postal_code,
-      'state' => @state
-    }
+  def set_default_payment_method
+    account_id        = params[:id]
+    payment_method_id = params[:payment_method_id]
 
     begin
-      Kaui::KillbillHelper::add_payment_method(@is_default == 1, payment_method, current_user, @reason, @comment, options_for_klient)
-      flash[:notice] = 'Payment method created'
-      redirect_to kaui_engine.account_timeline_path(account_id)
+      Kaui::PaymentMethod.set_default(payment_method_id, account_id, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      flash[:notice] = "Successfully set #{payment_method_id} as default"
     rescue => e
-      flash.now[:error] = "Error while adding payment method: #{as_string(e)}"
-      render "kaui/payment_methods/new"
+      flash[:error] = "Error while setting payment method #{payment_method_id} as default: #{as_string(e)}"
     end
-  end
 
-  def set_default_payment_method
-    @account_id = params[:id]
-    @payment_method_id = params[:payment_method_id]
-    if @account_id.present? && @payment_method_id.present?
-      begin
-        @payment_methods = Kaui::KillbillHelper::set_payment_method_as_default(@account_id, @payment_method_id, current_user, params[:reason], params[:comment], options_for_klient)
-      rescue => e
-        flash[:error] = "Error while setting payment method as default #{@payment_method_id}: #{as_string(e)}"
-      end
-    else
-      flash[:notice] = 'No account_id or payment_method_id given'
-    end
-    redirect_to :back
+    redirect_to account_path(account_id)
   end
 
   def toggle_email_notifications
+    account = Kaui::Account.new(:account_id => params[:id], :is_notified_for_invoices => params[:is_notified])
+
     begin
-      @account = Kaui::KillbillHelper::update_email_notifications(params[:id], params[:is_notified], current_user, params[:reason], params[:comment], options_for_klient)
-      flash[:notice] = "Email preferences updated"
+      account.update_email_notifications(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      flash[:notice] = 'Email preferences updated'
     rescue => e
-      flash[:error] = "Error while switching email notifications #{invoice_id}: #{as_string(e)}"
+      flash[:error] = "Error while setting email notifications: #{as_string(e)}"
     end
-    redirect_to :back
+
+    redirect_to account_path(account.account_id)
   end
 
   def pay_all_invoices
+    payment = Kaui::InvoicePayment.new(:account_id => params[:id])
+
     begin
-      @account = Kaui::KillbillHelper::pay_all_invoices(params[:id], false, current_user, params[:reason], params[:comment], options_for_klient)
-      flash[:notice] = "Successfully triggered a payment for all unpaid invoices"
+      payment.bulk_create(params[:is_external_payment], current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      flash[:notice] = 'Successfully triggered a payment for all unpaid invoices'
     rescue => e
       flash[:error] = "Error while triggering payments: #{as_string(e)}"
     end
-    redirect_to :back
+
+    redirect_to account_path(payment.account_id)
   end
 end

data/app/controllers/kaui/bundle_tags_controller.rb

@@ -1,39 +1,50 @@
 class Kaui::BundleTagsController < Kaui::EngineController
 
   def show
-    bundle_id = params[:id]
-    if bundle_id.present?
-      begin
-        tags = Kaui::KillbillHelper::get_tags_for_bundle(bundle_id, options_for_klient)
-      rescue => e
-        flash.now[:error] = "Error while retrieving tags information: #{as_string(e)}"
-      end
-    else
-      flash.now[:error] = "No account id given"
+    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 = params[:bundle_id]
-    begin
-      @available_tags = Kaui::KillbillHelper::get_tag_definitions(options_for_klient).sort {|tag_a, tag_b| tag_a.name.downcase <=> tag_b.name.downcase }
+    bundle_id_or_key = params[:bundle_id]
+    account_id       = params[:account_id]
 
-      @bundle = Kaui::KillbillHelper::get_bundle(@bundle_id, options_for_klient)
-      @tags = Kaui::KillbillHelper::get_tags_for_bundle(@bundle_id, options_for_klient)
+    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.now[:error] = "Error while retrieving tags information: #{as_string(e)}"
+      flash[:error] = "Error while editing tags: #{as_string(e)}"
+      redirect_to kaui_engine.bundle_tags_path(:bundle_id => bundle_id_or_key)
     end
   end
 
   def update
-    begin
-      bundle = Kaui::KillbillHelper::get_bundle(params[:bundle_id], options_for_klient)
-      tags = params[:tags]
+    bundle_id = params[:bundle_id]
+
+    tags = []
+    params.each do |tag, tag_name|
+      tag_info = tag.split('_')
+      next if tag_info.size != 2 or tag_info[0] != 'tag'
+      tags << tag_info[1]
+    end
 
-      Kaui::KillbillHelper::set_tags_for_bundle(bundle.bundle_id, tags, current_user, params[:reason], params[:comment], options_for_klient)
-      redirect_to Kaui.bundle_home_path.call(bundle.bundle_id)
+    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.now[:error] = "Error while updating tags: #{as_string(e)}"
+      flash[:error] = "Error while updating tags: #{as_string(e)}"
+      redirect_to kaui_engine.bundle_tags_path(:bundle_id => bundle_id)
     end
   end
 end

data/app/controllers/kaui/bundles_controller.rb

@@ -1,30 +1,29 @@
 class Kaui::BundlesController < Kaui::EngineController
 
   def index
-    if params[:bundle_id].present?
-      redirect_to kaui_engine.bundle_path(params[:bundle_id])
-    end
   end
 
   def pagination
-    json = { :sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => [] }
-
     search_key = params[:sSearch]
-    if search_key.present?
-      bundles = Kaui::KillbillHelper::search_bundles(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    else
-      bundles = Kaui::KillbillHelper::get_bundles(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    end
-    json[:iTotalDisplayRecords] = bundles.pagination_total_nb_records
-    json[:iTotalRecords] = bundles.pagination_max_nb_records
+    offset     = params[:iDisplayStart] || 0
+    limit      = params[:iDisplayLength] || 10
+
+    bundles = Kaui::Bundle.list_or_search(search_key, offset, limit, options_for_klient)
+
+    json = {
+        :sEcho                => params[:sEcho],
+        :iTotalRecords        => bundles.pagination_max_nb_records,
+        :iTotalDisplayRecords => bundles.pagination_total_nb_records,
+        :aaData               => []
+    }
 
     bundles.each do |bundle|
       json[:aaData] << [
-                         view_context.link_to(bundle.bundle_id, view_context.url_for(:action => :show, :id => bundle.bundle_id)),
-                         view_context.link_to(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(', ')
-                       ]
+          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
 
     respond_to do |format|
@@ -33,75 +32,51 @@ class Kaui::BundlesController < Kaui::EngineController
   end
 
   def show
-    key = params[:id]
-    if key.present?
-      begin
-        @bundle = Kaui::KillbillHelper::get_bundle_by_key(key, params[:account_id], options_for_klient)
-
-        if @bundle.present?
-          @account = Kaui::KillbillHelper::get_account(@bundle.account_id, false, false, options_for_klient)
-          @subscriptions = @bundle.subscriptions
-        else
-          flash.now[:error] = "Bundle #{key} not found"
-          render :action => :index
-        end
-      rescue => e
-        flash.now[:error] = "Error while retrieving bundle information for #{key}: #{as_string(e)}"
-        render :action => :index
-      end
-    else
-      flash.now[:error] = "No id given"
+    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
     end
   end
 
   def transfer
-    bundle_id = params[:id]
     begin
-      @bundle = Kaui::KillbillHelper::get_bundle(bundle_id, options_for_klient)
-      @account = Kaui::KillbillHelper::get_account_by_bundle_id(bundle_id, options_for_klient)
+      @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)}"
-    end
-    if @account.nil?
-      flash.now[:error] = "Account not found for bundle id #{bundle_id}"
+      render :action => :index
     end
   end
 
   def do_transfer
-    bundle_id = params[:id]
     key = params[:new_account_key]
-    if key.present?
-      begin
-        result = Kaui::KillbillHelper.get_account_by_key(key, false, false, options_for_klient)
-      rescue => e
-        flash.now[:error] = "Error while retrieving account for #{key}: #{as_string(e)}"
-        render :action => :index
-        return
-      end
-      if bundle_id.present? && result.is_a?(Kaui::Account)
-        @new_account = result
-        begin
-          Kaui::KillbillHelper::transfer_bundle(bundle_id, @new_account.account_id, false, true, current_user, params[:reason], params[:comment], options_for_klient)
-          flash[:notice] = "Bundle transfered successfully"
-        rescue => e
-          flash[:error] = "Error transfering bundle #{as_string(e)}"
-        end
-        redirect_to Kaui.account_home_path.call(@new_account.external_key)
-        return
-      else
-        flash.now[:error] = "Could not retrieve account #{result}"
-      end
-    else
-      flash.now[:error] = "No account key given"
+    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
 
     begin
-      @bundle = Kaui::KillbillHelper::get_bundle(bundle_id, options_for_klient)
-      @account = Kaui::KillbillHelper::get_account_by_bundle_id(bundle_id, options_for_klient)
+      billing_policy = params[:billing_policy]
+
+      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 account_path(new_account.account_id), :notice => 'Bundle was successfully transferred'
     rescue => e
-      flash.now[:error] = "Error while redirecting: #{as_string(e)}"
-      render :transfer
+      flash.now[:error] = "Error while transferring bundle: #{as_string(e)}"
+      render :action => :index
     end
   end
 end

data/app/controllers/kaui/chargebacks_controller.rb

@@ -1,79 +1,49 @@
 class Kaui::ChargebacksController < Kaui::EngineController
 
-  def show
-    @payment_id = params[:id]
-    if @payment_id.present?
-      begin
-        data = Kaui::KillbillHelper::get_chargebacks_for_payment(@payment_id, options_for_klient)
-      rescue => e
-        flash.now[:error] = "Error while getting chargeback information: #{as_string(e)}"
-      end
-      if data.present?
-        @chargeback = Kaui::Chargeback.new(data)
-      else
-        Rails.logger.warn("Did not get back chargebacks #{response_body}")
-      end
-    else
-      flash.now[:notice] = "No id given"
-    end
-  end
-
   def new
-    @payment_id = params[:payment_id]
-    @account_id = params[:account_id]
-    @invoice_id = params[:invoice_id]
-
     begin
-      @account = Kaui::KillbillHelper::get_account(@account_id, false, false, options_for_klient)
-      @payment = Kaui::KillbillHelper::get_payment(@payment_id, options_for_klient)
-      @invoice = Kaui::KillbillHelper::get_invoice(@invoice_id, true, "NONE", options_for_klient)
+      payment = Kaui::Payment::find_by_id(params[:payment_id], options_for_klient)
     rescue => e
-      flash[:error] = "Error while starting a new chargeback: #{as_string(e)}"
-      redirect_to kaui_engine.account_timeline_path(:id => params[:account_id])
+      flash[:error] = "Error while retrieving payment: #{as_string(e)}"
+      redirect_to :back
     end
 
-    # The payment method may have been deleted
-    @payment_method = Kaui::KillbillHelper::get_payment_method(@payment.payment_method_id, options_for_klient) rescue nil
-
-    @chargeback = Kaui::Chargeback.new("paymentId" => @payment_id,
-                                       "chargebackAmount" => @payment.amount)
+    @chargeback = Kaui::Chargeback.new(:payment_id => payment.payment_id,
+                                       :amount     => payment.paid_amount_to_money.to_f,
+                                       :currency   => payment.currency)
   end
 
   def create
-    chargeback = Kaui::Chargeback.new(params[:chargeback])
-    should_cancel_subs = (params[:cancel_all_subs] == "1")
-
-    if chargeback.present?
-      begin
-        Kaui::KillbillHelper::create_chargeback(chargeback, current_user, params[:reason], params[:comment], options_for_klient)
-      rescue => e
-        flash[:error] = "Error while creating a new chargeback: #{as_string(e)}"
-        redirect_to kaui_engine.account_timeline_path(:id => params[:account_id]) and return
-      end
+    @chargeback        = Kaui::Chargeback.new(params[:chargeback])
+    should_cancel_subs = (params[:cancel_all_subs] == '1')
 
-      # Cancel all subscriptions on the account, if required
-      if should_cancel_subs
-        begin
-          bundles = Kaui::KillbillHelper::get_bundles_for_account(params[:account_id], options_for_klient)
-          bundles.each do |bundle|
-            bundle.subscriptions.each do |subscription|
-              # Already cancelled?
-              next unless subscription.billing_end_date.blank?
+    begin
+      payment = @chargeback.chargeback(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+    rescue => e
+      flash.now[:error] = "Error while creating a new chargeback: #{as_string(e)}"
+      render :action => :new and return
+    end
 
-              # Cancel the entitlement immediately but use the default billing policy
-              Kaui::KillbillHelper::delete_subscription(subscription.subscription_id, current_user, params[:reason], params[:comment], 'IMMEDIATE', nil, options_for_klient)
-            end
+    # Cancel all subscriptions on the account, if required
+    if should_cancel_subs
+      begin
+        account = Kaui::Account.find_by_id(payment.account_id, false, false, options_for_klient)
+        account.bundles(options_for_klient).each do |bundle|
+          bundle.subscriptions.each do |subscription|
+            # Already cancelled?
+            next unless subscription.billing_end_date.blank?
+
+            # Cancel the entitlement immediately but use the default billing policy
+            entitlement = Kaui::Subscription.new(:subscription_id => subscription.subscription_id)
+            entitlement.cancel_entitlement_immediately(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
           end
-        rescue => e
-          flash[:error] = "Error while cancelling subscriptions: #{as_string(e)}"
-          redirect_to kaui_engine.account_timeline_path(:id => params[:account_id]) and return
         end
+      rescue => e
+        flash[:error] = "Error while cancelling subscriptions: #{as_string(e)}"
+        render :action => :new and return
       end
-
-      flash[:notice] = "Chargeback created"
-    else
-      flash[:error] = "No chargeback to process"
     end
-    redirect_to kaui_engine.account_timeline_path(:id => params[:account_id])
+
+    redirect_to kaui_engine.account_timeline_path(:id => payment.account_id), :notice => 'Chargeback created'
   end
 end

data/app/controllers/kaui/charges_controller.rb

@@ -1,34 +1,32 @@
 class Kaui::ChargesController < Kaui::EngineController
 
   def new
-    @account_id = params[:account_id]
-    @invoice_id = params[:invoice_id]
-    begin
-      @account = Kaui::KillbillHelper::get_account(@account_id, false, false, options_for_klient)
+    invoice_id = params[:invoice_id]
+    account_id = params[:account_id]
+    currency   = params[:currency] || 'USD'
 
-      if @invoice_id.present?
-        @invoice = Kaui::KillbillHelper::get_invoice(@invoice_id, true, "NONE", options_for_klient)
-        @charge = Kaui::Charge.new("accountId" => @account_id, "invoiceId" => @invoice_id)
-      else
-        @charge = Kaui::Charge.new("accountId" => @account_id)
+    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
-    rescue => e
-      flash.now[:error] = "Error while creating a charge: #{as_string(e)}"
     end
+
+    @charge = Kaui::InvoiceItem.new(:account_id => account_id, :invoice_id => invoice_id, :currency => currency)
   end
 
   def create
-    charge = Kaui::Charge.new(params[:charge])
+    @charge = Kaui::InvoiceItem.new(params[:invoice_item].delete_if { |key, value| value.blank? })
 
-    if charge.present?
-      begin
-        Kaui::KillbillHelper::create_charge(charge, params[:requested_date], current_user, params[:reason], params[:comment], options_for_klient)
-        flash[:notice] = "Charge created"
-        redirect_to kaui_engine.account_timeline_path(:id => charge.account_id)
-      rescue => e
-        flash.now[:error] = "Error while creating a charge: #{as_string(e)}"
-      end
+    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
   end
-
 end