spree_mercado_pago_payment_method 0.1.1 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 40adfc499928eac15119057cce845e736bbb38ed
+  data.tar.gz: 38e99138673257e99550bb574009e9ef3443d5ab
+SHA512:
+  metadata.gz: e1e288333612ef5bafe0a88c54450ddc48a0a994fb6b27c0925680980f92381f9c2a39776f78707a91547a0ae8901e5c6cab4d94640397e062b0e5781a49ab81
+  data.tar.gz: b6fe628da4a1a92c684b9dfd0cceccab2a78a0fdc1cd370545b6d6334a4c1b1e221768e32864cc16e5190c7c9a4a1cb248474bb0154c44afab03b272283ccefb

data/app/assets/javascripts/spree/frontend/spree_mercado_pago_payment_method.js

@@ -0,0 +1,25 @@
+//= require spree/frontend
+
+MercadoPago = {
+  hidePaymentSaveAndContinueButton: function(paymentMethod) {
+    if (MercadoPago.paymentMethodID && paymentMethod.val() == MercadoPago.paymentMethodID) {
+      $('.continue').hide();
+      $('[data-hook=coupon_code]').hide();
+    } else {
+      $('.continue').show();
+      $('[data-hook=coupon_code]').show();
+    }
+  }
+};
+
+$(document).ready(function() {
+  checkedPaymentMethod = $('div[data-hook="checkout_payment_step"] input[type="radio"]:checked');
+  MercadoPago.hidePaymentSaveAndContinueButton(checkedPaymentMethod);
+  paymentMethods = $('div[data-hook="checkout_payment_step"] input[type="radio"]').click(function (e) {
+    MercadoPago.hidePaymentSaveAndContinueButton($(e.target));
+  });
+
+  $('button.mercado_pago_button').click(function(event){
+    $(event.target).prop("disabled",true);
+  });
+});

data/app/controllers/spree/mercado_pago_controller.rb

@@ -1,47 +1,69 @@
-# -*- encoding : utf-8 -*-
-require 'rest_client'
-
 module Spree
-  class MercadoPagoController < Spree::BaseController
-    before_filter :get_order
+  class MercadoPagoController < StoreController
+    protect_from_forgery except: :ipn
+    skip_before_filter :set_current_order, only: :ipn
 
-    def success
-      advance_state
+    def checkout
+      current_order.state_name == :payment || raise(ActiveRecord::RecordNotFound)
+      payment_method = PaymentMethod::MercadoPago.find(params[:payment_method_id])
+      payment = current_order.payments.
+        create!({amount: current_order.total, payment_method: payment_method})
+      payment.started_processing!
+
+      preferences = ::MercadoPago::OrderPreferencesBuilder.
+        new(current_order, payment, callback_urls).
+        preferences_hash
+
+      provider = payment_method.provider
+      provider.create_preferences(preferences)
+
+      redirect_to provider.redirect_url
     end
 
-    def pending
-      advance_state
+    # Success/pending callbacks are currently aliases, this may change
+    # if required.
+    def success
+      payment.pend!
+      payment.order.next
+      flash.notice = Spree.t(:order_processed_successfully)
+      flash['order_completed'] = true
+      redirect_to spree.order_path(payment.order)
     end
 
     def failure
+      payment.failure!
+      flash.notice = Spree.t(:payment_processing_failed)
+      flash['order_completed'] = true
+      redirect_to spree.checkout_state_path(state: :payment)
     end
 
-    private
-    def correct_order_state
-      (@order.state == 'payment' || @order.state == 'complete') &&
-        @order.payments.last.payment_method && @order.payments.m_method &&
-        (@order.payments.last.payment_method.type == "PaymentMethod::MercadoPago")
+    def ipn
+      notification = MercadoPago::Notification.
+        new(operation_id: params[:id], topic: params[:topic])
+
+      if notification.save
+        MercadoPago::HandleReceivedNotification.new(notification).process!
+        status = :ok
+      else
+        status = :bad_request
+      end
+
+      render nothing: true, status: status
     end
 
-    def advance_state
-      @order.update_attributes( { :state => "complete", :completed_at => Time.now },
-                               :without_protection => true)
+    private
+
+    def payment
+      @payment ||= Spree::Payment.where(identifier: params[:external_reference]).
+        first
     end
 
