braspag-pagador 0.9.4

data/lib/braspag/core/poster.rb

@@ -0,0 +1,40 @@
+module Braspag
+  class Poster
+    def initialize(connection, url)
+      @connection = connection
+      @request = ::HTTPI::Request.new(url)
+    end
+
+    def do_post(method, data, headers = {})
+      @request.body = data
+      @request.proxy = @connection.proxy_address if @connection.proxy_address
+      headers.each_pair do |k,v|
+        @request.headers[k] = v
+      end
+
+      with_logger(method) do
+        ::HTTPI.post @request
+      end
+    end
+
+    private
+
+    def with_logger(method)
+      if @connection.logger
+        @connection.logger.info("[Braspag] ##{method}: #{@request.url}, data: #{mask_data(@request.body).inspect}")
+        response = yield
+        @connection.logger.info("[Braspag] ##{method} returns: #{response.body.inspect}")
+      else
+        response = yield
+      end
+      response
+    end
+
+    def mask_data(data)
+      copy_data = data.dup
+      copy_data['cardNumber'] = "************%s" % copy_data['cardNumber'][-4..-1] if copy_data['cardNumber']
+      copy_data['securityCode'] = "***" if copy_data['securityCode']
+      copy_data
+    end
+  end
+end

data/lib/braspag/crypto/no_crypto.rb

@@ -0,0 +1,6 @@
+module Braspag
+  module Crypto
+    class NoCrypto
+    end
+  end
+end

data/lib/braspag/crypto/webservice.rb

@@ -0,0 +1,63 @@
+module Braspag
+  module Crypto
+    class Webservice
+      def encrypt(connection, map)
+        data = ERB.new(File.read(Braspag::PATH + '/braspag/templates/crypto/encrypt.xml.erb'))
+
+        response = Braspag::Poster.new(
+          connection, 
+          connection.url_for(:encrypt)
+        ).do_post(
+          :encrypt,
+          data.result(binding),
+          {"Content-Type" => "text/xml"}
+        )
+        
+        document = Nokogiri::XML(response.body)
+
+        raise 'UnknownError' if document.children.empty?
+
+        #melhorar este parser cof cof
+        response = document.children.children.children.children.children.to_s
+
+        raise 'InvalidMerchantId' if (response == 'Erro BP 011' || response == 'Erro BP 012')
+        raise 'InvalidIP' if (response == 'Erro BP 067' || response == 'Erro BP 068')
+
+        response
+      end
+
+      def decrypt(connection, encripted_text)
+        data = ERB.new(File.read(Braspag::PATH + '/braspag/templates/crypto/decrypt.xml.erb'))
+        
+        response = Braspag::Poster.new(
+          connection, 
+          connection.url_for(:decrypt)
+        ).do_post(
+          :decrypt,
+          data.result(binding),
+          {"Content-Type" => "text/xml"}
+        )
+        
+        document = Nokogiri::XML(response.body)
+        raise 'UnknownError' if document.children.empty?
+
+        result_error = document.children.children.children.children.children.first.content.to_s
+
+        raise 'InvalidMerchantId' if (result_error == 'Erro BP 011' || result_error == 'Erro BP 012')
+        raise 'InvalidIP' if (result_error == 'Erro BP 067' || result_error == 'Erro BP 068')
+
+        convert_request_to_map document
+      end
+
+      protected
+      def convert_request_to_map(document)
+        map = {}
+        document.children.children.children.children.children.each do |n|
+          values = n.content.to_s.split("=")
+          map[values[0].downcase.to_sym] = values[1] if values.size == 2
+        end
+        map
+      end
+    end
+  end
+end

data/lib/braspag/payment/billet.rb

