catarse_pagarme 2.5.1 → 2.6.0

data/app/models/catarse_pagarme/payment_concern.rb

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

data/app/models/catarse_pagarme/{contribution_delegator.rb → payment_delegator.rb}

@@ -1,45 +1,45 @@
 module CatarsePagarme
-  class ContributionDelegator
-    attr_accessor :contribution, :transaction
+  class PaymentDelegator
+    attr_accessor :payment, :transaction
     include FeeCalculatorConcern
 
-    def initialize(contribution)
+    def initialize(payment)
       configure_pagarme
-      self.contribution = contribution
+      self.payment = payment
     end
 
     def change_status_by_transaction(transactin_status)
       case transactin_status
       when 'paid', 'authorized' then
-        self.contribution.confirm unless self.contribution.confirmed?
+        self.payment.pay unless self.payment.paid?
       when 'refunded' then
-        self.contribution.refund unless self.contribution.refunded?
+        self.payment.refund unless self.payment.refunded?
       when 'refused' then
-        self.contribution.cancel unless self.contribution.canceled?
-      when 'waiting_payment', 'processing' then
-        self.contribution.waiting unless self.contribution.waiting_confirmation?
+        self.payment.refuse unless self.payment.refused?
       end
     end
 
     def update_fee
       fill_acquirer_data
