gistfile1.txt

class TransactionsController < ApplicationController

  def payment
    amount = BigDecimal.new(params[:amount])
    contract = Contract.find_by_ra_num(params[:ra_num])      
    case params[:payment_method]
    when 'creditcard'
      #use existing creditcard transaction
      if params[:id].present?
        transaction = Transaction.find(params[:id])
        card = Braintree::Transaction.find(transaction.transaction_id)
        if card.status == 'authorized' && amount <= card.amount
          settlement = settle(contract, transaction.transaction_id, amount)
          if settlement.success?
            flash[:notice] = 'Payment was successful.'
          else
            flash[:error] = settlement.errors
          end
        elsif card.status == 'authorized' && amount > card.amount
          settlement = settle(contract, transaction.transaction_id, card.amount)
          if settlement.success?
            new_balance = amount - card.amount
            new_authorization = authorize(contract, new_balance, {:vault_id => transaction.vault_id}, :vault)
            if new_authorization.success?
              new_settlement = settle(contract, new_authorization.transaction.id, new_balance)
              if new_settlement.success?
                flash[:notice] = 'Payment was successful.'
              else
                flash[:error] = new_settlement.errors
              end
            else
              flash[:error] = new_authorization.errors
            end
          end
        else
          authorization = authorize(contract, amount, {:vault_id => transaction.vault_id}, :vault)
          if authorization.success?
            settlement = settle(contract, authorization.transaction.id, amount)
            if settlement.success?
              flash[:notice] = 'Payment was successful.'
            else
              flash[:error] = settlement.errors
          else
            flash[:error] = authorization.errors
          end
        end
      #use new creditcard
      else
        authorization = authorize(contract, amount, params)
        if authorization.success?
          settlement = settle(contract, authorization.transaction.id, amount)
          if settlement.success?
            flash[:notice] = 'Payment was successful.'
          else
            flash[:error] = settlement.errors
          end
        else
          flash[:error] = authorization.errors
        end
      end
    when 'cash'
      record_transaction(nil, contract.ra_num, 'payment', 'cash')
      flash[:notice] = "Payment was successful."
    end
    redirect_to contract
  end
  
  def deposit
    @contract = Contract.find(params[:contract_id])
    respond_to do |format|
      format.js {
        expiration_date = Date.strptime("#{params[:cc_month]}-01-#{params[:cc_year]}", "%m-%d-%y").end_of_month
        if @contract.expected_dropoff > expiration_date
          render :js => "alert('Credit card expires before end of rental.  Please use another card.');"
        else
          authorization = authorize(@contract, params[:cc_amount], params)
          if authorization.success?
            @contract.update_attributes(:status => 'OPEN')
            render :update do |page|
              flash[:notice] = "Authorization Successful."
              page.redirect_to @contract
            end
          else
            render :js => "alert('#{authorization.errors}');"
          end
        end
      }
    end
  end
  
  private
  
  def record_transaction(result, ra_num, action, payment_method)
    params[:transaction] = {
      :ra_num => ra_num,
      :amount => result.transaction.amount,
      :payment_method => payment_method,
      :action => action,
      :agent => current_user.username
    }
    case payment_method
    when 'cash'
    when 'creditcard'
      params[:transaction][:transaction_id] = result.transaction.id
      params[:transaction][:vault_id] = result.transaction.credit_card_details.token
      params[:transaction][:card_num] = result.transaction.credit_card_details.last_4
    end
    Transaction.create(params[:transaction])
  end
  
  def authorize(contract, amount, params, *args)
    if args.include?(:vault)
      result = Braintree::Transaction.sale(params[:vault_id], :amount => amount)
    else
      result = Braintree::Transaction.sale(
        :amount => amount,
        :credit_card => {
          :number => params[:cc_num],
          :expiration_date => "#{params[:cc_month]}/#{params[:cc_year]}",
          :cardholder_name => params[:cc_name]
        },
        :customer => {
          :first_name => contract.first_name,
          :last_name => contract.last_name
        },
        :options => { :store_in_vault_on_success => true }
      )
    end
    if result.success?
      record_transaction(result, contract.ra_num, 'authorization', 'creditcard')
    end
    return result
  end
  
  def settle(contract, gateway_transaction_id, amount)
    result = Braintree::Transaction.submit_for_settlement(gateway_transaction_id, amount)
    if result.success?
      record_transaction(result, contract.ra_num, 'payment', 'creditcard')
    end
    return result
  end
  
  def authorize_and_settle(contract, amount, params, *args)
    authorization = authorize(contract, amount, params, *args)
    if authorization.success?
      settlement = settle(contract, authorization.transaction.id, amount)
      return settlement
    else
      return authorization
    end
  end

end