-    def get_order
-      user = spree_current_user
-      order_no = params[:order_number]
-      @order = Order.where(number: order_no).where(user_id: user.id).first
-
-      unless @order && correct_order_state
-        if @order.present?
-          redirect_to checkout_state_path(@order.state)
-        else
-          flash[:error] = I18n.t(:mp_invalid_order)
-          redirect_to root_path
-        end
-        return
-      end
+    def callback_urls
+      @callback_urls ||= {
+        success: mercado_pago_success_url,
+        pending: mercado_pago_success_url,
+        failure: mercado_pago_failure_url
+      }
     end
   end
 end

data/app/models/mercado_pago/client.rb

@@ -0,0 +1,63 @@
+require 'rest_client'
+require 'mercado_pago/client/authentication'
+require 'mercado_pago/client/preferences'
+require 'mercado_pago/client/api'
+
+module MercadoPago
+  class Client
+    # These three includes are because of the user of line_item_description from
+    # ProductsHelper
+    include Authentication
+    include Preferences
+    include API
+
+    attr_reader :errors
+    attr_reader :auth_response
+    attr_reader :preferences_response
+
+    def initialize(payment_method, options={})
+      @payment_method = payment_method
+      @api_options    = options.clone
+      @errors         = []
+    end
+
+    def get_operation_info(operation_id)
+      url = create_url(notifications_url(operation_id), access_token: access_token)
+      options = {content_type: 'application/x-www-form-urlencoded', accept: 'application/json'}
+      get(url, options, quiet: true)
+    end
+
+
+    # def get_external_reference(operation_id)
+    #   response = send_notification_request(operation_id)
+    #   if response
+    #     response['collection']['external_reference']
+    #   end
+    # end
+
+    def get_payment_status(external_reference)
+      response = send_search_request({external_reference: external_reference, access_token: access_token})
+
+      if response['results'].empty?
+        "pending"
+      else
+        response['results'][0]['collection']['status']
+      end
+    end
+
+    private
+
+    def log_error(msg, response, request, result)
+      Rails.logger.info msg
+      Rails.logger.info "response: #{response}."
+      Rails.logger.info "request args: #{request.args}."
+      Rails.logger.info "result #{result}."
+    end
+
+    def send_search_request(params, options={})
+      url = create_url(search_url, params)
+      options = {content_type: 'application/x-www-form-urlencoded', accept: 'application/json'}
+      get(url, options)
+    end
+  end
+end

data/app/models/mercado_pago/client/api.rb

@@ -0,0 +1,43 @@
+require 'json'
+
+class MercadoPago::Client
+  module API
+    def redirect_url
+      point_key = sandbox ? 'sandbox_init_point' : 'init_point'
+      @preferences_response[point_key]
+    end
+
+    private
+
+    def notifications_url(operation_id)
+      sandbox_part = sandbox ? 'sandbox/' : ''
+      "https://api.mercadolibre.com/#{sandbox_part}collections/notifications/#{operation_id}"
+    end
+
+    def search_url
+      sandbox_part = sandbox ? 'sandbox/' : ''
+      "https://api.mercadolibre.com/#{sandbox_part}collections/search"
+    end
+
+    def create_url(url, params={})
+      uri = URI(url)
+      uri.query = URI.encode_www_form(params)
+      uri.to_s
+    end
+
+    def preferences_url(token)
+      create_url('https://api.mercadolibre.com/checkout/preferences', access_token: token)
+    end
+
+    def sandbox
+      @api_options[:sandbox]
+    end
+
+    def get(url, request_options={}, options={})
+      response = RestClient.get(url, request_options)
+      JSON.parse(response)
+    rescue => e
+      raise e unless options[:quiet]
+    end
+  end
+end

data/app/models/mercado_pago/client/authentication.rb

@@ -0,0 +1,36 @@
+require 'json'
+
+class MercadoPago::Client
+  module Authentication
+    def authenticate
+      response = send_authentication_request
+      @auth_response = JSON.parse(response)
+    rescue RestClient::Exception => e
+      @errors << I18n.t(:authentication_error, scope: :mercado_pago)
+      raise RuntimeError.new e.message
+    end
+
+    private
+
+    def send_authentication_request
+      RestClient.post(
+        'https://api.mercadolibre.com/oauth/token',
+        {:grant_type => 'client_credentials', :client_id => client_id, :client_secret => client_secret},
+        :content_type => 'application/x-www-form-urlencoded', :accept => 'application/json'
+      )
+    end
+
+    def client_id
+      @payment_method.preferred_client_id
+    end
+
+    def client_secret
+      @payment_method.preferred_client_secret
+    end
+
+    def access_token
+      authenticate unless @auth_response
+      @auth_response['access_token']
+    end
+  end
+end

