dune-balanced-bankaccount 1.0.0

data/app/controllers/dune/balanced/bankaccount/payments_controller.rb

@@ -0,0 +1,65 @@
+module Dune::Balanced::Bankaccount
+  class PaymentsController < AccountsController
+    def create
+      attach_bank_to_customer
+      update_customer
+
+      payment = Dune::Balanced::Bankaccount::PaymentGenerator.new(
+        customer,
+        resource,
+        resource_params
+      )
+      payment.complete
+
+      redirect_to(*checkout_response_params(payment.status))
+    end
+
+    def update_customer
+      Dune::Balanced::Customer.new(current_user, params).update!
+    end
+
+    protected
+    def resource
+      @resource ||= if params[:payment][:match_id].present?
+                      Match.find(params[:payment].fetch(:match_id))
+                    else
+                      Contribution.find(params[:payment].fetch(:contribution_id))
+                    end
+    end
+
+    def resource_name
+      resource.class.model_name.singular.to_sym
+    end
+
+    def checkout_response_params(status)
+      route_params = [resource.project.permalink, resource.id]
+
+      {
+        contribution: {
+          succeeded: [
+            main_app.project_contribution_path(*route_params)
+          ],
+          pending: [
+            main_app.project_contribution_path(*route_params)
+          ],
+          failed: [
+            main_app.edit_project_contribution_path(*route_params),
+            alert: t('.errors.default')
+          ]
+        },
+        match: {
+          succeeded: [
+            main_app.project_match_path(*route_params)
+          ],
+          pending: [
+            main_app.project_match_path(*route_params)
+          ],
+          failed: [
+            main_app.edit_project_match_path(*route_params),
+            alert: t('.errors.default')
+          ]
+        }
+      }.fetch(resource_name).fetch(status)
+    end
+  end
+end

data/app/controllers/dune/balanced/bankaccount/routing_numbers_controller.rb

@@ -0,0 +1,10 @@
+module Dune::Balanced::Bankaccount
+  class RoutingNumbersController < ApplicationController
+
+    def show
+      routing_number = RoutingNumber.where(number: params[:id]).first
+      render json: { ok: routing_number.present?, bank_name: routing_number.try(:bank_name) }
+    end
+
+  end
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,8 @@
+module ApplicationHelper
+  def method_missing(method, *args, &block)
+    return main_app.send(method, *args) if (method.to_s.end_with?('_path') ||
+                                            method.to_s.end_with?('_url')) &&
+                                            main_app.respond_to?(method)
+    super
+  end
+end

data/app/models/dune/balanced/bankaccount/delayed_payment.rb

@@ -0,0 +1,18 @@
+module Dune::Balanced::Bankaccount
+  class DelayedPayment < PaymentBase
+    def checkout!
+      resource.wait_confirmation!
+
+      @status = :succeeded
+      resource.update_attributes(
+        payment_method:                   engine_name,
+        payment_service_fee:              fee_calculator.fees,
+        payment_service_fee_paid_by_user: attrs[:pay_fee]
+      )
+    end
+
+    def successful?
+      @status.eql? :succeeded
+    end
+  end
+end

data/app/models/dune/balanced/bankaccount/delayed_payment_processing.rb

@@ -0,0 +1,22 @@
+module Dune::Balanced::Bankaccount
+  class DelayedPaymentProcessing
+    def initialize(contributor, resources)
+      @contributor, @resources = contributor, resources
+    end
+
+    def complete
+      @resources.each do |resource|
+        Dune::Balanced::Bankaccount::Payment.new(
+          'balanced-bankaccount',
+          customer,
+          resource,
+          {}
+        ).checkout!
+      end
+    end
+
+    def customer
+      @customer ||= ::Balanced::Customer.find(@contributor.href)
+    end
+  end
+end

data/app/models/dune/balanced/bankaccount/payment.rb