@@ -0,0 +1,79 @@
+require "bigdecimal"
+
+module Braspag
+  class Connection
+    def generate_billet(order, billet)
+      response = self.post(:generate_billet, order, billet)
+      status = (response[:status] == "0")
+
+      ActiveMerchant::Billing::Response.new(status,
+                   response[:message],
+                   response,
+                   :test => homologation?,
+                   :authorization => response[:number])
+    end
+  end
+  
+  class Billet
+    include ::ActiveAttr::Model
+    
+    class DueDateValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        # unless value.class.in? [Date, Time]
+        unless (
+          value.kind_of?(Time) || value.kind_of?(Date)
+        )
+          record.errors.add attribute, "invalid date"
+        end
+      end
+    end
+    
+    attr_accessor :id, :instructions, :due_date_on, :url, :code, :created_at, :due_date_on
+    attr_accessor :receiver, :bank, :agency, :account, :wallet, :amount, :amount_paid, :paid_at
+
+    validates :id, :length => {:minimum => 1, :maximum => 255, :on => :generate, :allow_blank => true }
+    validates :instructions, :length => {:minimum => 1, :maximum => 512, :on => :generate, :allow_blank => true }
+    validates :due_date_on, :presence => { :on => :generate }
+    validates :due_date_on, :due_date => { :on => :generate }
+    
+    def self.to_generate_billet(connection, order, billet)
+      {
+        "merchantId"       => connection.merchant_id,
+        "boletoNumber"     => billet.id.to_s,
+        "instructions"     => billet.instructions.to_s,
+        "expirationDate"   => billet.due_date_on.strftime("%d/%m/%y"),
+        "customerName"     => order.customer.name.to_s,
+        "customerIdNumber" => order.customer.document.to_s,
+        "emails"           => order.customer.email.to_s,
+        "orderId"          => order.id.to_s,
+        "amount"           => Braspag::Converter::decimal_to_string(order.amount),
+        "paymentMethod"    => order.payment_method
+      }
+    end
+    
+    def self.from_generate_billet(connection, order, billet, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+        :url => nil,
+        :amount => nil,
+        :number => "boletoNumber",
+        :expiration_date => Proc.new { |document|
+          begin
+            Date.parse(document.search("expirationDate").first.to_s)
+          rescue
+            nil
+          end
+        },
+        :return_code => "returnCode",
+        :status => nil,
+        :message => nil
+      })
+      
+      order.gateway_return_code = response[:return_code]
+      order.gateway_status = response[:status]
+      order.gateway_amount = BigDecimal.new(response[:amount].to_s) if response[:amount]
+      billet.url = response[:url]
+      
+      response
+    end
+  end
+end

data/lib/braspag/payment/credit_card.rb

@@ -0,0 +1,190 @@
+module Braspag
+  class Connection
+    def purchase(order, credit_card)
+      resp = self.authorize(order, credit_card)
+      resp = self.capture(order) if resp.success?
+      resp
+    end
+
+    def authorize(order, credit_card)
+      response = self.post(:authorize, order, credit_card)
+
+      status = (response[:status] == "0" || response[:status] == "1")
+
+      ActiveMerchant::Billing::Response.new(status,
+                   response[:message],
+                   response,
+                   :test => homologation?,
+                   :authorization => response[:number])
+    end
+
+    def capture(order)
+      response = self.post(:capture, order)
+
+      status = (response[:status] == "0")
+
+      ActiveMerchant::Billing::Response.new(status,
+                   response[:message],
+                   response,
+                   :test => homologation?,
+                   :authorization => response[:number])
+    end
+
+    def void(order, partial=nil)
+      response = self.post(:void, order)
+
+      status = (response[:status] == "0")
+
+      ActiveMerchant::Billing::Response.new(status,
+                   response[:message],
+                   response,
+                   :test => homologation?)
+    end
+  end
+
+  class CreditCard
+    include ::ActiveAttr::Model
+
+    attr_accessor :holder_name, :number, :month, :year, :verification_value, :alias, :id
+    attr_accessor :checking_number, :avs, :autorization_number, :transaction_number
+    attr_accessor :avs_response, :issuing, :authenticated_number
+
+    class ExpiratorValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        begin
+          year = record.year.try(:to_i)
+          year = "20#{year}".to_i if year && year.to_s.size == 2
+
+          month = record.month.try(:to_i)
+
+          Date.new(year, month) if year && month
+        rescue ArgumentError
+          record.errors.add attribute, "invalid date"
+        end
+      end
+    end
+
+
+    [:purchase, :authorize, :archive].each do |check_on|
+      validates :holder_name, :length => {:minimum => 1, :maximum => 100, :on => check_on}
+
+      validates :number, :presence => { :on => check_on }
+
+      validates :month, :presence => { :on => check_on }
+      validates :month, :expirator => { :on => check_on }
+      validates :year, :presence => { :on => check_on }
+      validates :year, :expirator => { :on => check_on }
+    end
+
+    [:purchase, :authorize, :recurrency].each do |check_on|
+      validates :verification_value, :length => {:minimum => 1, :maximum => 4, :on => check_on}
+    end
+
+    [:get_recurrency, :recurrency].each do |check_on|
+      validates :id, :length => {:is => 36, :on => check_on}
+    end
+
+    def self.to_save_credit_card(connection,credit_card,customer,request_id)
+      {
+        'saveCreditCardRequestWS'  => {
+          'MerchantKey'    => connection.merchant_id,
+          'CustomerName'   => customer.name.to_s,
+          'CardHolder'     => credit_card.holder_name.to_s,
+          'CardNumber'     => credit_card.number.to_s,
+          'CardExpiration' => "#{credit_card.month}/#{credit_card.year}",
+          'RequestId'      => request_id
+        }
+      }
+    end
+
+    def self.to_authorize(connection, order, credit_card)
+      year_normalize = credit_card.year.to_s[-2, 2]
+      {
+        "merchantId"     => connection.merchant_id,
+        "holder"         => credit_card.holder_name.to_s,
+        "cardNumber"     => credit_card.number.to_s,
+        "expiration"     => "#{credit_card.month}/#{year_normalize}",
+        "securityCode"   => credit_card.verification_value.to_s,
+        "customerName"   => order.customer.name.to_s,
+        "orderId"        => order.id.to_s,
+        "amount"         => Braspag::Converter::decimal_to_string(order.amount),
+        "paymentMethod"  => order.payment_method,
+        "numberPayments" => order.installments,
+        "typePayment"    => order.installments_type
+      }
+    end
+
+    def self.from_authorize(connection, order, credit_card, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+              :amount         => nil,
+              :number         => "authorisationNumber",
+              :message        => nil,
+              :return_code    => 'returnCode',
+              :status         => nil,
+              :transaction_id => "transactionId"
+      })
+
+      order.gateway_authorization = response[:number]
+      order.gateway_id = response[:transaction_id]
+      order.gateway_return_code = response[:return_code]
+      order.gateway_status = response[:status]
+      order.gateway_message = response[:message]
+      order.gateway_amount = Braspag::Converter::string_to_decimal(response[:amount])
+
+      response
+    end
+
+    def self.to_capture(connection, order)
+      {
+        "merchantId"  => connection.merchant_id,
+        "orderId"     => order.id.to_s
+      }
+    end
+
+    def self.from_capture(connection, order, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+              :amount => nil,
+              :message => 'message',
+              :return_code => 'returnCode',
+              :status => 'status',
+              :transaction_id => "transactionId"
+      })
+
+      #TODO: CHECK IF IS NECESSARY
+      # order.gateway_capture_id = response[:transaction_id]
+      order.gateway_capture_return_code = response[:return_code]
+      order.gateway_capture_status = response[:status]
+      order.gateway_capture_message = response[:message]
+      order.gateway_capture_amount = Braspag::Converter::string_to_decimal(response[:amount])
+
+      response
+    end
+
+    def self.to_void(connection, order)
+      {
+        "merchantId" => connection.merchant_id,
+        "order"      => order.id.to_s
+      }
+    end
+
+    def self.from_void(connection, order, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+              :order_id => "orderId",
+              :amount => nil,
+              :message => 'message',
+              :return_code => 'returnCode',
+              :status => 'status',
+              :transaction_id => "transactionId"
+      })
+
+      #TODO: CHECK IF IS NECESSARY
+      # order.gateway_void_id = response[:transaction_id]
+      order.gateway_void_return_code = response[:return_code]
+      order.gateway_void_status = response[:status]
+      order.gateway_void_message = response[:message]
+      order.gateway_void_amount = Braspag::Converter::string_to_decimal(response[:amount])
+
+      response
+    end
+  end
+end

