cbraspag 0.9.3 → 0.9.4

data/lib/cbraspag.rb

@@ -6,12 +6,12 @@ require 'json'
 require 'nokogiri'
 require 'savon'
 require 'bigdecimal'
+require 'active_merchant'
 
 require "cbraspag/version"
 require 'cbraspag/core/converter'
 require 'cbraspag/core/connection'
 require 'cbraspag/core/poster'
-require 'cbraspag/core/response'
 require 'cbraspag/core/customer'
 require 'cbraspag/core/order'
 

data/lib/cbraspag/core/connection.rb

@@ -54,7 +54,7 @@ module Braspag
         braspag_url + "/pagador/passthru.asp"
       when :info_billet
         braspag_info_url + "/GetDadosBoleto"
-      when :info_card
+      when :info_credit_card
         braspag_info_url + "/GetDadosCartao"
       when :info
         braspag_info_url + "/GetDadosPedido"
@@ -69,28 +69,33 @@ module Braspag
       end
     end
     
-    def convert_to(method)
-      {:merchant_id => self.merchant_id}
+    def post(method_name, *args)
+      response = Braspag::Poster.new(
+        self, 
+        self.url_for(method_name)
+      ).do_post(
+        method_name, 
+        self.convert(method_name, :to, args)
+      )
+      
+      self.convert(method_name, :from, args + [response] )
     end
     
-    def post(method, *args)
-      data = convert_to(method)
-      args.each do |field|
-        data.merge!(field.convert_to(method))
-      end
-
-      data = Converter::to(method, data)
-      
-      response = Braspag::Poster.new(self, self.url_for(method))
-                                .do_post(method, data)
-      
-      response = Converter::from(method, response.body)
-      
-      args.each do |field|
-        field.populate!(method, response)
+    def convert(method_name, direction, args)
+      target = case method_name
+      when :authorize, :void, :capture, :archive_card, :get_card, :recurrency
+        CreditCard
+      when :generate_billet
+        Billet
+      when :generate_eft
+        EFT
+      when :info_billet, :info_credit_card, :info
+        Order
+      when :encrypt
+        Crypto::Webservice
       end
       
-      response
-    end
+      target.send("#{direction}_#{method_name}", *([self] + args))
+    end    
   end
 end

data/lib/cbraspag/core/converter.rb

@@ -1,14 +1,21 @@
 module Braspag
   class Converter
     def self.decimal_to_string(value)
+      #TODO: CHANGE ANOTHER FOR CONVERSION
       ("%.2f" % value.to_f).gsub('.', ',')
     end
     
-    def self.string_to_decimal(value)
-      BigDecimal.new(value.to_s.gsub(".",""))
+    def self.string_to_decimal(value, mode = :br)
+      case mode
+      when :br
+        BigDecimal.new(value.to_s.gsub(".","").gsub(",","."))
+      when :eua
+        BigDecimal.new(value.to_s.gsub(",",""))
+      end
     end
+    
 
-    def self.to_map(document, map = {})
+    def self.hash_from_xml(document, map = {})
       document = Nokogiri::XML(document)
 
       map.each do |key, value|
@@ -36,125 +43,21 @@ module Braspag
     def self.payment_method_name?(code)
       Braspag::PAYMENT_METHOD.key(code.to_s.to_i)
     end
-    
-    def self.status_name?(code)
-      Braspag::STATUS_PAYMENT.key(code.to_s.to_i)
-    end
-    
-    def self.to_hash(format, params)
-      data = {}
-      format.each do |k, v|
-        case k
-        when :amount
-          data[v] = self.decimal_to_string(params[:amount])
-        else
-          data[v] = params[k] || ""
-        end
+
+    def self.payment_method_type?(code)
+      key = Braspag::PAYMENT_METHOD.key(code.to_s.to_i)
+      return nil if key.nil?
+      if key.match(/billet_/)
+        :billet
+      elsif key.match(/eft_/)
+        :eft
+      else
+        :credit_card
       end
-      data
-    end
-    
-    def self.to(method, data)
-      self.send("to_#{method}", data)
-    end
-    
-    def self.to_authorize(params)
-      self.to_hash({
-        :merchant_id => "merchantId",
-        :order_id => "orderId",
-        :customer_name => "customerName",
-        :amount => "amount",
-        :payment_method => "paymentMethod",
-        :holder => "holder",
-        :card_number => "cardNumber",
-        :expiration => "expiration",
-        :security_code => "securityCode",
-        :number_payments => "numberPayments",
-        :type => "typePayment",
-      }, params)
-    end
-    
-    def self.to_capture(params)
-      self.to_hash({
-        :merchant_id => "merchantId",
-        :order_id => "orderId"
-      }, params)
     end
     
