kaui 0.6.6 → 0.7.0

data/app/controllers/kaui/credits_controller.rb

@@ -1,51 +1,37 @@
 class Kaui::CreditsController < Kaui::EngineController
-  def show
-    @account_id = params[:account_id]
-    @invoice_id = params[:invoice_id]
 
-    if params.has_key?(:account_id)
+  def new
+    invoice_id = params[:invoice_id]
+    account_id = params[:account_id]
+    amount     = params[:amount]
+    currency   = params[:currency] || 'USD'
+
+    if invoice_id.present?
       begin
-      # invoice id can be nil for account level credit
-        data = Kaui::KillbillHelper::get_credits(@account_id, @invoice_id, options_for_klient)
+        @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] = "Error getting credit information: #{as_string(e)}"
-      end
-      if data.present?
-        @credit = Kaui::Credit.new(data)
-      else
-        Rails.logger.warn("Did not get back external payments #{response_body}")
+        flash.now[:error] = "Unable to retrieve invoice: #{as_string(e)}"
       end
-    else
-      flash.now[:notice] = "No id given"
-    end
-  end
-
-  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 = Kaui::KillbillHelper::get_invoice(@invoice_id, true, "NONE", options_for_klient) unless @invoice_id.nil?
-    rescue => e
-      flash.now[:error] = "Error while starting to create credit: #{as_string(e)}"
     end
 
-    credit_amount = @invoice.balance unless @invoice.nil?
-
-    @credit = Kaui::Credit.new("accountId" => @account_id, "invoiceId" => @invoice_id,
-                               "creditAmount" => credit_amount, "effectiveDate" => Date.parse(Time.now.to_s).to_s)
+    # TODO Specifying a custom currency is not supported yet
+    @credit = Kaui::Credit.new(:invoice_id    => invoice_id,
+                               :account_id    => account_id,
+                               :credit_amount => amount)
   end
 
   def create
-    credit = params[:credit]
+    @credit = Kaui::Credit.new(params[:credit].delete_if { |key, value| value.blank? })
+
     begin
-      Kaui::KillbillHelper::create_credit(credit, current_user, params[:reason], params[:comment], options_for_klient)
-      account = Kaui::KillbillHelper::get_account(credit['account_id'], false, false, options_for_klient)
-      flash[:notice] = "Credit created"
+      @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[:error] = "Error while starting to create credit: #{as_string(e)}"
+      flash.now[:error] = "Error while creating a credit: #{as_string(e)}"
+      render :action => :new
     end
-    redirect_to Kaui.account_home_path.call(credit['account_id'])
   end
 end

data/app/controllers/kaui/custom_fields_controller.rb

@@ -4,26 +4,28 @@ class Kaui::CustomFieldsController < Kaui::EngineController
   end
 
   def pagination
-    json = { :sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => [] }
-
     search_key = params[:sSearch]
