catarse_pagarme 0.0.1

data/app/assets/stylesheets/catarse_pagarme/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/catarse_pagarme/application_controller.rb

@@ -0,0 +1,51 @@
+require "pagarme"
+
+module CatarsePagarme
+  class ApplicationController < ActionController::Base
+
+    before_filter :authenticate_user!
+    before_action :configure_pagarme
+    skip_before_filter :force_http
+    layout :false
+
+    protected
+    def configure_pagarme
+      PagarMe.api_key = CatarsePagarme.configuration.api_key
+    end
+
+    def authenticate_user!
+      unless defined?(current_user) && current_user
+        raise Exception.new('invalid user')
+      end
+    end
+
+    def permited_attrs(attributes)
+      attrs = ActionController::Parameters.new(attributes)
+      attrs.permit([
+        slip_payment: [:payment_method, :amount, :postback_url,
+                       customer: [:name, :email]
+        ],
+        user: [
+          bank_account_attributes: [
+            :name, :account, :account_digit, :agency,
+            :agency_digit, :owner_name, :owner_document
+          ]
+        ]
+      ])
+    end
+
+    def contribution
+      conditions = {id: params[:id] }
+
+      unless params[:controller] == 'catarse_pagarme/notifications'
+        conditions.merge!({user_id: current_user.id})
+      end
+
+      @contribution ||= PaymentEngines.find_payment(conditions)
+    end
+
+    def delegator
+      contribution.pagarme_delegator
+    end
+  end
+end

data/app/controllers/catarse_pagarme/credit_card_base_controller.rb

@@ -0,0 +1,48 @@
+module CatarsePagarme
+  class CreditCardBaseController < ApplicationController
+
+    protected
+
+    def charge_with_class(kclass)
+      transaction = kclass.new(credit_card_attributes, contribution).charge!
+
+      render json: { payment_status: transaction.status }
+    rescue Exception => e
+      render json: { payment_status: 'failed', message: e.message }
+    end
+
+    def splited_month_and_year
+      params[:payment_card_date].split('/')
+    rescue
+      [0, 0]
+    end
+
+    def get_installment
+      if contribution.value < CatarsePagarme.configuration.minimum_value_for_installment
+        1
+      elsif params[:payment_card_installments].to_i > 0
+        params[:payment_card_installments].to_i
+      else
+        1
+      end
+    end
+
+    def credit_card_attributes
+      {
+        payment_method: 'credit_card',
+        card_number: params[:payment_card_number],
+        card_holder_name: params[:payment_card_name],
+        card_expiration_month: splited_month_and_year[0],
+        card_expiration_year: splited_month_and_year[1],
+        card_cvv: params[:payment_card_source],
+        amount: delegator.value_with_installment_tax(get_installment),
+        postback_url: ipn_pagarme_url(contribution),
+        installments: get_installment,
+        customer: {
+          email: contribution.user.email,
+          name: contribution.user.name
+        }
+      }
+    end
+  end
+end

data/app/controllers/catarse_pagarme/credit_cards_controller.rb

@@ -0,0 +1,8 @@
+module CatarsePagarme
+  class CreditCardsController < CreditCardBaseController
+
+    def create
+      charge_with_class CreditCardTransaction
+    end
+  end
+end

data/app/controllers/catarse_pagarme/notifications_controller.rb

@@ -0,0 +1,20 @@
+module CatarsePagarme
+  class NotificationsController < ApplicationController
+    skip_before_filter :authenticate_user!
+
+    def create
+      if PagarMe::validate_fingerprint(contribution.try(:payment_id), params[:fingerprint])
+        if contribution
+          contribution.payment_notifications.create(extra_data: params.to_json)
+          delegator.change_status_by_transaction(params[:current_status])
+
+          return render nothing: true, status: 200
+        end
+
+        return render nothing: true, status: 404
+      end
+
+      render nothing: true, status: 404
+    end
+  end
+end

data/app/controllers/catarse_pagarme/pagarme_controller.rb

@@ -0,0 +1,10 @@
+module CatarsePagarme
+  class PagarmeController < CatarsePagarme::ApplicationController
+
+    def review
+      contribution
+      current_user.build_bank_account unless current_user.bank_account
+    end
+
+  end
+end

data/app/controllers/catarse_pagarme/slip_controller.rb