-    def self.to_void(params)
-      self.to_hash({
-        :merchant_id => "merchantId",
-        :order_id => "order"
-      }, params)
-    end
-    
-    def self.to_generate_billet(params)
-      self.to_hash({
-        :merchant_id => "merchantId",
-        :order_id => "orderId",
-        :customer_name => "customerName",
-        :customer_id => "customerIdNumber",
-        :amount => "amount",
-        :payment_method => "paymentMethod",
-        :number => "boletoNumber",
-        :instructions => "instructions",
-        :expiration_date => "expirationDate",
-        :emails => "emails"
-      }, params)
-    end
-    
-    def self.from(method, data)
-      self.send("from_#{method}", data)
-    end
-    
-    def self.from_authorize(data)
-      to_map(data, {
-        :amount => nil,
-        :number => "authorisationNumber",
-        :message => 'message',
-        :return_code => 'returnCode',
-        :status => 'status',
-        :transaction_id => "transactionId"
-      })
-    end
-    
-    def self.from_capture(data)
-      to_map(data, {
-        :amount => nil,
-        :message => 'message',
-        :return_code => 'returnCode',
-        :status => 'status',
-        :transaction_id => "transactionId"
-      })
-    end
-    
-    def self.from_void(data)
-      to_map(data, {
-        :order_id => "orderId",
-        :amount => nil,
-        :message => 'message',
-        :return_code => 'returnCode',
-        :status => 'status',
-        :transaction_id => "transactionId"
-      })
-    end
-    
-    def self.from_generate_billet(data)
-      to_map(data, {
-        :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
-      })
+    def self.status_name?(code)
+      Braspag::STATUS_PAYMENT.key(code.to_s.to_i)
     end
   end
 end

data/lib/cbraspag/core/customer.rb

@@ -9,29 +9,5 @@ module Braspag
       validates :email, :length => {:minimum => 1, :maximum => 255, :on => check_on, :allow_blank => true}
       validates :document, :length => {:minimum => 11, :maximum => 18, :on => check_on, :allow_blank => true}
     end
-    
-    def convert_to(method)
-      data = {}
-      data = self.send("to_#{method}") if self.respond_to?("to_#{method}")
-      data
-    end
-    
-    def to_authorize
-      {
-        :customer_name => self.name.to_s
-      }
-    end
-    
-    def to_generate_billet
-      {
-        :customer_name => self.name.to_s,
-        :customer_id   => self.document.to_s,
-        :emails        => self.email.to_s
-      }
-    end
-       
-    def populate!(method)
-      
-    end
   end
 end

data/lib/cbraspag/core/order.rb

@@ -1,84 +1,30 @@
 module Braspag
   class Connection
-    def self.get(order)
-      #check if order.is valid for get
-      return ::Response
+    def get(order)
+      response = self.post(:info, order)
       
-      response = Braspag::Poster.new(self, self.url_for(:info)).do_post(:info, {
-        :loja => self.merchant_id, :numeroPedido => order.id.to_s
-      })
+      if (  response.size == 0 || 
+            !response.fetch(:error_code, nil).nil? || 
+            response.fetch(:status, nil).nil?
+         )
+        return ActiveMerchant::Billing::Response.new(false,
+                     response.fetch(:error_message, ''),
+                     response,
+                     :test => homologation?)
+      end
       
-      response = Utils::convert_to_map(response.body, {
-        :authorization => "CodigoAutorizacao",
-        :error_code => "CodigoErro",
-        :error_message => "MensagemErro",
-        :payment_method => "CodigoPagamento",
-        :payment_method_name => "FormaPagamento",
-        :installments => "NumeroParcelas",
-        :status => "Status",
-        :amount => "Valor",
-        :cancelled_at => "DataCancelamento",
-        :paid_at => "DataPagamento",
-        :order_date => "DataPedido",
-        :transaction_id => "TransId",
-        :tid => "BraspagTid"
-      })
-
-      # raise InvalidData if response[:authorization].nil?
+      case order.payment_method_type?
+      when :billet
+        self.post(:info_billet, order)
+      when :credit_card
+        self.post(:info_credit_card, order)
+      end
       