-    if search_key.present?
-      custom_fields = Kaui::KillbillHelper::search_custom_fields(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    else
-      custom_fields = Kaui::KillbillHelper::get_custom_fields(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    end
-    json[:iTotalDisplayRecords] = custom_fields.pagination_total_nb_records
-    json[:iTotalRecords] = custom_fields.pagination_max_nb_records
+    offset     = params[:iDisplayStart] || 0
+    limit      = params[:iDisplayLength] || 10
+
+    custom_fields = Kaui::CustomField.list_or_search(search_key, offset, limit, options_for_klient)
+
+    json = {
+        :sEcho                => params[:sEcho],
+        :iTotalRecords        => custom_fields.pagination_max_nb_records,
+        :iTotalDisplayRecords => custom_fields.pagination_total_nb_records,
+        :aaData               => []
+    }
 
     custom_fields.each do |custom_field|
       json[:aaData] << [
-                         custom_field.name,
-                         custom_field.value
-                       ]
+          custom_field.name,
+          custom_field.value
+      ]
     end
 
     respond_to do |format|
       format.json { render :json => json }
     end
   end
-end
+end

data/app/controllers/kaui/engine_controller.rb

@@ -6,18 +6,18 @@ class Kaui::EngineController < ApplicationController
   # Common options for the Kill Bill client
   def options_for_klient(options = {})
     {
-      # TODO Kaui doesn't support multi-tenancy yet
-      :api_key => KillBillClient.api_key,
-      :api_secret => KillBillClient.api_secret,
-      :username => current_user.kb_username || KillBillClient.username,
-      :password => current_user.password || KillBillClient.password,
-      :session_id => current_user.kb_session_id
+        # TODO Kaui doesn't support multi-tenancy yet
+        :api_key    => KillBillClient.api_key,
+        :api_secret => KillBillClient.api_secret,
+        :username   => current_user.kb_username || KillBillClient.username,
+        :password   => current_user.password || KillBillClient.password,
+        :session_id => current_user.kb_session_id
     }.merge(options)
   end
 
   # Used for auditing purposes
   def current_user
-    super rescue Kaui.config[:default_current_user]
+    super
   end
 
   def current_ability
@@ -28,9 +28,7 @@ class Kaui::EngineController < ApplicationController
   protected
 
   def as_string(e)
-    if e.is_a?(RestClient::Exception)
-      "#{e.message}, server response: #{as_string_from_response(e.response)}".split(/\n/).take(5).join("\n")
-    elsif e.is_a?(KillBillClient::API::ResponseError)
+    if e.is_a?(KillBillClient::API::ResponseError)
       "Error #{e.response.code}: #{as_string_from_response(e.response.body)}"
     else
       e.message

data/app/controllers/kaui/invoice_items_controller.rb

@@ -1,59 +1,42 @@
 class Kaui::InvoiceItemsController < Kaui::EngineController
-  def index
-    if params[:invoice_item_id].present? and params[:invoice_id].present?
-      redirect_to kaui_engine.invoice_item_path(params[:invoice_item_id], :invoice_id => params[:invoice_id])
-    end
-  end
-
-  def show
-    find_invoice_item
-  end
 
   def edit
-    find_invoice_item
-  end
+    invoice_item_id = params[:id]
+    invoice_id      = params[:invoice_id]
 
-  def update
-    @invoice_item = Kaui::KillbillHelper.new_invoice_item(params[:kill_bill_client_model_invoice_item])
     begin
-      Kaui::KillbillHelper.adjust_invoice(@invoice_item, current_user, params[:reason], params[:comment], options_for_klient)
-      flash[:notice] = "Adjustment item created"
-      redirect_to kaui_engine.invoice_path(@invoice_item.invoice_id)
+      invoice = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
     rescue => e
-      flash.now[:error] = "Error while updating the invoice item: #{as_string(e)}"
-      render :action => "edit"
+      flash[:error] = "Error while getting information for invoice #{invoice_id}: #{as_string(e)}"
+      redirect_to :back
     end
+
+    @invoice_item = invoice.items.find { |ii| ii.invoice_item_id == invoice_item_id }
   end
 
-  def destroy
+  def update
+    @invoice_item = Kaui::InvoiceItem.new(params[:invoice_item])
+
     begin
-      Kaui::KillbillHelper.delete_cba(params[:account_id], params[:invoice_id], params[:id], current_user, params[:reason], params[:comment], options_for_klient)
-      flash[:notice] = "CBA deleted"
-      redirect_to kaui_engine.invoice_path(params[:invoice_id])
+      invoice = @invoice_item.update(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.invoice_path(invoice.invoice_id), :notice => 'Adjustment item was successfully created'
     rescue => e
-      flash[:error] = "Error while deleting the CBA: #{as_string(e)}"
-      redirect_to kaui_engine.invoice_path(params[:invoice_id])
+      flash.now[:error] = "Error while adjusting invoice item: #{as_string(e)}"
+      render :action => :edit
     end
   end
 
-  private
+  def destroy
+    @invoice_item = Kaui::InvoiceItem.new(:invoice_item_id => params[:id],
+                                          :invoice_id      => params[:invoice_id],
+                                          :account_id      => params[:account_id])
 
-  def find_invoice_item
-    invoice_item_id = params[:id]
-    invoice_id = params[:invoice_id]
-    if invoice_item_id.present? and invoice_id.present?
-      begin
-        @invoice_item = Kaui::KillbillHelper.get_invoice_item invoice_id, invoice_item_id, options_for_klient
-      rescue => e
-        flash[:error] = "Error while trying to find the invoice item: #{as_string(e)}"
-      end
-      unless @invoice_item.present?
-        flash[:error] = "Invoice for id #{invoice_id} and invoice item id #{invoice_item_id} not found"
-        render :action => :index
-      end
-    else
-      flash[:error] = "Both invoice item and invoice ids should be specified"
-      render :action => :index
+    begin
+      @invoice_item.delete(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.invoice_path(@invoice_item.invoice_id), :notice => 'CBA item was successfully deleted'
+    rescue => e
+      flash.now[:error] = "Error while deleting CBA item: #{as_string(e)}"
+      render :action => :edit
     end
   end
 end

data/app/controllers/kaui/invoices_controller.rb

@@ -1,4 +1,5 @@
 class Kaui::InvoicesController < Kaui::EngineController
+
   def index
     if params[:invoice_id].present?
       redirect_to kaui_engine.invoice_path(params[:invoice_id])
@@ -6,25 +7,25 @@ class Kaui::InvoicesController < Kaui::EngineController
   end
 
   def pagination
-    json = { :sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => [] }
+    json = {:sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => []}
 
     search_key = params[:sSearch]
     if search_key.present?
-      invoices = Kaui::KillbillHelper::search_invoices(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
+      invoices = Kaui::Invoice.find_in_batches_by_search_key(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
     else
-      invoices = Kaui::KillbillHelper::get_invoices(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
+      invoices = Kaui::Invoice.find_in_batches(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
     end
     json[:iTotalDisplayRecords] = invoices.pagination_total_nb_records
-    json[:iTotalRecords] = invoices.pagination_max_nb_records
+    json[:iTotalRecords]        = invoices.pagination_max_nb_records
 
     invoices.each do |invoice|
       json[:aaData] << [
-                         view_context.link_to(invoice.invoice_id, view_context.url_for(:controller => :invoices, :action => :show, :id => invoice.invoice_id)),
-                         invoice.invoice_number,
-                         view_context.format_date(invoice.invoice_date),
-                         view_context.humanized_money_with_symbol(Kaui::Base.to_money(invoice.amount, invoice.currency)),
-                         view_context.humanized_money_with_symbol(Kaui::Base.to_money(invoice.balance, invoice.currency))
-                       ]
+          view_context.link_to(view_context.truncate_uuid(invoice.invoice_id), view_context.url_for(:controller => :invoices, :action => :show, :id => invoice.invoice_id)),
+          invoice.invoice_number,
+          view_context.format_date(invoice.invoice_date),
+          view_context.humanized_money_with_symbol(invoice.amount_to_money),
+          view_context.humanized_money_with_symbol(invoice.balance_to_money)
+      ]
     end
 
     respond_to do |format|
@@ -34,54 +35,43 @@ class Kaui::InvoicesController < Kaui::EngineController
 
   def show
     invoice_id_or_number = params[:id]
-    if invoice_id_or_number.present?
-      begin
-        @invoice = Kaui::KillbillHelper.get_invoice(invoice_id_or_number, true, "FULL", options_for_klient)
-        if @invoice.present?
-          @invoice_id = @invoice.invoice_id
-          @account = Kaui::KillbillHelper.get_account(@invoice.account_id, false, false, options_for_klient)
-          @payments = Kaui::KillbillHelper.get_payments_for_invoice(@invoice_id, options_for_klient)
-          @payment_methods = {}
-          @payments.each do |payment|
-            # The payment method may have been deleted
-            @payment_methods[payment.payment_id] = Kaui::KillbillHelper::get_payment_method(payment.payment_method_id, options_for_klient) rescue nil
+    unless invoice_id_or_number.present?
+      flash.now[:error] = 'No id given'
+      render :index and return
+    end
 
-            #get the refunds for the payment
-            payment.refunds = Kaui::KillbillHelper::get_refunds_for_payment(payment.payment_id, options_for_klient) rescue []
-          end
+    begin
+      @invoice         = Kaui::Invoice.find_by_id_or_number(invoice_id_or_number, true, 'FULL', options_for_klient)
+      @invoice_id      = @invoice.invoice_id
+      @account         = Kaui::Account.find_by_id(@invoice.account_id, false, false, options_for_klient)
+      @payments        = Kaui::Invoice.new(:invoice_id => @invoice_id).payments(false, 'FULL', options_for_klient)
+      @payment_methods = Kaui::PaymentMethod.payment_methods_for_payments(@payments, options_for_klient)
 
-          @subscriptions = {}
-          @bundles = {}
-          @cba_items_not_deleteable = []
-          if @invoice.items.present?
-            @invoice.items.each do |item|
-              @cba_items_not_deleteable << item.linked_invoice_item_id if item.description =~ /account credit/ and item.amount < 0
+      @subscriptions            = {}
+      @bundles                  = {}
+      @cba_items_not_deleteable = []
+      if @invoice.items.present?
+        @invoice.items.each do |item|
+          @cba_items_not_deleteable << item.linked_invoice_item_id if item.description =~ /account credit/ and item.amount < 0
 
-              unless item.subscription_id.nil? || @subscriptions.has_key?(item.subscription_id)
-                @subscriptions[item.subscription_id] = Kaui::KillbillHelper.get_subscription(item.subscription_id, options_for_klient)
-              end
-              unless item.bundle_id.nil? || @bundles.has_key?(item.bundle_id)
-                @bundles[item.bundle_id] = Kaui::KillbillHelper.get_bundle(item.bundle_id, options_for_klient)
-              end
+          unless item.subscription_id.nil? || @subscriptions.has_key?(item.subscription_id)
+            @subscriptions[item.subscription_id] = Kaui::Subscription::find_by_id(item.subscription_id, options_for_klient)
           end
-          else
-            flash.now[:error] = "Invoice items for #{@invoice_id} not found"
+          unless item.bundle_id.nil? || @bundles.has_key?(item.bundle_id)
+            @bundles[item.bundle_id] = Kaui::Bundle::find_by_id(item.bundle_id, options_for_klient)
           end
-        else
-          flash.now[:error] = "Invoice #{invoice_id_or_number} not found"
-          render :action => :index
         end
-      rescue => e
-        flash.now[:error] = "Error while getting information for invoice #{invoice_id_or_number}: #{as_string(e)}"
+      else
+        flash.now[:error] = "Invoice items for #{@invoice_id} not found"
       end
-    else
-      flash.now[:error] = "No id given"
+    rescue => e
+      flash.now[:error] = "Error while getting information for invoice #{invoice_id_or_number}: #{as_string(e)}"
     end
   end
 
   def show_html
     begin
-      render :text => Kaui::KillbillHelper.get_invoice_html(params[:id], options_for_klient)
+      render :text => Kaui::Invoice.as_html(params[:id], options_for_klient)
     rescue => e
       flash.now[:error] = "Error rendering invoice html #{params[:id]}: #{as_string(e)}"
       render :action => :index

data/app/controllers/kaui/payment_methods_controller.rb

@@ -1,30 +1,31 @@
-require 'kaui/killbill_helper'
-
 class Kaui::PaymentMethodsController < Kaui::EngineController
+
   def index
   end
 
   def pagination
-    json = { :sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => [] }
-
     search_key = params[:sSearch]
-    if search_key.present?
-      payment_methods = Kaui::KillbillHelper::search_payment_methods(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    else
-      payment_methods = Kaui::KillbillHelper::get_payment_methods(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    end
-    json[:iTotalDisplayRecords] = payment_methods.pagination_total_nb_records
-    json[:iTotalRecords] = payment_methods.pagination_max_nb_records
+    offset     = params[:iDisplayStart] || 0
+    limit      = params[:iDisplayLength] || 10
+
+    payment_methods = Kaui::PaymentMethod.list_or_search(search_key, offset, limit, options_for_klient)
+
+    json = {
+        :sEcho                => params[:sEcho],
+        :iTotalRecords        => payment_methods.pagination_max_nb_records,
+        :iTotalDisplayRecords => payment_methods.pagination_total_nb_records,
+        :aaData               => []
+    }
 
     payment_methods.each do |payment_method|
       info_plugin = payment_method.plugin_info || OpenStruct.new
       json[:aaData] << [
-                         view_context.link_to(payment_method.account_id, view_context.url_for(:controller => :accounts, :action => :show, :id => payment_method.account_id)),
-                         info_plugin.external_payment_id,
-                         info_plugin.type,
-                         info_plugin.cc_name,
-                         info_plugin.cc_last4,
-                       ]
+          view_context.link_to(view_context.truncate_uuid(payment_method.payment_method_id), view_context.url_for(:controller => :payment_methods, :action => :show, :id => payment_method.payment_method_id)),
+          view_context.link_to(view_context.truncate_uuid(payment_method.account_id), view_context.url_for(:controller => :accounts, :action => :show, :id => payment_method.account_id)),
+          info_plugin.external_payment_id,
+          find_value_from_properties(info_plugin.properties, 'ccName'),
+          find_value_from_properties(info_plugin.properties, 'ccLast4'),
+      ]
     end
 
     respond_to do |format|
@@ -32,26 +33,81 @@ class Kaui::PaymentMethodsController < Kaui::EngineController
     end
   end
 
+  def new
+    @payment_method = Kaui::PaymentMethod.new(:account_id  => params[:account_id],
+                                              :plugin_name => params[:plugin_name] || Kaui.creditcard_plugin_name.call)
+  end
+
+  def create
+    @payment_method             = Kaui::PaymentMethod.new(params[:payment_method].delete_if { |key, value| value.blank? })
+    # Transform "1" into boolean
+    @payment_method.is_default  = @payment_method.is_default == '1'
+    # Sensible default
+    @payment_method.plugin_name ||= Kaui.creditcard_plugin_name.call
+
+    # Instance variables needed in case of failure
+    @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]
+    @postal_code                = params[:postal_code]
+    @state                      = params[:state]
+    @country                    = params[:country]
+
+    @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
+    }
+
+    begin
+      @payment_method = @payment_method.create(current_user.kb_username, @reason, @comment, options_for_klient)
+      redirect_to payment_method_path(@payment_method.payment_method_id), :notice => 'Payment method was successfully created'
+    rescue => e
+      flash.now[:error] = "Error while creating payment method: #{as_string(e)}"
+      render :action => :new
+    end
+  end
+
   def show
-    @payment_methods = []
     begin
-      @payment_methods << Kaui::KillbillHelper.get_payment_method(params[:id], options_for_klient)
+      @payment_methods = [Kaui::PaymentMethod.find_by_id(params[:id], true, options_for_klient)]
     rescue => e
       flash.now[:error] = "Error while retrieving payment method #{params[:id]}: #{as_string(e)}"
+      render :action => :index
     end
   end
 
   def destroy
     payment_method_id = params[:id]
-    if payment_method_id.present?
-      begin
-        Kaui::KillbillHelper.delete_payment_method(payment_method_id, params[:set_auto_pay_off], current_user, params[:reason], params[:comment], options_for_klient)
-      rescue => e
-        flash[:error] = "Error while deleting payment method #{payment_method_id}: #{as_string(e)}"
-      end
-    else
-      flash[:notice] = 'Did not get the payment method id'
+
+    begin
+      Kaui::PaymentMethod.destroy(payment_method_id, params[:set_auto_pay_off], current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to payment_methods_path, :notice => "Payment method #{payment_method_id} successfully deleted"
+    rescue => e
+      flash.now[:error] = "Error while deleting payment method #{payment_method_id}: #{as_string(e)}"
+      render :action => :index
     end
-    redirect_to :back
+  end
+
+  private
+
+  def find_value_from_properties(properties, key)
+    return nil if key.nil? or properties.nil?
+    prop = (properties.find { |kv| kv.key.to_s == key.to_s })
+    prop.nil? ? nil : prop.value
   end
 end

data/app/controllers/kaui/payments_controller.rb

@@ -4,25 +4,33 @@ class Kaui::PaymentsController < Kaui::EngineController
   end
 
   def pagination
-    json = { :sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => [] }
+    json = {:sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => []}
 
     search_key = params[:sSearch]
     if search_key.present?
-      payments = Kaui::KillbillHelper::search_payments(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
+      payments = Kaui::Payment::find_in_batches_by_search_key(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
     else
-      payments = Kaui::KillbillHelper::get_payments(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
+      payments = Kaui::Payment::find_in_batches(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
     end
     json[:iTotalDisplayRecords] = payments.pagination_total_nb_records
-    json[:iTotalRecords] = payments.pagination_max_nb_records
+    json[:iTotalRecords]        = payments.pagination_max_nb_records
 
     payments.each do |payment|
+      created_date = nil
+      payment.transactions.each do |transaction|
+        transaction_date = Date.parse(transaction.effective_date)
+        if created_date.nil? or transaction_date < created_date
+          created_date = transaction_date
+        end
+      end
+
       json[:aaData] << [
-                         view_context.link_to(payment.account_id, view_context.url_for(:controller => :accounts, :action => :show, :id => payment.account_id)),
-                         payment.payment_number,
-                         view_context.format_date(payment.effective_date),
-                         view_context.humanized_money_with_symbol(Kaui::Base.to_money(payment.amount, payment.currency)),
-                         payment.status
-                       ]
+          view_context.link_to(view_context.truncate_uuid(payment.account_id), view_context.url_for(:controller => :accounts, :action => :show, :id => payment.account_id)),
+          payment.payment_number,
+          view_context.format_date(created_date),
+          view_context.humanized_money_with_symbol(payment.paid_amount_to_money),
+          view_context.humanized_money_with_symbol(payment.returned_amount_to_money)
+      ]
     end
 
     respond_to do |format|
@@ -31,30 +39,60 @@ class Kaui::PaymentsController < Kaui::EngineController
   end
 
   def new
-    @account_id = params[:account_id]
-    @invoice_id = params[:invoice_id]
+    account_id = params[:account_id]
+    invoice_id = params[:invoice_id]
+    amount     = 0
+
+    if invoice_id.nil?
+      flash[:error] = 'No invoice id specified'
+      render :action => :index and return
+    end
+
+    if account_id.nil?
+      flash[:error] = 'No account id specified'
+      render :action => :index and return
+    end
+
     begin
-      @invoice = Kaui::KillbillHelper::get_invoice(@invoice_id, true, "NONE", options_for_klient)
-      @account = Kaui::KillbillHelper::get_account(@account_id, false, false, options_for_klient)
+      @invoice = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
+      amount   = @invoice.balance
     rescue => e
-      flash[:error] = "Error while creating a new payment: #{as_string(e)}"
-      redirect_to kaui_engine.account_timeline_path(:id => payment.account_id)
+      flash[:error] = "Unable to retrieve invoice: #{as_string(e)}"
+      render :action => :index and return
+    end
+
+    begin
+      @account = Kaui::Account.find_by_id(account_id, false, false, options_for_klient)
+    rescue => e
+      flash[:error] = "Unable to retrieve account: #{as_string(e)}"
+      render :action => :index and return
     end
 
-    @payment = Kaui::Payment.new("accountId" => @account_id, "invoiceId" => @invoice_id, "amount" => @invoice.balance)
+    @payment = Kaui::InvoicePayment.new('accountId' => account_id, 'targetInvoiceId' => invoice_id, 'purchasedAmount' => amount)
   end
 
   def create
-    payment = Kaui::Payment.new(params[:payment])
-    if payment.present?
-      payment.external = (payment.external == "1")
-      begin
-        Kaui::KillbillHelper::create_payment(payment, payment.external, current_user, params[:reason], params[:comment], options_for_klient)
-        flash[:notice] = "Payment created"
-      rescue => e
-        flash[:error] = "Error while creating a new payment: #{as_string(e)}"
-      end
+    payment = Kaui::InvoicePayment.new(params[:invoice_payment])
+
+    begin
+      payment        = payment.create(params[:external] == '1', current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      flash[:notice] = 'Payment created'
+    rescue => e
+      flash[:error] = "Error while creating a new payment: #{as_string(e)}"
+      render :action => :index and return
     end
+
     redirect_to kaui_engine.account_timeline_path(:id => payment.account_id)
   end
+
+  def show
+    begin
+      @payments        = [Kaui::InvoicePayment.find_by_id(params[:id], true, options_for_klient)]
+      @account         = Kaui::Account.find_by_id(@payments.first.account_id, false, false, options_for_klient)
+      @payment_methods = Kaui::PaymentMethod.payment_methods_for_payments(@payments, options_for_klient)
+    rescue => e
+      flash.now[:error] = "Error while looking up payment: #{as_string(e)}"
+      render :action => :index
+    end
+  end
 end