@@ -0,0 +1,43 @@
+module CatarsePagarme
+  class SlipController < CatarsePagarme::ApplicationController
+
+    def create
+      transaction = SlipTransaction.new(permitted_attributes, contribution).charge!
+
+      render json: { boleto_url: transaction.boleto_url, payment_status: transaction.status }
+    rescue PagarMe::PagarMeError => e
+      render json: { boleto_url: nil, payment_status: 'failed', message: e.message }
+    end
+
+    def update
+      transaction = SlipTransaction.new(permitted_attributes, contribution).charge!
+      render text: transaction.boleto_url
+    end
+
+    protected
+
+    def slip_attributes
+      {
+        payment_method: 'boleto',
+        amount: delegator.value_for_transaction,
+        postback_url: ipn_pagarme_url(contribution),
+        customer: {
+          email: contribution.user.email,
+          name: contribution.user.name
+        }
+      }.update({ user: params[:user] })
+    end
+
+    def permitted_attributes
+      attrs = ActionController::Parameters.new(slip_attributes)
+      attrs.permit(:payment_method, :amount, :postback_url, customer: [:name, :email],
+        user: [
+          bank_account_attributes: [
+            :name, :account, :account_digit, :agency,
+            :agency_digit, :owner_name, :owner_document
+          ]
+        ])
+    end
+
+  end
+end

data/app/controllers/catarse_pagarme/subscriptions_controller.rb

@@ -0,0 +1,27 @@
+module CatarsePagarme
+  class SubscriptionsController < CreditCardBaseController
+    def create
+      charge_with_class SaveCreditCardTransaction
+    end
+
+    def update
+      charge_with_class SubscriptionTransaction
+    end
+
+    protected
+
+    def credit_card_attributes
+      attributes = super
+
+      if has_subscription?
+        attributes.update({subscription_id: params[:subscription_id]})
+      end
+
+      attributes
+    end
+
+    def has_subscription?
+      params[:subscription_id].present?
+    end
+  end
+end

data/app/helpers/catarse_pagarme/application_helper.rb

@@ -0,0 +1,23 @@
+module CatarsePagarme
+  module ApplicationHelper
+
+    def installments_for_select(contribution)
+      installments = contribution.pagarme_delegator.get_installments['installments']
+
+      collection = installments.map do |installment|
+        installment_number = installment[0].to_i
+        if installment_number <= CatarsePagarme.configuration.max_installments
+          amount = installment[1]['installment_amount'] / 100.0
+          [format_instalment_text(installment_number, amount), installment_number]
+        end
+      end
+
+      collection.compact
+    end
+
+    def format_instalment_text(number, amount)
+      [number, number_to_currency(amount, precision: 2)].join('x ')
+    end
+
+  end
+end

data/app/models/catarse_pagarme/contribution_concern.rb

@@ -0,0 +1,9 @@
+module CatarsePagarme::ContributionConcern
+  extend ActiveSupport::Concern
+
+  included do
+    def pagarme_delegator
+      CatarsePagarme::ContributionDelegator.new(self)
+    end
+  end
+end

data/app/models/catarse_pagarme/contribution_delegator.rb