-      self.get_billet(order)
-      self.get_credit_card(order)
-      response
-    end
-    
-    private
-    def self.get_billet(order)
-
-      request = ::HTTPI::Request.new(self.info_url)
-      request.body = {
-        :loja => connection.merchant_id,
-        :numeroPedido => order_id.to_s
-      }
-
-      response = ::HTTPI.post(request)
-
-      response = Utils::convert_to_map(response.body, {
-          :document_number => "NumeroDocumento",
-          :payer => "Sacado",
-          :our_number => "NossoNumero",
-          :bill_line => "LinhaDigitavel",
-          :document_date => "DataDocumento",
-          :expiration_date => "DataVencimento",
-          :receiver => "Cedente",
-          :bank => "Banco",
-          :agency => "Agencia",
-          :account => "Conta",
-          :wallet => "Carteira",
-          :amount => "ValorDocumento",
-          :amount_invoice => "ValorPago",
-          :invoice_date => "DataCredito"
-        })
-
-      raise UnknownError if response[:document_number].nil?
-      response
-    end
-    
-    def self.get_credit_card(order)
-      data = {:loja => self.merchant_id, :numeroPedido => order.id.to_s}
-      response = Braspag::Poster.new(self, self.info_url).do_post(:info_credit_card, data)
-
-      response = Utils::convert_to_map(response.body, {
-          :checking_number => "NumeroComprovante",
-          :certified => "Autenticada",
-          :autorization_number => "NumeroAutorizacao",
-          :card_number => "NumeroCartao",
-          :transaction_number => "NumeroTransacao"
-        })
-
-      raise UnknownError if response[:checking_number].nil?
-      response
+      ActiveMerchant::Billing::Response.new(true,
+                   'OK',
+                   response,
+                   :test => homologation?)
     end
-    
   end
   
   class Order
@@ -112,6 +58,8 @@ module Braspag
     attr_accessor :gateway_authorization, :gateway_id, :gateway_return_code, :gateway_status, :gateway_message, :gateway_amount
     attr_accessor :gateway_capture_return_code, :gateway_capture_status, :gateway_capture_message, :gateway_capture_amount
     attr_accessor :gateway_void_return_code, :gateway_void_status, :gateway_void_message, :gateway_void_amount
+    attr_accessor :authorization, :payment_method_name, :status, :gateway_cancelled_at, :gateway_paid_at
+    attr_accessor :gateway_created_at, :transaction_id, :gateway_id, :billet, :credit_card
     
     [:purchase, :generate, :authorize, :capture, :void, :recurrency].each do |check_on|
       validates :id, :presence => { :on => check_on }
@@ -143,83 +91,184 @@ module Braspag
       when Braspag::INTEREST[:no],
            Braspag::INTEREST[:no_iata]
         true
+      else
+        false
       end
     end
     
-    def convert_to(method)
-      data = {}
-      data = self.send("to_#{method}") if self.respond_to?("to_#{method}")
-      data.merge!(self.customer.convert_to(method)) if self.customer
-      data
+    def payment_method_type?
+      Converter.payment_method_type?(self.payment_method)
     end
     
-    def to_authorize
-      {
-        :order_id        => self.id.to_s,
-        :amount          => self.amount,
-        :payment_method  => self.payment_method,
-        :number_payments => self.installments,
-        :type            => self.installments_type,
-      }
+    def build_customer
+      self.customer = Customer.new
+    end
+
+    def build_billet
+      self.billet = Billet.new
     end
     
-    def to_capture
+    def build_credit_card
+      self.credit_card = CreditCard.new
+    end
+
+    def self.to_info(connection, order)
       {
-        :order_id        => self.id.to_s
+        "loja"          => connection.merchant_id,
+        "numeroPedido"  => order.id.to_s
       }
     end
     
-    def to_void
-      {
-        :order_id        => self.id.to_s
-      }
+    def self.from_info(connection, order, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+        :authorization => "CodigoAutorizacao",
+        :error_code => "CodigoErro",
+        :error_message => "MensagemErro",
+        :payment_method => "CodigoPagamento",
+        :payment_method_name => "FormaPagamento",
+        :installments => "NumeroParcelas",
+        :status => "Status",
+        :amount => "Valor",
+        :cancelled_at => Proc.new { |document|
+          begin
+            Time.parse(document.search("DataCancelamento").first.to_s)
+          rescue
+            nil
+          end
+        },
+        :paid_at => Proc.new { |document|
+          begin
+            Time.parse(document.search("DataPagamento").first.to_s)
+          rescue
+            nil
+          end
+        },
+        :order_date => Proc.new { |document|
+          begin
+            Time.parse(document.search("DataPedido").first.to_s)
+          rescue
+            nil
+          end
+        },
+        :transaction_id => "TransId",
+        :tid => "BraspagTid"
+      })
+      
+      order.authorization = response[:authorization]
+      order.payment_method_name = response[:payment_method_name]
+      order.payment_method = response[:payment_method]
+      order.installments = response[:installments]
+      order.status = response[:status]
+      order.amount = Braspag::Converter::string_to_decimal(response[:amount], :eua)
+      order.gateway_cancelled_at = response[:cancelled_at]
+      order.gateway_paid_at = response[:paid_at]
+      order.gateway_created_at = response[:order_date]
+      order.transaction_id = response[:transaction_id]
+      order.gateway_id = response[:tid]
+
+      response
     end
     