-      contribution.update_attributes({
-        payment_service_fee: get_fee,
+      payment.update_attributes({
+        gateway_fee: get_fee,
       })
     end
 
     def fill_acquirer_data
-      if !contribution.acquirer_name.present? || !contribution.acquirer_tid.present?
-        contribution.update_attributes({
+      if payment.gateway_data.nil? || payment.gateway_data["acquirer_name"].nil? || payment.gateway_data["acquirer_tid"].nil?
+        data = payment.gateway_data || {}
+        payment.gateway_data = data.merge({
           acquirer_name: transaction.acquirer_name,
           acquirer_tid: transaction.tid,
           card_brand: transaction.try(:card_brand)
         })
+        payment.save
       end
     end
 
     def refund
-      if contribution.is_credit_card?
+      if payment.is_credit_card?
         transaction.refund
       else
         transaction.refund(bank_account_attributes)
@@ -47,7 +47,7 @@ module CatarsePagarme
     end
 
     def value_for_transaction
-      (self.contribution.value * 100).to_i
+      (self.payment.value * 100).to_i
     end
 
     def value_with_installment_tax(installment)
@@ -65,7 +65,7 @@ module CatarsePagarme
     end
 
     def transaction
-      @transaction ||= ::PagarMe::Transaction.find_by_id(self.contribution.payment_id)
+      @transaction ||= ::PagarMe::Transaction.find_by_id(self.payment.gateway_id)
     end
 
     def get_installment(installment_number)
@@ -86,7 +86,7 @@ module CatarsePagarme
     protected
 
     def bank_account_attributes
-      bank = contribution.user.bank_account
+      bank = payment.user.bank_account
 
       {
         bank_account: {

data/app/models/catarse_pagarme/slip_transaction.rb

@@ -1,6 +1,6 @@
 module CatarsePagarme
   class SlipTransaction < TransactionBase
-    def initialize(attributes, contribution)
+    def initialize(attributes, payment)
       super
       build_default_bank_account
     end
@@ -9,9 +9,10 @@ module CatarsePagarme
       update_user_bank_account
 
       self.transaction = PagarMe::Transaction.new(self.attributes)
+
       self.transaction.charge
 
-      change_contribution_state
+      change_payment_state
 
       self.transaction
     end

data/app/models/catarse_pagarme/transaction_base.rb

@@ -1,18 +1,19 @@
 module CatarsePagarme
   class TransactionBase
-    attr_accessor :attributes, :contribution,
+    attr_accessor :attributes, :payment,
       :transaction, :user
 
-    def initialize(attributes, contribution)
+    def initialize(attributes, payment)
       self.attributes = attributes
-      self.contribution = contribution
-      self.user = contribution.user
+      self.payment = payment
+      self.user = payment.user
     end
 
-    def change_contribution_state
-      self.contribution.update_attributes(attributes_to_contribution)
+    def change_payment_state
+      self.payment.update_attributes(attributes_to_payment)
+      self.payment.save!
       delegator.update_fee
-      self.contribution.payment_notifications.create(extra_data: self.transaction.to_json)
+      self.payment.payment_notifications.create(contribution_id: self.payment.contribution_id, extra_data: self.transaction.to_json)
       delegator.change_status_by_transaction(self.transaction.status)
     end
 
@@ -20,19 +21,19 @@ module CatarsePagarme
       PaymentType::CREDIT_CARD
     end
 
-    def attributes_to_contribution
+    def attributes_to_payment
       {
-        payment_choice: payment_method,
-        payment_id: self.transaction.id,
-        payment_method: 'Pagarme',
-        slip_url: self.transaction.boleto_url,
+        payment_method: payment_method,
+        gateway_id: self.transaction.id,
+        gateway: 'Pagarme',
+        gateway_data: self.transaction.to_json,
         installments: (self.transaction.installments || 1),
         installment_value: (delegator.value_for_installment(self.transaction.installments || 0) / 100.0).to_f
       }
     end
 
     def delegator
-      self.contribution.pagarme_delegator
+      self.payment.pagarme_delegator
     end
 
   end

data/lib/catarse_pagarme/engine.rb

@@ -3,7 +3,7 @@ module CatarsePagarme
     isolate_namespace CatarsePagarme
 
     config.to_prepare do
-      ::Contribution.send(:include, CatarsePagarme::ContributionConcern)
+      ::Payment.send(:include, CatarsePagarme::PaymentConcern)
     end
   end
 end

data/lib/catarse_pagarme/version.rb

@@ -1,3 +1,3 @@
 module CatarsePagarme
-  VERSION = "2.5.1"
+  VERSION = "2.6.0"
 end

data/spec/controllers/catarse_pagarme/credit_cards_controller_spec.rb

@@ -2,12 +2,12 @@ require 'spec_helper'
 
 describe CatarsePagarme::CreditCardsController do
   before do
-    PaymentEngines.stub(:find_payment).and_return(contribution)
     controller.stub(:current_user).and_return(user)
   end
 
   let(:project) { create(:project, goal: 10_000, state: 'online') }
   let(:contribution) { create(:contribution, value: 10, project: project) }
+  let(:payment) { contribution.payments.first }
 
   describe 'pay with credit card' do
     context  'without an user' do
@@ -15,17 +15,17 @@ describe CatarsePagarme::CreditCardsController do
 
       it 'should raise a error' do
         expect {
-          post :create, { locale: :pt, project_id: project.id, contribution_id: contribution.id, use_route: 'catarse_pagarme' }
+          post :create, { locale: :pt, id: contribution.id, use_route: 'catarse_pagarme' }
         }.to raise_error('invalid user')
       end
     end
 
     context 'with an user' do
-      let(:user) { contribution.user }
+      let(:user) { payment.user }
       context "with valid card data" do
         before do
           post :create, {
-            locale: :pt, project_id: project.id, contribution_id: contribution.id, use_route: 'catarse_pagarme',
+            locale: :pt, id: contribution.id, use_route: 'catarse_pagarme',
             card_hash: sample_card_hash }
         end
 
@@ -37,7 +37,7 @@ describe CatarsePagarme::CreditCardsController do
       context 'with invalid card data' do
         before do
           post :create, {
-            locale: :pt, project_id: project.id, contribution_id: contribution.id, use_route: 'catarse_pagarme', card_hash: "abcd" }
+            locale: :pt, id: contribution.id, use_route: 'catarse_pagarme', card_hash: "abcd" }
         end
 
         it 'payment_status should be failed' do

data/spec/controllers/catarse_pagarme/notifications_controller_spec.rb

@@ -14,29 +14,34 @@ describe CatarsePagarme::NotificationsController do
   end
 
   let(:project) { create(:project, goal: 10_000, state: 'online') }
-  let(:contribution) { create(:contribution, value: 10, project: project, payment_id: 'abcd') }
+  let(:contribution) { create(:contribution, value: 10, project: project) }
+  let(:payment) { 
+    p = contribution.payments.first 
+    p.update_attributes gateway_id: 'abcd'
+    p
+  }
   let(:credit_card) { create(:credit_card, subscription_id: '1542')}
 
   describe 'CREATE' do
-    context "with invalid contribution" do
+    context "with invalid payment" do
       before do
         PaymentEngines.stub(:find_payment).and_return(nil)
         post :create, { locale: :pt, id: 'abcdfg', use_route: 'catarse_pagarme' }
       end
 
-      it "should not found the contribution" do
+      it "should not found the payment" do
         expect(response.code.to_i).to eq(404)
       end
     end
 
-    context "with valid contribution" do
+    context "with valid payment" do
       before do
-        PaymentEngines.stub(:find_payment).and_return(contribution)
+        PaymentEngines.stub(:find_payment).and_return(payment)
         post :create, { locale: :pt, id: 'abcd', use_route: 'catarse_pagarme' }
       end
 
       it "should save an extra_data into payment_notifications" do
-        expect(contribution.payment_notifications.size).to eq(1)
+        expect(payment.payment_notifications.size).to eq(1)
       end
 
       it "should return 200 status" do

data/spec/controllers/catarse_pagarme/slip_controller_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe CatarsePagarme::SlipController do
   before do
-    PaymentEngines.stub(:find_payment).and_return(contribution)
     controller.stub(:current_user).and_return(user)
     Bank.create(name: 'foo', code: '123')
   end
 
   let(:project) { create(:project, goal: 10_000, state: 'online') }
   let(:contribution) { create(:contribution, value: 10, project: project) }
+  let(:payment) { contribution.payments.first }
   let(:credit_card) { create(:credit_card, subscription_id: '1542')}
 
   describe 'pay with slip' do
@@ -17,18 +17,18 @@ describe CatarsePagarme::SlipController do
 
       it 'should raise a error' do
         expect {
-          post :create, { locale: :pt, project_id: project.id, contribution_id: contribution.id, use_route: 'catarse_pagarme' }
+          post :create, { locale: :pt, id: contribution.id, use_route: 'catarse_pagarme' }
         }.to raise_error('invalid user')
       end
     end
 
     context 'with an user' do
-      let(:user) { contribution.user }
+      let(:user) { payment.user }
 
       context 'with valid bank account data' do
         before do
           post :create, {
-            locale: :pt, project_id: project.id, contribution_id: contribution.id, use_route: 'catarse_pagarme',
+            locale: :pt, id: contribution.id, use_route: 'catarse_pagarme',
             user: { bank_account_attributes: {
               bank_id: Bank.first.id, agency: '1', agency_digit: '1', account: '1', account_digit: '1', owner_name: 'foo', owner_document: '1'
             } } }
@@ -44,10 +44,10 @@ describe CatarsePagarme::SlipController do
       end
 
       context 'with invalid bank account data' do
-        let(:user) { contribution.user }
+        let(:user) { payment.user }
 
         before do
-          post :create, { locale: :pt, project_id: project.id, contribution_id: contribution.id, use_route: 'catarse_pagarme', user: { bank_account_attributes: { owner_name: '' } } }
+          post :create, { locale: :pt, id: contribution.id, use_route: 'catarse_pagarme', user: { bank_account_attributes: { owner_name: '' } } }
         end
 
         it 'boleto_url should be nil' do

data/spec/dummy/app/models/contribution.rb

@@ -2,28 +2,5 @@ class Contribution < ActiveRecord::Base
   belongs_to :user
   belongs_to :project
   has_many :payment_notifications
-
-  def confirmed?
-    false
-  end
-
-  def update_current_billing_info
-  end
-
-  def confirm!
-    true
-  end
-  alias :confirm :confirm!
-
-  def waiting_confirmation?
-  end
-
-  def waiting
-  end
-
-  def cancel
-  end
-
-  def canceled?
-  end
+  has_many :payments
 end

data/spec/dummy/app/models/payment.rb

@@ -0,0 +1,55 @@
+class Payment < ActiveRecord::Base
+  has_many :payment_notifications
+  belongs_to :contribution
+  delegate :user, :project, to: :contribution
+
+  validates_presence_of :state, :key, :gateway, :payment_method, :value, :installments, :installment_value
+  validate :value_should_be_equal_or_greater_than_pledge
+
+  before_validation do
+    self.key ||= SecureRandom.uuid
+    self.value ||= self.contribution.try(:value)
+    self.state = 'pending' # mock initial state for here we do not include the stat machine
+  end
+
+  def value_should_be_equal_or_greater_than_pledge
+    errors.add(:value, I18n.t("activerecord.errors.models.payment.attributes.value.invalid")) if self.contribution && self.value < self.contribution.value
+  end
+
+  def notification_template_for_failed_project
+    if slip_payment?
+      :contribution_project_unsuccessful_slip
+    else
+      :contribution_project_unsuccessful_credit_card
+    end
+  end
+
+  def refunded?
+    true
+  end
+
+  def paid?
+    true
+  end
+
+  def refused?
+    true
+  end
+
+  def refuse
+  end
+
+  def pay
+  end
+
+  def refund
+  end
+
+  def credits?
+    self.gateway == 'Credits'
+  end
+
+  def slip_payment?
+    self.payment_method == 'BoletoBancario'
+  end
+end

data/spec/dummy/app/models/payment_engines.rb

@@ -1,2 +1,9 @@
 class PaymentEngines
+  def self.new_payment(attributes={})
+    Payment.new attributes
+  end
+
+  def self.find_contribution(id)
+    Contribution.find id
+  end
 end

data/spec/helpers/catarse_pagarme/application_helper_spec.rb

@@ -7,10 +7,10 @@ describe CatarsePagarme::ApplicationHelper do
     CatarsePagarme.configuration.stub(:max_installments).and_return(6)
   end
 
-  let(:contribution) { create(:contribution, value: 100) }
+  let(:payment) { create(:payment, value: 100) }
 
   context "#installments_for_select" do
-    subject { installments_for_select(contribution) }
+    subject { installments_for_select(payment) }
     it { expect(subject.size).to eq(6) }
     it { expect(subject[0][0]).to eq('1x $100.00 ') }
     it { expect(subject[0][1]).to eq(1) }

data/spec/models/catarse_pagarme/credit_card_transaction_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe CatarsePagarme::CreditCardTransaction do
-  let(:contribution) { create(:contribution, value: 100) }
+  let(:payment) { create(:payment, value: 100) }
 
   let(:pagarme_transaction) {
     double({
@@ -24,61 +24,61 @@ describe CatarsePagarme::CreditCardTransaction do
         card_expiration_month: '10',
         card_expiration_year: '19',
         card_cvv: '434',
-        amount: contribution.pagarme_delegator.value_for_transaction,
+        amount: payment.pagarme_delegator.value_for_transaction,
         postback_url: 'http://test.foo',
         installments: 1
       }
   end
 
-  let(:card_transaction) { CatarsePagarme::CreditCardTransaction.new(valid_attributes, contribution) }
+  let(:card_transaction) { CatarsePagarme::CreditCardTransaction.new(valid_attributes, payment) }
 
   before do
     PagarMe::Transaction.stub(:new).and_return(pagarme_transaction)
-    CatarsePagarme::ContributionDelegator.any_instance.stub(:change_status_by_transaction).and_return(true)
+    CatarsePagarme::PaymentDelegator.any_instance.stub(:change_status_by_transaction).and_return(true)
     CatarsePagarme.configuration.stub(:credit_card_tax).and_return(0.01)
   end
 
   describe '#charge!' do
     describe 'with valid attributes' do
       before do
-        contribution.should_receive(:update_attributes).at_least(1).and_call_original
+        payment.should_receive(:update_attributes).at_least(1).and_call_original
         PagarMe::Transaction.should_receive(:find_by_id).with(pagarme_transaction.id).and_return(pagarme_transaction)
-        CatarsePagarme::ContributionDelegator.any_instance.should_receive(:change_status_by_transaction).with('paid')
+        CatarsePagarme::PaymentDelegator.any_instance.should_receive(:change_status_by_transaction).with('paid')
 
         card_transaction.charge!
-        contribution.reload
+        payment.reload
       end
 
-      it "should update contribution payment_id" do
-        expect(contribution.payment_id).to eq('abcd')
+      it "should update payment payment_id" do
+        expect(payment.gateway_id).to eq('abcd')
       end
 
-      it "should update contribution payment_service_fee" do
-        expect(contribution.payment_service_fee.to_f).to eq(4.08)
+      it "should update payment payment_service_fee" do
+        expect(payment.gateway_fee.to_f).to eq(4.08)
       end
 
-      it "should update contribution payment_method" do
-        expect(contribution.payment_method).to eq('Pagarme')
+      it "should update payment payment_method" do
+        expect(payment.gateway).to eq('Pagarme')
       end
 
-      it "should update contribution installments" do
-        expect(contribution.installments).to eq(3)
+      it "should update payment installments" do
+        expect(payment.installments).to eq(3)
       end
 
-      it "should update contribution payment_choice" do
-        expect(contribution.payment_choice).to eq(CatarsePagarme::PaymentType::CREDIT_CARD)
+      it "should update payment payment_choice" do
+        expect(payment.payment_method).to eq(CatarsePagarme::PaymentType::CREDIT_CARD)
       end
 
-      it "should update contribution acquirer_name" do
-        expect(contribution.acquirer_name).to eq('stone')
+      it "should update payment acquirer_name" do
+        expect(payment.gateway_data["acquirer_name"]).to eq('stone')
       end
 
-      it "should update contribution acquirer_tid" do
-        expect(contribution.acquirer_tid).to eq('123123')
+      it "should update payment acquirer_tid" do
+        expect(payment.gateway_data["acquirer_tid"]).to eq('123123')
       end
 
-      it "should update contribution installment_value" do
-        expect(contribution.installment_value).to_not be_nil
+      it "should update payment installment_value" do
+        expect(payment.installment_value).to_not be_nil
       end
     end
   end