@@ -0,0 +1,94 @@
+module CatarsePagarme
+  class ContributionDelegator
+    attr_accessor :contribution, :transaction
+
+    def initialize(contribution)
+      configure_pagarme
+      self.contribution = contribution
+    end
+
+    def change_status_by_transaction(transactin_status)
+      case transactin_status
+      when 'paid', 'authorized' then
+        self.contribution.confirm unless self.contribution.confirmed?
+      when 'refunded' then
+        self.contribution.refund unless self.contribution.refunded?
+      when 'refused' then
+        self.contribution.cancel unless self.contribution.canceled?
+      when 'waiting_payment', 'processing' then
+        self.contribution.waiting unless self.contribution.waiting_confirmation?
+      end
+    end
+
+    def refund
+      if contribution.is_credit_card?
+        transaction.refund
+      else
+        transaction.refund(bank_account_attributes)
+      end
+    end
+
+    def value_for_transaction
+      (self.contribution.value * 100).to_i
+    end
+
+    def value_with_installment_tax(installment)
+      current_installment = get_installment(installment)
+
+      if current_installment.present?
+        current_installment['amount']
+      else
+        value_for_transaction
+      end
+    end
+
+    def transaction
+      @transaction ||= ::PagarMe::Transaction.find_by_id(self.contribution.payment_id)
+    end
+
+    def get_installment(installment_number)
+      installment = get_installments['installments'].select do |installment|
+        !installment[installment_number.to_s].nil?
+      end
+
+      installment[installment_number.to_s]
+    end
+
+    def get_installments
+      @installments ||= PagarMe::Transaction.calculate_installments({
+        amount: self.value_for_transaction,
+        interest_rate: CatarsePagarme.configuration.interest_rate
+      })
+    end
+
+    def get_fee(payment_method)
+      if payment_method == PaymentType::SLIP
+        CatarsePagarme.configuration.slip_tax
+      else
+        (self.contribution.value * CatarsePagarme.configuration.credit_card_tax.to_f) + CatarsePagarme.configuration.credit_card_cents_fee
+      end
+    end
+
+    protected
+
+    def bank_account_attributes
+      bank = contribution.user.bank_account
+
+      {
+        bank_account: {
+          bank_code: (bank.bank_code || bank.name),
+          agencia: bank.agency,
+          agencia_dv: bank.agency_digit,
+          conta: bank.account,
+          conta_dv: bank.account_digit,
+          legal_name: bank.owner_name,
+          document_number: bank.owner_document
+        }
+      }
+    end
+
+    def configure_pagarme
+      ::PagarMe.api_key = CatarsePagarme.configuration.api_key
+    end
+  end
+end

data/app/models/catarse_pagarme/credit_card_concern.rb

@@ -0,0 +1,9 @@
+module CatarsePagarme::CreditCardConcern
+  extend ActiveSupport::Concern
+
+  included do
+    def pagarme_delegator
+      CatarsePagarme::CreditCardDelegator.new(self)
+    end
+  end
+end

data/app/models/catarse_pagarme/credit_card_delegator.rb

@@ -0,0 +1,26 @@
+module CatarsePagarme
+  class CreditCardDelegator
+    attr_accessor :credit_card, :subscription
+
+    def initialize(credit_card)
+      configure_pagarme
+      self.credit_card = credit_card
+    end
+
+    def cancel_subscription
+      get_subscription
+      self.subscription.cancel
+    end
+
+    def get_subscription
+      self.subscription ||= ::PagarMe::Subscription.find_by_id(self.credit_card.subscription_id)
+    end
+
+
+    protected
+
+    def configure_pagarme
+      ::PagarMe.api_key = CatarsePagarme.configuration.api_key
+    end
+  end
+end

data/app/models/catarse_pagarme/credit_card_transaction.rb

@@ -0,0 +1,11 @@
+module CatarsePagarme
+  class CreditCardTransaction < TransactionBase
+    def charge!
+      self.transaction = PagarMe::Transaction.new(self.attributes)
+      self.transaction.charge
+
+      change_contribution_state
+      self.transaction
+    end
+  end
+end

data/app/models/catarse_pagarme/payment_type.rb

@@ -0,0 +1,6 @@
+module CatarsePagarme
+  class PaymentType
+    SLIP = 'BoletoBancario'
+    CREDIT_CARD = 'CartaoDeCredito'
+  end
+end

data/app/models/catarse_pagarme/save_credit_card_transaction.rb

@@ -0,0 +1,33 @@
+module CatarsePagarme
+  class SaveCreditCardTransaction < TransactionBase
+    def charge!
+      installments = self.attributes.delete(:installments)
+      amount = self.attributes.delete(:amount)
+
+      self.subscription = PagarMe::Subscription.new(self.attributes)
+      self.subscription.create
+
+      self.subscription.charge(amount, installments)
+      self.transaction = subscription.current_transaction
+
+      save_user_credit_card
+      change_contribution_state
+
+
+      self.transaction
+    end
+
+    protected
+
+    def save_user_credit_card
+      credit_cards = self.user.credit_cards
+      unless credit_cards.where(subscription_id: self.subscription.id.to_s).present?
+        credit_cards.create!({
+          last_digits: self.subscription.card_last_digits,
+          card_brand: self.subscription.card_brand,
+          subscription_id: self.subscription.id
+        })
+      end
+    end
+  end
+end