-    def to_generate_billet
+    def self.to_info_credit_card(connection, order)
       {
-        :order_id        => self.id.to_s,
-        :amount          => self.amount,
-        :payment_method  => self.payment_method
+        "loja"          => connection.merchant_id,
+        "numeroPedido"  => order.id.to_s
       }
     end
     
-    def populate!(method, response)
-      self.send("populate_#{method}!", response)
-    end
-    
-    def populate_authorize!(response)
-      self.gateway_authorization = response[:number]
-      self.gateway_id = response[:transaction_id]
-      self.gateway_return_code = response[:return_code]
-      self.gateway_status = response[:status]
-      self.gateway_message = response[:message]
-      self.gateway_amount = Converter::string_to_decimal(response[:amount])
-    end
+    def self.from_info_credit_card(connection, order, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+          :checking_number => "NumeroComprovante",
+          :certified => "Autenticada",
+          :autorization_number => "NumeroAutorizacao",
+          :card_number => "NumeroCartao",
+          :transaction_number => "NumeroTransacao",
 
-    def populate_capture!(response)
-      #TODO: CHECK IF IS NECESSARY
-      # self.gateway_capture_id = response[:transaction_id]
-      self.gateway_capture_return_code = response[:return_code]
-      self.gateway_capture_status = response[:status]
-      self.gateway_capture_message = response[:message]
-      self.gateway_capture_amount = Converter::string_to_decimal(response[:amount])
+          :avs_response => "RetornoAVS",
+          :issuing => "Emissor",
+          :authenticated_number => "NumeroAutenticacao"
+      })
+      
+      order.build_credit_card if order.credit_card.nil?
+      
+      order.credit_card.checking_number = response[:checking_number]
+      order.credit_card.avs = response[:certified]
+      order.credit_card.autorization_number = response[:autorization_number]
+      order.credit_card.number = response[:card_number]
+      order.credit_card.transaction_number = response[:transaction_number]
+      order.credit_card.avs_response = response[:avs_response]
+      order.credit_card.issuing = response[:issuing]
+      order.credit_card.authenticated_number = response[:authenticated_number]
+      
+      response
     end
     
-    def populate_void!(response)
-      #TODO: CHECK IF IS NECESSARY
-      # self.gateway_void_id = response[:transaction_id]
-      self.gateway_void_return_code = response[:return_code]
-      self.gateway_void_status = response[:status]
-      self.gateway_void_message = response[:message]
-      self.gateway_void_amount = Converter::string_to_decimal(response[:amount])
+    def self.to_info_billet(connection, order)
+      {
+        "loja"          => connection.merchant_id,
+        "numeroPedido"  => order.id.to_s
+      }
     end
     
-    def populate_generate_billet!(response)
-      self.gateway_return_code = response[:return_code]
-      self.gateway_status = response[:status]
-      self.gateway_amount = BigDecimal.new(response[:amount].to_s) if response[:amount]
-    end
+    def self.from_info_billet(connection, order, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+          :document_number => "NumeroDocumento",
+          :payer => "Sacado",
+          :our_number => "NossoNumero",
+          :bill_line => "LinhaDigitavel",
+          :document_date => Proc.new { |document|
+            begin
+              Date.parse(document.search("DataDocumento").first.to_s)
+            rescue
+              nil
+            end
+          },
+          :expiration_date => Proc.new { |document|
+            begin
+              Date.parse(document.search("DataVencimento").first.to_s)
+            rescue
+              nil
+            end
+          },
+          :receiver => "Cedente",
+          :bank => "Banco",
+          :agency => "Agencia",
+          :account => "Conta",
+          :wallet => "Carteira",
+          :amount => "ValorDocumento",
+          :amount_invoice => "ValorPago",
+          :invoice_date => Proc.new { |document|
+            begin
+              Date.parse(document.search("DataCredito").first.to_s)
+            rescue
+              nil
+            end
+          }
+      })
+      
+      order.build_customer if order.customer.nil?
+      order.customer.name = response[:payer]
+
+      order.build_billet if order.billet.nil?
+      order.billet.id = response[:our_number]
+      order.billet.code = response[:bill_line]
+      
+      order.billet.created_at = response[:document_date]
+      order.billet.due_date_on = response[:expiration_date]
+      
+      order.billet.receiver = response[:receiver]
+      
+      order.billet.bank = response[:bank]
+      order.billet.agency = response[:agency]
+      order.billet.account = response[:account]
+      order.billet.wallet = response[:wallet]
+      order.billet.amount = Braspag::Converter::string_to_decimal(response[:amount])
+      order.billet.amount_paid = Braspag::Converter::string_to_decimal(response[:amount_invoice])
+      order.billet.paid_at = response[:invoice_date]
     
+      response
+    end
+  
     private
     def payment_for_cielo?
       case payment_method
@@ -232,5 +281,6 @@ module Braspag
         true
       end
     end
+    
   end
 end