@@ -0,0 +1,69 @@
+module Dune::Balanced::Bankaccount
+  class Payment < PaymentBase
+    def checkout!
+      perform_debit!
+      resource.confirm
+    rescue Balanced::BadRequest
+      @status = :failed
+      resource.cancel
+    ensure
+      resource.update_attributes(
+        payment_id:                       @debit.try(:id),
+        payment_method:                   engine_name,
+        payment_service_fee:              fee_calculator.fees,
+        payment_service_fee_paid_by_user: attrs[:pay_fee]
+      )
+      update_meta(@debit) if @debit
+    end
+
+    def successful?
+      %i(pending succeeded).include? status
+    end
+
+    def debit_resource_href
+      attrs.fetch(:use_bank) { contributor.bank_account_href }
+    end
+
+    def contributor
+      @contributor ||= Dune::Balanced::Contributor.find_by(href: @customer.href)
+    end
+
+    private
+
+    def perform_debit!
+      debit_params = {
+        amount:                  amount_in_cents,
+        appears_on_statement_as: ::Configuration[:balanced_appears_on_statement_as],
+        description:             debit_description,
+        meta:                    meta,
+        source:                  bank_account
+      }
+
+      order  = Dune::Balanced::OrderProxy.new(resource.project)
+      @debit = order.debit_from(debit_params)
+    end
+
+    def update_meta(debit)
+      debit.meta = meta
+      debit.save
+    end
+
+    def resource_name
+      resource.class.model_name.singular
+    end
+
+    def debit_description
+      I18n.t('description',
+             project_name: resource.try(:project).try(:name),
+             scope: "dune.balanced.bankaccount.payments.debit.#{resource_name}")
+    end
+
+    def bank_account
+      ::Balanced::BankAccount.find(debit_resource_href)
+    end
+
+    def meta
+      PayableResourceSerializer.new(resource).to_json
+    end
+  end
+end

data/app/models/dune/balanced/bankaccount/payment_base.rb

@@ -0,0 +1,44 @@
+module Dune::Balanced::Bankaccount
+  class PaymentBase
+    attr_reader :engine_name, :resource, :attrs
+
+    def initialize(engine_name, customer, resource, attrs = {})
+      @engine_name  = engine_name
+      @customer     = customer
+      @resource     = resource
+      @attrs        = attrs
+    end
+
+    def amount_in_cents
+      (fee_calculator.gross_amount * 100).round
+    end
+
+    def fee_calculator
+      @fee_calculator and return @fee_calculator
+
+      calculator_class = if ActiveRecord::ConnectionAdapters::Column::TRUE_VALUES.include? attrs[:pay_fee]
+                           TransactionAdditionalFeeCalculator
+                         else
+                           TransactionInclusiveFeeCalculator
+                         end
+
+      @fee_calculator = calculator_class.new(resource.value)
+    end
+
+    def debit
+      @debit.try(:sanitize)
+    end
+
+    def status
+      @debit.try(:status).try(:to_sym) || @status
+    end
+
+    def checkout!
+      raise NotImplementedError
+    end
+
+    def successful?
+      raise NotImplementedError
+    end
+  end
+end

data/app/models/dune/balanced/bankaccount/payment_generator.rb

@@ -0,0 +1,38 @@
+module Dune::Balanced::Bankaccount
+  class PaymentGenerator
+    attr_reader :attrs, :resource, :customer
+
+    delegate :status, to: :payment
+
+    def initialize(customer, resource, attrs = {})
+      @customer      = customer
+      @resource      = resource
+      @attrs         = attrs
+    end
+
+    def complete
+      payment.checkout!
+    end
+
+    def payment
+      @payment ||= payment_class.new(
+        'balanced-bankaccount',
+        customer,
+        resource,
+        attrs
+      )
+    end
+
+    def payment_class
+      @payment_class ||= can_debit_resource? ? Dune::Balanced::Bankaccount::Payment : Dune::Balanced::Bankaccount::DelayedPayment
+    end
+
+    def can_debit_resource?
+      debit_resource.bank_account_verifications.to_a.first.try(:verification_status).eql? 'succeeded'
+    end
+
+    def debit_resource
+      @debit_resource ||= ::Balanced::BankAccount.find(@attrs.fetch(:use_bank))
+    end
+  end
+end

