catarse_paypal_express 0.1.0 → 1.0.0

data/app/controllers/catarse_paypal_express/payment/paypal_express_controller.rb

@@ -1,119 +0,0 @@
-require 'catarse_paypal_express/processors'
-
-module CatarsePaypalExpress::Payment
-  class PaypalExpressController < ApplicationController
-    skip_before_filter :verify_authenticity_token, :only => [:notifications]
-    skip_before_filter :detect_locale, :only => [:notifications]
-    skip_before_filter :set_locale, :only => [:notifications]
-
-    before_filter :setup_gateway
-
-    SCOPE = "projects.backers.checkout"
-
-
-    def notifications
-      backer = Backer.find params[:id]
-      response = @@gateway.details_for(backer.payment_token)
-      if response.params['transaction_id'] == params['txn_id']
-        build_notification(backer, response.params)
-        render status: 200, nothing: true
-      else
-        render status: 404, nothing: true
-      end
-    rescue
-      render status: 404, nothing: true
-    end
-
-    def pay
-      backer = current_user.backs.find params[:id]
-      begin
-        response = @@gateway.setup_purchase(backer.price_in_cents, {
-          ip: request.remote_ip,
-          return_url: payment_success_paypal_express_url(id: backer.id),
-          cancel_return_url: payment_cancel_paypal_express_url(id: backer.id),
-          currency_code: 'BRL',
-          description: t('paypal_description', scope: SCOPE, :project_name => backer.project.name, :value => backer.display_value),
-          notify_url: payment_notifications_paypal_express_url(id: backer.id)
-        })
-
-        backer.update_attribute :payment_method, 'PayPal'
-        backer.update_attribute :payment_token, response.token
-
-        build_notification(backer, response.params)
-
-        if response.params['correlation_id']
-          backer.update_attribute :payment_id, response.params['correlation_id']
-        end
-
-        redirect_to @@gateway.redirect_url_for(response.token)
-      rescue Exception => e
-        Airbrake.notify({ :error_class => "Paypal Error", :error_message => "Paypal Error: #{e.inspect}", :parameters => params}) rescue nil
-        Rails.logger.info "-----> #{e.inspect}"
-        paypal_flash_error
-        return redirect_to main_app.new_project_backer_path(backer.project)
-      end
-    end
-
-    def success
-      backer = current_user.backs.find params[:id]
-      begin
-        details = @@gateway.details_for(backer.payment_token)
-        response = @@gateway.purchase(backer.price_in_cents, {
-          ip: request.remote_ip,
-          token: backer.payment_token,
-          payer_id: details.payer_id
-        })
-
-        build_notification(backer, details.params)
-
-        if details.params['transaction_id'] 
-          backer.update_attribute :payment_id, details.params['transaction_id']
-        end
-
-        session[:thank_you_id] = backer.project.id
-        session[:_payment_token] = backer.payment_token
-
-        paypal_flash_success
-        redirect_to main_app.thank_you_path
-      rescue Exception => e
-        Airbrake.notify({ :error_class => "Paypal Error", :error_message => "Paypal Error: #{e.message}", :parameters => params}) rescue nil
-        Rails.logger.info "-----> #{e.inspect}"
-        paypal_flash_error
-        return redirect_to main_app.new_project_backer_path(backer.project)
-      end
-    end
-
-    def cancel
-      backer = current_user.backs.find params[:id]
-      flash[:failure] = t('paypal_cancel', scope: SCOPE)
-      redirect_to main_app.new_project_backer_path(backer.project)
-    end
-
-  private
-
-    def build_notification(backer, data)
-      processor = CatarsePaypalExpress::Processors::Paypal.new
-      processor.process!(backer, data)
-    end
-
-    def paypal_flash_error
-      flash[:failure] = t('paypal_error', scope: SCOPE)
-    end
-
-    def paypal_flash_success
-      flash[:success] = t('success', scope: SCOPE)
-    end
-
-    def setup_gateway
-      if ::Configuration[:paypal_username] and ::Configuration[:paypal_password] and ::Configuration[:paypal_signature]
-        @@gateway ||= ActiveMerchant::Billing::PaypalExpressGateway.new({
-          :login => ::Configuration[:paypal_username],
-          :password => ::Configuration[:paypal_password],
-          :signature => ::Configuration[:paypal_signature]
-        })
-      else
-        puts "[PayPal] An API Certificate or API Signature is required to make requests to PayPal"
-      end
-    end
-  end
-end

data/lib/catarse_paypal_express/processors.rb

@@ -1,5 +0,0 @@
-require 'catarse_paypal_express/processors/paypal'
-module CatarsePaypalExpress
-  module Processors
-  end
-end

data/lib/catarse_paypal_express/processors/paypal.rb

