kaui 0.6.6 → 0.7.0

data/app/controllers/kaui/refunds_controller.rb

@@ -1,127 +1,47 @@
 class Kaui::RefundsController < Kaui::EngineController
 
-  def index
-    if params[:refund_id].present?
-      redirect_to kaui_engine.refund_path(params[:refund_id])
-    end
-  end
-
-  def pagination
-    json = { :sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => [] }
-
-    search_key = params[:sSearch]
-    if search_key.present?
-      refunds = Kaui::KillbillHelper::search_refunds(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    else
-      refunds = Kaui::KillbillHelper::get_refunds(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    end
-    json[:iTotalDisplayRecords] = refunds.pagination_total_nb_records
-    json[:iTotalRecords] = refunds.pagination_max_nb_records
-
-    refunds.each do |refund|
-      json[:aaData] << [
-                         view_context.link_to(refund.refund_id, view_context.url_for(:controller => :refunds, :action => :show, :id => refund.refund_id)),
-                         view_context.format_date(refund.effective_date),
-                         view_context.humanized_money_with_symbol(Kaui::Base.to_money(refund.amount, refund.currency)),
-                         refund.adjusted,
-                         refund.status
-                       ]
-    end
-
-    respond_to do |format|
-      format.json { render :json => json }
-    end
-  end
-
-  def show
-    if params[:id].present?
-      begin
-        data = Kaui::KillbillHelper::get_refund(params[:id], options_for_klient)
-      rescue => e
-        flash.now[:error] = "Error while retrieving the refund with id #{params[:id]}: #{as_string(e)}"
-      end
-      if data.present?
-        @refunds = [data]
-      else
-        begin
-          @refunds = Kaui::KillbillHelper::get_refunds_for_payment(params[:id], options_for_klient)
-          unless @refunds.present?
-            flash.now[:error] = "Refund for id or payment id #{params[:id]} couldn't be found"
-            render :action => :index and return
-          end
-        rescue => e
-          flash.now[:error] = "Error while retrieving the refunds for the payment: #{as_string(e)}"
-          render :action => :index and return
-        end
-      end
-
-      if @refunds.size > 0
-        begin
-          # Retrieve the account via the payment
-          payment = Kaui::KillbillHelper::get_payment(@refunds[0].payment_id, options_for_klient)
-          unless payment.present?
-            flash.now[:error] = "Account for payment id #{@refunds[0].payment_id} couldn't be found"
-            render :action => :index
-          end
-          @account = Kaui::KillbillHelper::get_account(payment.account_id, false, false, options_for_klient)
-        rescue => e
-          flash.now[:error] = "Error while retrieving the account for the refund: #{as_string(e)}"
-          render :action => :index
-        end
-      end
-    else
-      flash.now[:error] = "A refund or payment id should be specifed"
-      render :action => :index
-    end
-  end
-
   def new
-    @payment_id = params[:payment_id]
-    @invoice_id = params[:invoice_id]
-    @account_id = params[:account_id]
+    payment_id = params[:payment_id]
+    invoice_id = params[:invoice_id]
+    account_id = params[:account_id]
 
-    @refund = Kaui::Refund.new('adjusted' => true)
+    @refund = KillBillClient::Model::InvoiceItem.new
 
     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)
+      @account = Kaui::Account.find_by_id(account_id, false, false, options_for_klient)
+      @payment = Kaui::InvoicePayment::find_by_id(payment_id, false, options_for_klient)
+      @invoice = Kaui::Invoice.find_by_id_or_number(invoice_id, true, 'NONE', options_for_klient)
     rescue => e
       flash[:error] = "Error while processing refund: #{as_string(e)}"
-      redirect_to kaui_engine.account_timeline_path(:id => params[:account_id])
+      redirect_to kaui_engine.account_timeline_path(:id => account_id)
     end
   end
 
   def create
-    invoice = Kaui::KillbillHelper::get_invoice(params[:invoice_id], true, "NONE", options_for_klient)
-    refund = {}
-    refund.merge! params[:refund]
-    refund["adjusted"] = (refund["adjustment_type"] != "noInvoiceAdjustment")
+    invoice = Kaui::Invoice.find_by_id_or_number(params[:invoice_id], true, 'NONE', options_for_klient)
+
+    items = []
+    if params[:adjustment_type] == 'invoiceItemAdjustment'
+      (params[:adjustments] || []).each do |ii|
+        original_item       = find_original_item(invoice.items, ii[0])
 
-    if refund["adjustment_type"] == "invoiceItemAdjustment"
-      refund["adjustments"] = []
-      params[:adjustments].each_with_index do |ii, idx|
-        original_item = find_original_item(invoice.items, ii[0])
-        h = Hash.new
-        h[:invoice_item_id] = ii[0]
+        item = KillBillClient::Model::InvoiceItem.new
+        item.invoice_item_id = ii[0]
         # If we tried to do a partial item adjustment, we pass the value, if not we don't send any value and let the system
-        # decide what is the maxium amount we can have on that item
-        h[:amount] = (ii[1].to_f == original_item.amount) ? nil : ii[1]
-        kaui_ii = Kaui::InvoiceItem.new(h)
-        puts "Got #{kaui_ii.inspect}"
-        refund["adjustments"][idx] = kaui_ii
+        # decide what is the maximum amount we can have on that item
+        item.amount = (ii[1].to_f == original_item.amount) ? nil : ii[1]
+
+        items << item
       end
     end
-    if refund.present?
-      begin
-        Kaui::KillbillHelper::create_refund(params[:payment_id], refund, current_user, params[:reason], params[:comment], options_for_klient)
-        flash[:notice] = "Refund created"
-      rescue => e
-        flash[:error] = "Error while processing refund: #{as_string(e)}"
-      end
-    else
-      flash[:error] = "No refund to process"
+
+    begin
+      KillBillClient::Model::InvoicePayment.refund(params[:payment_id], params[:amount], items, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      flash[:notice] = 'Refund created'
+    rescue => e
+      flash[:error] = "Error while processing refund: #{as_string(e)}"
     end
+
     redirect_to kaui_engine.account_timeline_path(:id => params[:account_id])
   end
 

data/app/controllers/kaui/subscriptions_controller.rb

@@ -1,121 +1,73 @@
-require 'kaui/product'
-
 class Kaui::SubscriptionsController < Kaui::EngineController
-  def index
-    if params[:subscription_id].present?
-      redirect_to kaui_engine.subscription_path(params[:subscription_id])
-    end
-  end
 
-  def show
-    begin
-      @subscription = Kaui::KillbillHelper.get_subscription(params[:id], options_for_klient)
-      unless @subscription.present?
-        flash[:error] = "No subscription id given or subscription not found"
-        redirect_to :back
-      end
-
-      @account = Kaui::KillbillHelper::get_account_by_bundle_id(@subscription.bundle_id, options_for_klient)
-      unless @account.present?
-        flash[:error] = "Unable to retrieve account for bundle #{@subscription.bundle_id}"
-        redirect_to :back
-      end
-    rescue => e
-      flash.now[:error] = "Error while getting subscription information: #{as_string(e)}"
-    end
+  def index
   end
 
   def new
-    @account_id = params[:account_id]
-    bundle_id = params[:bundle_id]
-    @base_subscription = params[:base_subscription]
-    @product_category = params[:product_category]
-    begin
+    @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')
 
-      if @product_category == "ADD_ON"
-        @bundle = Kaui::KillbillHelper::get_bundle(bundle_id, options_for_klient)
-        @catalog = Kaui::KillbillHelper::get_available_addons(@base_subscription, options_for_klient)
-      elsif @product_category == "BASE"
-        @catalog = Kaui::KillbillHelper::get_available_base_plans(options_for_klient)
+    begin
+      if @subscription.product_category == 'ADD_ON'
+        @bundle       = Kaui::Bundle::find_by_id(@subscription.bundle_id, options_for_klient)
+        plans_details = Kaui::Catalog::available_addons(@base_product_name, options_for_klient)
+      else
+        plans_details = Kaui::Catalog::available_base_plans(options_for_klient)
       end
+      @plans = plans_details.map { |p| p.plan }
     rescue => e
       flash.now[:error] = "Error while trying to start new subscription creation: #{as_string(e)}"
+      render :action => :index
     end
-    @subscription = Kaui::Subscription.new("bundleId" => bundle_id, "accountId" => @account_id, "product_category" => @product_category)
   end
 
   def create
-
-    @subscription = Kaui::Subscription.new(params[:subscription])
-
-    @plan_name = params[:plan_name]
+    @subscription = Kaui::Subscription.new(params[:subscription].delete_if { |key, value| value.blank? })
 
     begin
-      if @subscription.product_category == "ADD_ON"
-        @base_subscription = params[:base_subscription]
-        @bundle = Kaui::KillbillHelper::get_bundle(@subscription.bundle_id, options_for_klient)
-        @catalog = Kaui::KillbillHelper::get_available_addons(@base_subscription, options_for_klient)
-        @subscription.account_id = @bundle.account_id
+      if @subscription.product_category == 'ADD_ON'
+        @bundle       = Kaui::Bundle::find_by_id(@subscription.bundle_id, options_for_klient)
+        plans_details = Kaui::Catalog::available_addons(params[:base_product_name], options_for_klient)
       else
-        @catalog = Kaui::KillbillHelper::get_available_base_plans(options_for_klient)
-        @subscription.external_key = params[:external_key]
+        plans_details = Kaui::Catalog::available_base_plans(options_for_klient)
       end
 
-      plan = @catalog[@plan_name]
-      @subscription.billing_period = plan["billingPeriod"]
-      @subscription.product_name = plan["productName"]
-      @subscription.price_list = plan["priceListName"]
-
-      res = Kaui::KillbillHelper::create_subscription(@subscription, current_user, params[:reason], params[:comment], options_for_klient)
+      plan_details                 = plans_details.find { |p| p.plan == params[:plan_name] }
+      @subscription.billing_period = plan_details.final_phase_billing_period
+      @subscription.product_name   = plan_details.product
+      @subscription.price_list     = plan_details.price_list
 
-      redirect_to Kaui.bundle_home_path.call(res.bundle_id)
+      @subscription = @subscription.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to bundle_path(@subscription.bundle_id), :notice => 'Subscription was successfully created'
     rescue => e
-      flash.now[:error] = "Error while creating the new subscription: #{as_string(e)}"
+      @plans            = plans_details.nil? ? [] : plans_details.map { |p| p.plan }
+      flash.now[:error] = "Error while creating the subscription: #{as_string(e)}"
       render :new
     end
   end
 
-  def add_addon
-    @base_product_name = params[:base_product_name]
-
-    @account_id = params[:account_id]
-    @bundle_id = params[:bundle_id]
-    @product_name = params[:product_name]
-    @product_category = params[:product_category]
-    @billing_period = params[:billing_period]
-    @price_list = params[:price_list]
-
+  def show
     begin
-      @subscription = Kaui::Subscription.new(:account_id => @account_id,
-                                             :bundle_id => @bundle_id,
-                                             :product_name => @product_name,
-                                             :product_category => @product_category,
-                                             :billing_period => @billing_period,
-                                             :price_list => @price_list)
-
-      @bundle = Kaui::KillbillHelper.get_bundle(subscription.bundle_id, options_for_klient)
-      @available_plans = Kaui::KillbillHelper.get_available_addons(params[:base_product_name], options_for_klient)
+      @subscription = Kaui::Subscription.find_by_id(params[:id], options_for_klient)
+      # Need to retrieve the account for the timezone
+      @account      = Kaui::Account::find_by_id(@subscription.account_id, false, false, options_for_klient)
     rescue => e
-      flash.now[:error] = "Error while adding an addon: #{as_string(e)}"
+      flash.now[:error] = "Error while getting subscription information: #{as_string(e)}"
+      render :action => :index
     end
   end
 
   def edit
     begin
-      @subscription = Kaui::KillbillHelper.get_subscription(params[:id], options_for_klient)
-      if @subscription.present?
-        @bundle = Kaui::KillbillHelper::get_bundle(@subscription.bundle_id, options_for_klient)
-        @account = Kaui::KillbillHelper::get_account(@bundle.account_id, false, false, options_for_klient)
-        @catalog = Kaui::KillbillHelper::get_available_base_plans(options_for_klient)
+      @subscription = Kaui::Subscription.find_by_id(params[:id], options_for_klient)
+      plans_details = Kaui::Catalog::available_base_plans(options_for_klient)
+      @plans        = plans_details.map { |p| p.plan }
 
-        @current_plan = "#{@subscription.product_name} #{@subscription.billing_period}".humanize
-
-        if @subscription.price_list != "DEFAULT"
-          @current_plan += " (price list #{@subscription.price_list})"
-        end
-      else
-        flash[:error] = "No subscription id given or subscription not found"
-        redirect_to :back
+      @current_plan = "#{@subscription.product_name} #{@subscription.billing_period}".humanize
+      if @subscription.price_list != 'DEFAULT'
+        @current_plan += " (price list #{@subscription.price_list})"
       end
     rescue => e
       flash.now[:error] = "Error while editing subscription: #{as_string(e)}"
@@ -123,61 +75,65 @@ class Kaui::SubscriptionsController < Kaui::EngineController
   end
 
   def update
-    if params.has_key?(:subscription) && params[:subscription].has_key?(:subscription_id)
-
-      begin
-        subscription = Kaui::KillbillHelper::get_subscription(params[:subscription][:subscription_id], options_for_klient)
-        bundle = Kaui::KillbillHelper::get_bundle(subscription.bundle_id, options_for_klient)
-        catalog = Kaui::KillbillHelper::get_available_base_plans(options_for_klient)
-
-        plan = catalog[params[:plan_name]]
-        requested_date = params[:requested_date]
-        policy = params[:policy] unless params[:policy].empty?
-
-        subscription.billing_period = plan["billingPeriod"]
-        subscription.product_category = plan["productCategory"]
-        subscription.product_name = plan["productName"]
-        subscription.price_list = plan["priceListName"]
-        subscription.subscription_id = params[:subscription][:subscription_id]
-
-        Kaui::KillbillHelper::update_subscription(subscription, requested_date, policy, current_user, params[:reason], params[:comment], options_for_klient)
-      rescue => e
-        flash[:error] = "Error while updating subscription: #{as_string(e)}"
-      end
-    else
-      flash[:error] = "No subscription given"
+    requested_date      = params[:requested_date] unless params[:requested_date].blank?
+    billing_policy      = params[:policy] unless params[:policy].blank?
+    wait_for_completion = params[:wait_for_completion] == '1'
+
+    subscription = Kaui::Subscription.new(:subscription_id => params[:id])
+
+    begin
+      plans_details    = Kaui::Catalog::available_base_plans(options_for_klient)
+      new_plan_details = plans_details.find { |p| p.plan == params[:plan_name] }
+
+      subscription.change_plan({
+                                   :productName   => new_plan_details.product,
+                                   :billingPeriod => new_plan_details.final_phase_billing_period,
+                                   :priceList     => new_plan_details.price_list
+                               },
+                               current_user.kb_username,
+                               params[:reason],
+                               params[:comment],
+                               requested_date,
+                               billing_policy,
+                               wait_for_completion,
+                               options_for_klient)
+      flash[:notice] = 'Subscription plan successfully changed'
+    rescue => e
+      flash[:error] = "Error while changing subscription plan: #{as_string(e)}"
     end
-    redirect_to Kaui.bundle_home_path.call(bundle.bundle_id)
+
+    redirect_to subscription_path(subscription.subscription_id)
   end
 
   def destroy
-    subscription_id = params[:id]
+    requested_date                 = params[:requested_date] unless params[:requested_date].blank?
+    entitlement_policy             = params[:policy] unless params[:policy].blank?
+    billing_policy                 = entitlement_policy
+    # true by default
+    use_requested_date_for_billing = (params[:use_requested_date_for_billing] || '1') == '1'
 
-    if subscription_id.present?
-      begin
-        Kaui::KillbillHelper::delete_subscription(subscription_id, current_user, params[:reason], params[:comment], params[:policy], params[:policy], options_for_klient)
-      rescue => e
-        flash[:error] = "Error while canceling subscription: #{as_string(e)}"
-      end
-    else
-      flash[:error] = "No subscription id given"
+    subscription = Kaui::Subscription.new(:subscription_id => params[:id])
+
+    begin
+      subscription.cancel(current_user.kb_username, params[:reason], params[:comment], requested_date, entitlement_policy, billing_policy, use_requested_date_for_billing, options_for_klient)
+      flash[:notice] = 'Subscription was successfully cancelled'
+    rescue => e
+      flash[:error] = "Error while canceling subscription: #{as_string(e)}"
     end
-    redirect_to :back
+
+    redirect_to subscription_path(subscription.subscription_id)
   end
 
   def reinstate
-    subscription_id = params[:id]
-    if subscription_id.present?
-      begin
-        Kaui::KillbillHelper::reinstate_subscription(subscription_id, current_user, params[:reason], params[:comment], options_for_klient)
-        flash[:notice] = "Subscription reinstated"
-      rescue => e
-        flash[:error] = "Error while reinstating subscription: #{as_string(e)}"
-      end
-    else
-      flash[:error] = "No subscription id given"
+    subscription = Kaui::Subscription.new(:subscription_id => params[:id])
+
+    begin
+      subscription.uncancel(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      flash[:notice] = 'Subscription was successfully reinstated'
+    rescue => e
+      flash[:error] = "Error while reinstating subscription: #{as_string(e)}"
     end
-    redirect_to :back
-  end
 
+    redirect_to subscription_path(subscription.subscription_id)
+  end
 end

data/app/controllers/kaui/tag_definitions_controller.rb

@@ -1,90 +1,43 @@
-module Kaui
-  class TagDefinitionsController < Kaui::EngineController
-    # GET /tag_definitions
-    # GET /tag_definitions.json
-    def index
-      begin
-        @tag_definitions = TagDefinition.all(options_for_klient)
-      rescue => e
-        flash.now[:error] = "Error while retrieving tag definitions: #{as_string(e)}"
-        @tag_definitions = []
-      end
-
-      respond_to do |format|
-        format.html # index.html.erb
-        format.json { render :json => @tag_definitions }
-      end
-    end
-
-    # GET /tag_definitions/1
-    # GET /tag_definitions/1.json
-    def show
-      @tag_definition = TagDefinition.find(params[:id], options_for_klient)
-
-      respond_to do |format|
-        format.html # show.html.erb
-        format.json { render :json => @tag_definition }
-      end
-    end
-
-    # GET /tag_definitions/new
-    # GET /tag_definitions/new.json
-    def new
-      @tag_definition = TagDefinition.new
-
-      respond_to do |format|
-        format.html # new.html.erb
-        format.json { render :json => @tag_definition }
-      end
-    end
-
-    # GET /tag_definitions/1/edit
-    def edit
-      @tag_definition = TagDefinition.find(params[:id], options_for_klient)
+class Kaui::TagDefinitionsController < Kaui::EngineController
+
+  def index
+    begin
+      @tag_definitions = Kaui::TagDefinition.all('NONE', options_for_klient)
+    rescue => e
+      flash.now[:error] = "Error while retrieving tag definitions: #{as_string(e)}"
+      @tag_definitions  = []
     end
+  end
 
-    # POST /tag_definitions
-    # POST /tag_definitions.json
-    def create
-      @tag_definition = TagDefinition.new(params[:tag_definition])
+  def show
+    @tag_definition = Kaui::TagDefinition.find_by_id(params[:id], 'NONE', options_for_klient)
+  end
 
-      respond_to do |format|
-        if @tag_definition.save(current_user, params[:reason], params[:comment], options_for_klient)
-          format.html { redirect_to @tag_definition, :notice => 'Tag definition was successfully created.' }
-          format.json { render :json => @tag_definition, :status => :created, :location => @tag_definition }
-        else
-          format.html { render :action => "new" }
-          format.json { render :json => @tag_definition.errors, :status => :unprocessable_entity }
-        end
-      end
-    end
+  def new
+    @tag_definition = Kaui::TagDefinition.new
+  end
 
-    # PUT /tag_definitions/1
-    # PUT /tag_definitions/1.json
-    def update
-      @tag_definition = TagDefinition.find(params[:id], options_for_klient)
+  def create
+    @tag_definition = Kaui::TagDefinition.new(params[:tag_definition])
 
-      respond_to do |format|
-        if @tag_definition.update_attributes(params[:tag_definition])
-          format.html { redirect_to @tag_definition, :notice => 'Tag definition was successfully updated.' }
-          format.json { head :no_content }
-        else
-          format.html { render :action => "edit" }
-          format.json { render :json => @tag_definition.errors, :status => :unprocessable_entity }
-        end
-      end
+    begin
+      @tag_definition = @tag_definition.create(current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.tag_definition_path(@tag_definition.id), :notice => 'Tag definition successfully created'
+    rescue => e
+      flash.now[:error] = "Error while creating tag definition: #{as_string(e)}"
+      render :action => :new
     end
+  end
 
-    # DELETE /tag_definitions/1
-    # DELETE /tag_definitions/1.json
-    def destroy
-      @tag_definition = TagDefinition.find(params[:id], options_for_klient)
-      @tag_definition.destroy(current_user, params[:reason], params[:comment], options_for_klient)
+  def destroy
+    @tag_definition = Kaui::TagDefinition.find_by_id(params[:id], 'NONE', options_for_klient)
 
-      respond_to do |format|
-        format.html { redirect_to tag_definitions_url, :notice => 'Tag definition was successfully destroyed.' }
-        format.json { head :no_content }
-      end
+    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
     end
   end
 end

data/app/controllers/kaui/tags_controller.rb

@@ -4,27 +4,29 @@ class Kaui::TagsController < Kaui::EngineController
   end
 
   def pagination
-    json = { :sEcho => params[:sEcho], :iTotalRecords => 0, :iTotalDisplayRecords => 0, :aaData => [] }
-
     search_key = params[:sSearch]
-    if search_key.present?
-      tags = Kaui::KillbillHelper::search_tags(search_key, params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    else
-      tags = Kaui::KillbillHelper::get_tags(params[:iDisplayStart] || 0, params[:iDisplayLength] || 10, options_for_klient)
-    end
-    json[:iTotalDisplayRecords] = tags.pagination_total_nb_records
-    json[:iTotalRecords] = tags.pagination_max_nb_records
+    offset     = params[:iDisplayStart] || 0
+    limit      = params[:iDisplayLength] || 10
+
+    tags = Kaui::Tag.list_or_search(search_key, offset, limit, options_for_klient)
+
+    json = {
+        :sEcho                => params[:sEcho],
+        :iTotalRecords        => tags.pagination_max_nb_records,
+        :iTotalDisplayRecords => tags.pagination_total_nb_records,
+        :aaData               => []
+    }
 
     tags.each do |tag|
       json[:aaData] << [
-                         tag.tag_id,
-                         tag.object_type,
-                         tag.tag_definition_name,
-                       ]
+          tag.tag_id,
+          tag.object_type,
+          tag.tag_definition_name,
+      ]
     end
 
     respond_to do |format|
       format.json { render :json => json }
     end
   end
-end
+end

data/app/controllers/kaui/transactions_controller.rb

@@ -0,0 +1,25 @@
+class Kaui::TransactionsController < Kaui::EngineController
+
+  def new
+    @account_id        = params[:account_id]
+    @payment_method_id = params[:payment_method_id]
+    @transaction       = Kaui::Transaction.new(:payment_id       => params[:payment_id],
+                                               :amount           => params[:amount],
+                                               :currency         => params[:currency],
+                                               :transaction_type => params[:transaction_type])
+  end
+
+  def create
+    @account_id        = params[:account_id]
+    @payment_method_id = params[:payment_method_id]
+    @transaction       = Kaui::Transaction.new(params[:transaction].delete_if { |key, value| value.blank? })
+
+    begin
+      payment = @transaction.create(@account_id, @payment_method_id, current_user.kb_username, params[:reason], params[:comment], options_for_klient)
+      redirect_to kaui_engine.account_timeline_path(:id => payment.account_id), :notice => 'Transaction successfully created'
+    rescue => e
+      flash.now[:error] = "Error while creating a new transaction: #{as_string(e)}"
+      render :action => :new
+    end
+  end
+end

data/app/helpers/kaui/money_helper.rb

@@ -0,0 +1,8 @@
+module Kaui
+  module MoneyHelper
+
+    def currencies
+      (Money::Currency.table.map { |c| c[1][:iso_code] } + ['BTC']).sort.uniq
+    end
+  end
+end