data/app/models/dune/balanced/bankaccount/routing_number.rb

@@ -0,0 +1,6 @@
+module Dune::Balanced::Bankaccount
+  class RoutingNumber < ActiveRecord::Base
+    self.table_name = :routing_numbers
+    validates :number, :bank_name, presence: true
+  end
+end

data/app/models/dune/balanced/bankaccount/transaction_additional_fee_calculator.rb

@@ -0,0 +1,12 @@
+require 'float_extensions'
+
+module Dune::Balanced::Bankaccount
+  class TransactionAdditionalFeeCalculator < TransactionFeeCalculatorBase
+    using FloatExtensions
+
+    def net_amount
+      transaction_value.to_f.floor_with_two_decimal_places
+    end
+  end
+end
+

data/app/models/dune/balanced/bankaccount/transaction_fee_calculator_base.rb

@@ -0,0 +1,34 @@
+require 'float_extensions'
+
+module Dune::Balanced::Bankaccount
+  class TransactionFeeCalculatorBase
+    using FloatExtensions
+
+    attr_writer :transaction_value
+
+    def initialize(transaction_value)
+      @transaction_value = transaction_value
+    end
+
+    def transaction_value
+      @transaction_value.to_f.floor_with_two_decimal_places
+    end
+
+    def gross_amount
+      net_amount + fees
+    end
+
+    def net_amount
+      raise NotImplementedError
+    end
+
+    # Base calculation of fees
+    # 1% + 30¢ ($5 cap)
+    def fees
+      [
+        (net_amount * 0.01 + 0.3).ceil_with_two_decimal_places,
+        5.0
+      ].min
+    end
+  end
+end

data/app/models/dune/balanced/bankaccount/transaction_inclusive_fee_calculator.rb

@@ -0,0 +1,16 @@
+require 'float_extensions'
+
+module Dune::Balanced::Bankaccount
+  class TransactionInclusiveFeeCalculator < TransactionFeeCalculatorBase
+    using FloatExtensions
+
+    # Base calculation of fees
+    # 1% + 30¢ ($5 cap)
+    def net_amount
+      [
+        ((transaction_value - 0.3) / 1.01).floor_with_two_decimal_places,
+        transaction_value - 5
+      ].max
+    end
+  end
+end

data/app/models/dune/balanced/bankaccount/verification.rb