data/lib/braspag/payment/eft.rb

@@ -0,0 +1,65 @@
+module Braspag
+  class Connection
+    def generate_eft(order, eft)
+
+      params = {
+        Id_Loja:      self.merchant_id,
+        VALOR:        Braspag::Converter::decimal_to_string(order.amount),
+        CODPAGAMENTO: order.payment_method,
+        VENDAID:      order.id,
+        NOME:         order.customer.name
+      }
+
+      html = "<form id='form_tef_#{order.id}' name='form_tef_#{order.id}' action='#{self.url_for(:generate_eft)}' method='post'>"
+
+
+      begin
+        unless eft.crypto.respond_to?(:encrypt)
+          params.each do |key, value|
+            html << "<input type='text' name='#{key}' value='#{value}' />"
+          end
+        else
+          params.delete("Id_Loja")
+          html << "<input type='text' name='Id_Loja' value='#{self.merchant_id}' />"
+          html << "<input type='text' name='crypt' value='#{eft.crypto.encrypt(self, params)}' />"
+        end
+
+        html << "</form><script type='text/javascript' charset='utf-8'>document.forms['form_tef_#{order.id}'].submit();</script>"
+
+        eft.code = html
+        status = true
+        message = 'OK'
+      rescue Exception => e
+        status = false
+        message = e.message
+      end
+
+      ActiveMerchant::Billing::Response.new(status,
+       message,
+       {},
+       :test => homologation?)
+    end
+  end
+
+  class EFT
+    include ::ActiveAttr::Model
+
+    class CryptoValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        unless (
+          value.kind_of?(Braspag::Crypto::NoCrypto) ||
+          value.respond_to?(:encrypt)
+          )
+          record.errors.add attribute, "invalid crypto"
+        end
+      end
+    end
+
+    attr_accessor :crypto, :code
+
+    validates :crypto, :presence => { :on => :generate }
+    validates :crypto, :crypto => { :on => :generate }
+
+  end
+
+end