@@ -1,26 +0,0 @@
-module CatarsePaypalExpress
-  module Processors
-    class Paypal
-
-      def process!(backer, data)
-        status = data["checkout_status"] || "pending"
-
-        notification = backer.payment_notifications.new({
-          status: status,
-          extra_data: data
-        })
-
-        notification.save!
-
-        backer.confirm! if success_payment?(status)
-      end
-
-      protected
-
-      def success_payment?(status)
-        status == 'PaymentActionCompleted'
-      end
-
-    end
-  end
-end

data/spec/controllers/catarse_paypal_express/payment/paypal_express_controller_spec.rb

@@ -1,177 +0,0 @@
-require 'spec_helper'
-
-describe CatarsePaypalExpress::Payment::PaypalExpressController do
-  before do
-    Configuration.create!(name: "paypal_username", value: "usertest_api1.teste.com")
-    Configuration.create!(name: "paypal_password", value: "HVN4PQBGZMHKFVGW")
-    Configuration.create!(name: "paypal_signature", value: "AeL-u-Ox.N6Jennvu1G3BcdiTJxQAWdQcjdpLTB9ZaP0-Xuf-U0EQtnS")
-    ActiveMerchant::Billing::PaypalExpressGateway.any_instance.stub(:details_for).and_return({})
-    Airbrake.stub(:notify).and_return({})
-  end
-
-  let(:current_user) { Factory(:user) }
-
-  context 'when receive a notification' do
-    it 'and not found the backer, should return 404' do
-      post :notifications, { id: 1, use_route: 'catarse_paypal_express'}
-      response.status.should eq(404)
-    end
-
-    it 'and the transaction ID not match, should return 404' do
-      backer = Factory(:backer, payment_id: '1234')
-      post :notifications, { id: backer.id, txn_id: 123, use_route: 'catarse_paypal_express' }
-      response.status.should eq(404)
-    end
-
-    it 'should create a payment_notification' do
-      success_payment_response = mock()
-      success_payment_response.stubs(:params).returns({ 'transaction_id' => '1234', "checkout_status" => "PaymentActionCompleted" })
-      success_payment_response.stubs(:success?).returns(true)
-      ActiveMerchant::Billing::PaypalExpressGateway.any_instance.stub(:details_for).and_return(success_payment_response)
-
-      backer = Factory(:backer, payment_id: '1234')
-      backer.payment_notifications.should be_empty
-
-      post :notifications, { id: backer.id, txn_id: 1234 , use_route: 'catarse_paypal_express' }
-      backer.reload
-
-      backer.payment_notifications.should_not be_empty
-    end
-
-    it 'and the transaction ID match, should update the payment status if successful' do
-      success_payment_response = mock()
-      success_payment_response.stubs(:params).returns({ 'transaction_id' => '1234', "checkout_status" => "PaymentActionCompleted" })
-      success_payment_response.stubs(:success?).returns(true)
-      ActiveMerchant::Billing::PaypalExpressGateway.any_instance.stub(:details_for).and_return(success_payment_response)
-      backer = Factory(:backer, payment_id: '1234', confirmed: false)
-
-      post :notifications, { id: backer.id, txn_id: 1234, use_route: 'catarse_paypal_express' }
-
-      backer.reload
-      response.status.should eq(200)
-      backer.confirmed.should be_true
-    end
-  end
-
-  context 'setup purchase' do
-    context 'when have some failures' do
-      it 'user not logged in, should redirect' do
-        pending 'problems with external application routes'
-        #get :pay, {locale: 'en', use_route: 'catarse_paypal_express' }
-        #response.status.should eq(302)
-      end
-
-      it 'backer not belongs to current_user should 404' do
-        backer = Factory(:backer)
-        session[:user_id] = current_user.id
-
-        lambda { 
-          get :pay, { id: backer.id, locale: 'en', use_route: 'catarse_paypal_express' }
-        }.should raise_exception ActiveRecord::RecordNotFound
-      end
-
-      it 'raise a exepction because invalid data and should be redirect and set the flash message' do
-        ActiveMerchant::Billing::PaypalExpressGateway.any_instance.stub(:setup_purchase).and_raise(StandardError)
-        session[:user_id] = current_user.id
-        backer = Factory(:backer, user: current_user)
-
-        get :pay, { id: backer.id, locale: 'en', use_route: 'catarse_paypal_express' }
-        flash[:failure].should == I18n.t('paypal_error', scope: CatarsePaypalExpress::Payment::PaypalExpressController::SCOPE)
-        response.should be_redirect
-      end
-    end
-
-    context 'when successul' do
-      before do
-        success_response = mock()
-        success_response.stub(:token).and_return('ABCD')
-        success_response.stub(:params).and_return({ 'correlation_id' => '123' })
-        ActiveMerchant::Billing::PaypalExpressGateway.any_instance.stub(:setup_purchase).and_return(success_response)
-      end
-
-      it 'should create a payment_notification' do
-        session[:user_id] = current_user.id
-        backer = Factory(:backer, user: current_user)
-
-        get :pay, { id: backer.id, locale: 'en', use_route: 'catarse_paypal_express' }
-        backer.reload
-
-        backer.payment_notifications.should_not be_empty
-        backer.payment_notifications.first.status == 'pending'
-      end
-
-      it 'payment method, token and id should be persisted ' do
-        session[:user_id] = current_user.id
-        backer = Factory(:backer, user: current_user)
-
-        get :pay, { id: backer.id, locale: 'en', use_route: 'catarse_paypal_express' }
-        backer.reload
-
-        backer.payment_method.should == 'PayPal'
-        backer.payment_token.should == 'ABCD'
-        backer.payment_id.should == '123'
-
-        response.should be_redirect
-      end
-    end
-  end
-
-  context 'when cancel the paypal purchase' do
-    it 'should show for user the flash message' do
-      session[:user_id] = current_user.id
-      backer = Factory(:backer, user: current_user, payment_token: 'TOKEN')
-
-      get :cancel, { id: backer.id, locale: 'en', use_route: 'catarse_paypal_express' }
-      flash[:failure].should == I18n.t('paypal_cancel', scope: CatarsePaypalExpress::Payment::PaypalExpressController::SCOPE)
-      response.should be_redirect
-    end
-  end
-
-  context 'paypal returning to success route' do
-    context 'when paypal purchase is ok' do
-      before(:each) do
-        fake_success_purchase = mock()
-        fake_success_purchase.stub(:success?).and_return(true)
-        ActiveMerchant::Billing::PaypalExpressGateway.any_instance.stub(:purchase).and_return(fake_success_purchase)
-
-        fake_success_details = mock()
-        fake_success_details.stub(:payer_id).and_return('123')
-        fake_success_details.stub(:params).and_return({'transaction_id' => '12345', "checkout_status" => "PaymentActionCompleted"})
-        ActiveMerchant::Billing::PaypalExpressGateway.any_instance.stub(:details_for).and_return(fake_success_details)
-      end
-
-      it 'should update the backer and redirect to thank_you' do
-        session[:user_id] = current_user.id
-        backer = Factory(:backer, user: current_user, payment_token: 'TOKEN')
-        backer.payment_notifications.should be_empty
-
-        get :success, { id: backer.id, locale: 'en', use_route: 'catarse_paypal_express' }
-        backer.reload
-
-        backer.payment_notifications.should_not be_empty
-        backer.confirmed.should be_true
-        backer.payment_id.should == '12345'
-        session[:thank_you_id].should == backer.project.id
-        session[:_payment_token].should == backer.payment_token
-
-        response.should redirect_to('/thank_you')
-      end
-    end
-    context 'when paypal purchase raise a error' do
-      before do
-        ActiveMerchant::Billing::PaypalExpressGateway.any_instance.stub(:purchase).and_raise(StandardError)
-      end
-
-      it 'should be redirect and show a flash message' do
-        session[:user_id] = current_user.id
-        backer = Factory(:backer, user: current_user)
-
-        get :success, { id: backer.id, locale: 'en', use_route: 'catarse_paypal_express' }
-
-        flash[:failure].should == I18n.t('paypal_error', scope: CatarsePaypalExpress::Payment::PaypalExpressController::SCOPE)
-        response.should be_redirect
-      end
-    end
-  end
-
-end

data/spec/lib/processors/paypal_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe CatarsePaypalExpress::Processors::Paypal do
-  context "process paypal details_for response" do
-    let(:backer) { Factory(:backer, confirmed: false) }
-
-    it "should create a new payment_notifications for backer" do
-      backer.payment_notifications.should be_empty
-      subject.process!(backer, paypal_details_response)
-      backer.payment_notifications.should_not be_empty
-    end
-
-    it "should fill status based on checkout_status" do
-      subject.process!(backer, paypal_details_response)
-      backer.payment_notifications.first.status.should == 'PaymentActionCompleted'
-    end
-
-    it "should fill extra_data with all response data" do
-      subject.process!(backer, paypal_details_response)
-      backer.payment_notifications.first.extra_data.should == paypal_details_response
-    end
-
-    it "should confirm backer when checkout status is completed" do
-      subject.process!(backer, paypal_details_response)
-      backer.confirmed.should be_true
-    end
-
-    it "should not confirm when checkout status is not completed" do
-      subject.process!(backer, paypal_details_response.merge!({"checkout_status" => "just_another_status"}) )
-      backer.confirmed.should be_false
-    end
-  end
-end