@@ -0,0 +1,34 @@
+module Dune::Balanced::Bankaccount
+  class Verification
+    delegate :user, to: :contributor
+
+    def self.find(href)
+      new(::Balanced::BankAccountVerification.find(href))
+    end
+
+    def initialize(balanced_verification)
+      @source = balanced_verification
+    end
+
+    def bank_account_href
+      bank_account.href
+    end
+
+    def contributor
+      Dune::Balanced::Contributor.find_by(bank_account_href: bank_account_href)
+    end
+
+    def confirm
+      DebitAuthorizedContributionsWorker.perform_async(contributor.id)
+    end
+
+    # Delegate instance methods to Balanced::BankAccountVerification object
+    def method_missing(method, *args, &block)
+      if @source.respond_to? method
+        @source.public_send(method, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/app/models/dune/balanced/event_registered.rb

@@ -0,0 +1,13 @@
+module Dune::Balanced
+  class EventRegistered
+    def confirm(event)
+      case event.type
+      when 'bank_account_verification.deposited'
+        Notification.notify('balanced/bankaccount/confirm_bank_account', event.user)
+      when 'bank_account_verification.verified'
+        verification = Dune::Balanced::Bankaccount::Verification.find(event.entity_href)
+        verification.confirm
+      end
+    end
+  end
+end

data/app/views/dune/balanced/bankaccount/accounts/new.html.slim

@@ -0,0 +1,96 @@
+= initjs_tag app_name: 'Dune', partial: true
+
+.dune-balanced-bankaccount-form[data-balanced-bankaccount-form data-routing-number-path=routing_number_path(:id)]
+  = simple_form_for :payment, url: accounts_path do |f|
+    = f.input :use_bank, as: :hidden
+    .row
+      .large-12.columns.title
+        h3
+          .row
+            .large-4.columns
+              = t('.bankaccount.title')
+            .large-8.columns.text-right
+              small
+                - if @bank_account.present?
+                  = t('.status')
+                  |  
+                  - if @bank_account.bank_account_verifications.to_a.first.try(:verification_status) == 'succeeded'
+                    span.label = t('.account_verified')
+                  - else
+                    span.label.alert = t('.account_unverified')
+                    |  
+                    = link_to t('.verify'), new_confirmation_path
+        - if @bank_account
+          p = t('.bankaccount.subtitle')
+
+    .row
+      .large-8.columns
+        - if @bank_account
+          section.use-existing-item.row
+            .large-12.columns
+              .bank-box
+                label.row
+                  dl
+                    .large-1.columns
+                      = f.radio_button :show_bank, 'existing', { class: 'show-bank', checked: false, label: false }
+                    .large-5.columns
+                      dt.hide
+                      dd = @bank_account.account_number
+                    .large-6.columns.bank_name
+                      dt.hine
+                      dd = @bank_account.bank_name
+                .expandable.hide
+                  = f.simple_fields_for :current do |fc|
+                    .row
+                      .large-8.columns
+                        = fc.input :account_holder_name, input_html: { value: @bank_account.try(:name) }
+
+                      .large-4.columns
+                        = fc.input :account_type, as: :radio_buttons, collection: [['Checking', 'checking'], ['Savings', 'savings']], checked: (@bank_account.try(:account_type) || 'checking')
+
+                    .row
+                      .large-3.columns
+                        = fc.input :routing_number, input_html: { value: @bank_account.try(:routing_number) }
+
+                      .large-4.columns
+                        = fc.input :account_number, input_html: { value: @bank_account.try(:account_number) }
+
+                      .large-5.columns
+                        = fc.input :bank_name, disabled: true, input_html: { value: @bank_account.try(:bank_name) }
+
+        section.row
+          .large-12.columns
+            .bank-box[class="#{'new-bank' unless @bank_account.present?}"]
+               .row
+                 - if @bank_account.present?
+                   label
+                      .large-1.columns
+                        = f.radio_button :show_bank, 'new', { class: 'show-bank', checked: false, label: false }
+                      .large-8.columns
+                        = t('.replace_bank')
+                      .large-3.columns.bank_name
+
+                 .add-new-bankaccount-form.expandable[class="#{'hide with-other-bank' if @bank_account.present?}"]
+                    .large-12.columns.check-numbers
+                      = image_tag('payments/check-numbers.png')
+                    .large-12.columns
+                      .row
+                        .large-8.columns
+                          = f.input :account_holder_name, required: true, input_html: { 'data-balanced-bank-account-input' => '' }
+
+                        .large-4.columns
+                          = f.input :account_type, as: :radio_buttons, checked: 'checking', required: true, collection: [['Checking', 'checking'], ['Savings', 'savings']]
+
+                      .row
+                        .large-3.columns
+                          = f.input :routing_number, required: true, input_html: { 'data-balanced-bank-account-input' => '' }
+
+                        .large-4.columns
+                          = f.input :account_number, required: true, input_html: { 'data-balanced-bank-account-input' => '' }
+
+                        .large-5.columns
+                          = f.input :bank_name, disabled: true, input_html: { 'data-balanced-bank-account-input' => '' }
+
+                        .large-12.columns.submit
+                          = f.button :submit, (@bank_account.present? ? t('.replace') : t('.add')), data: { disable_with: t('.proccessing'), enable_with: (@bank_account.present? ? t('.replace') : t('.add')) }
+