data/app/models/mercado_pago/client/preferences.rb

@@ -0,0 +1,20 @@
+require 'json'
+
+class MercadoPago::Client
+  module Preferences
+    def create_preferences(preferences)
+      response = send_preferences_request(preferences)
+      @preferences_response = JSON.parse(response)
+    rescue RestClient::Exception => e
+      @errors << I18n.t(:authentication_error, scope: :mercado_pago)
+      raise RuntimeError.new(e.message)
+    end
+
+    private
+
+    def send_preferences_request(preferences)
+      RestClient.post(preferences_url(access_token), preferences.to_json,
+                      :content_type => 'application/json', :accept => 'application/json')
+    end
+  end
+end

data/app/models/mercado_pago/notification.rb

@@ -0,0 +1,8 @@
+module MercadoPago
+  class Notification < ActiveRecord::Base
+    self.table_name = "mercado_pago_notifications"
+    
+    validates :topic, presence: true, inclusion: {in: %w(payment preapproval authorized_payment merchant_order) }
+    validates :operation_id, presence: true
+  end
+end

data/app/models/mercado_pago/order_preferences_builder.rb

@@ -0,0 +1,68 @@
+module MercadoPago
+  class OrderPreferencesBuilder
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::SanitizeHelper
+    include Spree::ProductsHelper
+
+    def initialize(order, payment, callback_urls, payer_data = nil)
+      @order         = order
+      @payment       = payment
+      @callback_urls = callback_urls
+      @payer_data    = payer_data
+    end
+
+    def preferences_hash
+      {
+        external_reference: @payment.identifier,
+        back_urls: @callback_urls,
+        payer: @payer_data,
+        items: generate_items
+      }
+    end
+
+    private
+
+    def generate_items
+      items = []
+
+      items += generate_items_from_line_items
+      items += generate_items_from_adjustments
+      items += generate_items_from_shipments
+
+      items
+    end
+
+    def generate_items_from_shipments
+      @order.shipments.collect do |shipment|
+        {
+          :title => shipment.shipping_method.name,
+          :unit_price => shipment.cost.to_f,
+          :quantity => 1,
+          :currency_id => 'ARS'
+        }
+      end
+    end
+
+    def generate_items_from_line_items
+      @order.line_items.collect do |line_item|
+        {
+          :title => line_item_description_text(line_item.variant.product.name),
+          :unit_price => line_item.price.to_f,
+          :quantity => line_item.quantity,
+          :currency_id => 'ARS'
+        }
+      end
+    end
+
+    def generate_items_from_adjustments
+      @order.adjustments.eligible.collect do |adjustment|
+        {
+          title: line_item_description_text(adjustment.label),
+          unit_price: adjustment.amount.to_f,
+          quantity: 1,
+          currency_id: "ARS"
+        }
+      end
+    end
+  end
+end

data/app/models/spree/payment_method/mercado_pago.rb

@@ -0,0 +1,46 @@
+module Spree
+  class PaymentMethod::MercadoPago < PaymentMethod
+    preference :client_id,     :integer
+    preference :client_secret, :string
+    preference :sandbox, :boolean, default: true
+
+    def payment_profiles_supported?
+      false
+    end
+
+    def provider_class
+      ::MercadoPago::Client
+    end
+
+    def provider(additional_options = {})
+      @provider ||= begin
+                      options = { sandbox: preferred_sandbox }
+                      client = provider_class.new(self, options.merge(additional_options))
+                      client.authenticate
+                      client
+                    end
+    end
+
+    def source_required?
+      false
+    end
+
+    def auto_capture?
+      false
+    end
+
+    ## Admin options
+
+    def can_void?(payment)
+      payment.state != 'void'
+    end
+
+    def actions
+      %w{void}
+    end
+
+    def void(*args)
+      ActiveMerchant::Billing::Response.new(true, "", {}, {})
+    end
+  end
+end

data/app/services/mercado_pago/handle_received_notification.rb

@@ -0,0 +1,18 @@
+module MercadoPago
+  class HandleReceivedNotification
+    def initialize(notification)
+      @notification = notification
+    end
+
+    # The purpose of this method is to enable async/sync processing
+    # of Mercado Pago IPNs. For simplicity processing is synchronous but
+    # if you would like to enqueue the processing via Resque/Ost/etc you
+    # will be able to do it.
+    def process!
+      # Sync
+      ProcessNotification.new(@notification).process!
+      # Async Will be configurable via block for example:
+      # Resque.enqueue(ProcessNotificationWorker, {id: @notification.id})
+    end
+  end
+end