rbraspag 0.0.19 → 0.1.0

data/.gitignore

@@ -5,4 +5,5 @@ tags
 *.swp
 .bundle
 .rvmrc
+Gemfile.lock
 

data/lib/rbraspag/bill.rb

@@ -27,67 +27,34 @@ module Braspag
       :emails => "emails"
     }
 
-    # (my face when I saw this method ---------> D:)
+    PRODUCTION_INFO_URI   = "/webservices/pagador/pedido.asmx/GetDadosBoleto"
+    HOMOLOGATION_INFO_URI = "/pagador/webservice/pedido.asmx/GetDadosBoleto"
+    CREATION_URI = "/webservices/pagador/Boleto.asmx/CreateBoleto"
+
     def self.generate(params)
       connection = Braspag::Connection.instance
-      params = params
       params[:merchant_id] = connection.merchant_id
 
-      if params[:expiration_date].is_a?(Date)
-        params[:expiration_date] = params[:expiration_date].strftime("%d/%m/%y")
-      end
-
-      if params[:amount] && !params[:amount].is_a?(BigDecimal)
-        params[:amount] = BigDecimal.new(params[:amount].to_s)
-      end
-
-      raise IncompleteParams if params[:order_id].nil? || params[:amount].nil? || params[:payment_method].nil?
-
-      raise InvalidOrderId unless params[:order_id].is_a?(String) || params[:order_id].is_a?(Fixnum)
-      raise InvalidOrderId unless (1..50).include?(params[:order_id].to_s.size)
+      params = self.normalize_params(params)
+      self.check_params(params)
 
-      unless params[:customer_name].nil?
-        raise InvalidCustomerName unless (1..255).include?(params[:customer_name].to_s.size)
-      end
-
-      unless params[:customer_id].nil?
-        raise InvalidCustomerId unless (11..18).include?(params[:customer_id].to_s.size)
-      end
-
-      unless params[:number].nil?
-        raise InvalidNumber unless (1..255).include?(params[:number].to_s.size)
-      end
+      data = {}
 
-      unless params[:instructions].nil?
-        raise InvalidInstructions unless (1..512).include?(params[:instructions].to_s.size)
-      end
-
-      unless params[:expiration_date].nil?
-        date_regexp = /(0[1-9]|1[0-9]|2[0-9]|3[01])\/(0[1-9]|1[012])\/\d\d/
-        raise InvalidExpirationDate unless params[:expiration_date].to_s =~ date_regexp
-      end
-
-      unless params[:payment_method].is_a?(Symbol) && PAYMENT_METHODS[params[:payment_method]]
-        raise InvalidPaymentMethod
-      end
-
-      data =  MAPPING.inject({}) do |memo, k|
-        if k[0] == :payment_method
-          memo[k[1]] = PAYMENT_METHODS[params[:payment_method]]
-        elsif k[0] == :amount
-          memo[k[1]] = Utils.convert_decimal_to_string(params[:amount])
+      MAPPING.each do |k, v|
+        case k
+        when :payment_method
+          data[v] = PAYMENT_METHODS[params[:payment_method]]
+        when :amount
+          data[v] = Utils.convert_decimal_to_string(params[:amount])
         else
-          memo[k[1]] = params[k[0]] || "";
+          data[v] = params[k] || ""
         end
-        
-        memo
       end
 
-      request = ::HTTPI::Request.new uri
+      request = ::HTTPI::Request.new(self.creation_url)
       request.body = data
 
-      response = ::HTTPI.post request
-      response = Utils::convert_to_map(response.body,
+      response = Utils::convert_to_map(::HTTPI.post(request).body,
         {
           :url => nil,
           :amount => nil,
@@ -104,9 +71,8 @@ module Braspag
           :message => nil
         })
 
-      
-      raise InvalidAmount if response[:message] == "Invalid purchase amount"
       raise InvalidMerchantId if response[:message] == "Invalid merchantId"
+      raise InvalidAmount if response[:message] == "Invalid purchase amount"
       raise InvalidPaymentMethod if response[:message] == "Invalid payment method"
       raise InvalidStringFormat if response[:message] == "Input string was not in a correct format."
       raise UnknownError if response[:status].nil?
@@ -116,17 +82,60 @@ module Braspag
       response
     end
 
+    def self.normalize_params(params)
+      params = super
+
+      if params[:expiration_date].respond_to?(:strftime)
+        params[:expiration_date] = params[:expiration_date].strftime("%d/%m/%y")
+      end
+
+      params
+    end
+
+    def self.check_params(params)
+      super
+
+      if params[:number]
+        raise InvalidNumber unless (1..255).include?(params[:number].to_s.size)
+      end
+
+      if params[:instructions]
+        raise InvalidInstructions unless (1..512).include?(params[:instructions].to_s.size)
+      end
+
+      if params[:expiration_date]
+        matches = params[:expiration_date].to_s.match /(\d{2})\/(\d{2})\/(\d{2})/
+        raise InvalidExpirationDate unless matches
+        begin
+          Date.new(matches[3].to_i, matches[2].to_i, matches[1].to_i)
+        rescue ArgumentError
+          raise InvalidExpirationDate
+        end
+      end
+    end
+
+    def self.info_url
+      connection = Braspag::Connection.instance
+      connection.braspag_url + (connection.production? ? PRODUCTION_INFO_URI : HOMOLOGATION_INFO_URI)
+    end
+
+    def self.creation_url
+      Braspag::Connection.instance.braspag_url + CREATION_URI
+    end
+
     def self.info(order_id)
       connection = Braspag::Connection.instance
 
-      raise InvalidOrderId unless order_id.is_a?(String) || order_id.is_a?(Fixnum)
-      raise InvalidOrderId unless (1..50).include?(order_id.to_s.size)
+      raise InvalidOrderId unless self.valid_order_id?(order_id)
 
-      request = ::HTTPI::Request.new("#{connection.braspag_query_url}/GetDadosBoleto")
-      request.body = {:loja => connection.merchant_id, :numeroPedido => order_id.to_s}
+      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",
@@ -147,12 +156,5 @@ module Braspag
       raise UnknownError if response[:document_number].nil?
       response
     end
-
-    protected
-
-    def self.uri
-      connection = Braspag::Connection.instance
-      "#{connection.braspag_url}/webservices/pagador/Boleto.asmx/CreateBoleto"
-    end
   end
 end

data/lib/rbraspag/connection.rb

@@ -2,17 +2,10 @@ module Braspag
   class Connection
     include Singleton
 
-    class InvalidMerchantId < Exception ; end
-    class InvalidEnv < Exception ; end
-    class InvalidBraspagUrl < Exception ; end
-
     PRODUCTION_URL = "https://transaction.pagador.com.br"
     HOMOLOGATION_URL = "https://homologacao.pagador.com.br"
 
-    PRODUCTION_QUERY_URL = "https://query.pagador.com.br/webservices/pagador/pedido.asmx"
-    HOMOLOGATION_QUERY_URL = "https://homologacao.pagador.com.br/pagador/webservice/pedido.asmx"
-
-    attr_reader :braspag_url, :braspag_query_url, :merchant_id, :crypto_url, :crypto_key, :options, :environment
+    attr_reader :braspag_url, :merchant_id, :crypto_url, :crypto_key, :options, :environment
 
     def initialize
       raise InvalidEnv if ENV["RACK_ENV"].nil? || ENV["RACK_ENV"].empty?
@@ -24,11 +17,9 @@ module Braspag
 
       @crypto_key  = @options["crypto_key"]
       @crypto_url  = @options["crypto_url"]
-
       @environment = @options["environment"] == 'production' ? 'production' : 'homologation'
 
-      @braspag_url       = self.production? ? PRODUCTION_URL : HOMOLOGATION_URL
-      @braspag_query_url = self.production? ? PRODUCTION_QUERY_URL : HOMOLOGATION_QUERY_URL
+      @braspag_url = self.production? ? PRODUCTION_URL : HOMOLOGATION_URL
     end
 
     def production?

data/lib/rbraspag/credit_card.rb

@@ -44,45 +44,33 @@ module Braspag
       :type => "typePayment",
     }
 
-    def self.uri_authorize
-      "#{Braspag::Connection.instance.braspag_url}/webservices/pagador/Pagador.asmx/Authorize"
-    end
+    AUTHORIZE_URI = "/webservices/pagador/Pagador.asmx/Authorize"
+    CAPTURE_URI = "/webservices/pagador/Pagador.asmx/Capture"
 
-    def self.uri_capture
-      "#{Braspag::Connection.instance.braspag_url}/webservices/pagador/Pagador.asmx/Capture"
-    end
+    PRODUCTION_INFO_URI   = "/webservices/pagador/pedido.asmx/GetDadosCartao"
+    HOMOLOGATION_INFO_URI = "/pagador/webservice/pedido.asmx/GetDadosCartao"
 
     def self.authorize(params = {})
       connection = Braspag::Connection.instance
       params[:merchant_id] = connection.merchant_id
 
-      [:order_id, :customer_name, :amount, :payment_method, :holder,
-        :card_number, :expiration, :security_code, :number_payments, :type].each do |param|
-        raise IncompleteParams unless params.include?(param)
-      end
-
-      raise InvalidOrderId unless (1..20).include?(params[:order_id].to_s.size)
-      raise InvalidCustomerName unless (1..100).include?(params[:customer_name].to_s.size)
-      raise InvalidAmount unless (1..10).include?(params[:amount].to_s.size)
-      raise InvalidHolder unless (1..100).include?(params[:holder].to_s.size)
-      raise InvalidExpirationDate unless (1..7).include?(params[:expiration].to_s.size)
-      raise InvalidSecurityCode unless (1..4).include?(params[:security_code].to_s.size)
-      raise InvalidNumberPayments unless (1..2).include?(params[:number_payments].to_s.size)
-      raise InvalidType unless (1..2).include?(params[:type].to_s.size)
-
-      params[:payment_method] = PAYMENT_METHODS[params[:payment_method]] if params[:payment_method].is_a?(Symbol)
+      self.check_params(params)
 
-      data =  MAPPING.inject({}) do |memo, k|
-        if k[0] == :amount
-          memo[k[1]] = Utils.convert_decimal_to_string(params[:amount])
+      data = {}
+      MAPPING.each do |k, v|
+        case k
+        when :payment_method
+          data[v] = PAYMENT_METHODS[params[:payment_method]]
+        when :amount
+          data[v] = Utils.convert_decimal_to_string(params[:amount])
         else
-          memo[k[1]] = params[k[0]] || "";
+          data[v] = params[k] || ""
         end
-        memo
       end
 
-      request = ::HTTPI::Request.new uri_authorize
+      request = ::HTTPI::Request.new self.authorize_url
       request.body = data
+
       response = ::HTTPI.post request
       Utils::convert_to_map(response.body, {
           :amount => nil,
@@ -98,14 +86,17 @@ module Braspag
       connection = Braspag::Connection.instance
       merchant_id = connection.merchant_id
 
-      raise InvalidOrderId unless (1..20).include?(order_id.to_s.size)
+      raise InvalidOrderId unless self.valid_order_id?(order_id)
 
-      data = {MAPPING[:order_id] => order_id, "merchantId" => merchant_id }
-      request = ::HTTPI::Request.new uri_capture
+      data = {
+        MAPPING[:order_id] => order_id,
+        MAPPING[:merchant_id] => merchant_id
+      }
 
+      request = ::HTTPI::Request.new(self.capture_url)
       request.body = data
-      response = ::HTTPI.post(request)
 
+      response = ::HTTPI.post(request)
       Utils::convert_to_map(response.body, {
           :amount => nil,
           :number => "authorisationNumber",
@@ -116,14 +107,12 @@ module Braspag
         })
     end
 
-
     def self.info(order_id)
       connection = Braspag::Connection.instance
 
-      raise InvalidOrderId unless order_id.is_a?(String) || order_id.is_a?(Fixnum)
-      raise InvalidOrderId unless (1..50).include?(order_id.to_s.size)
+      raise InvalidOrderId unless self.valid_order_id?(order_id)
 
-      request = ::HTTPI::Request.new("#{connection.braspag_query_url}/GetDadosCartao")
+      request = ::HTTPI::Request.new(self.info_url)
       request.body = {:loja => connection.merchant_id, :numeroPedido => order_id.to_s}
 
       response = ::HTTPI.post(request)
@@ -138,10 +127,44 @@ module Braspag
 
       raise UnknownError if response[:checking_number].nil?
       response
+    end
+
+    def self.check_params(params)
+      super
+
+      [:customer_name, :holder, :card_number, :expiration, :security_code, :number_payments, :type].each do |param|
+        raise IncompleteParams if params[param].nil?
+      end
+
+      raise InvalidHolder if params[:holder].to_s.size < 1 || params[:holder].to_s.size > 100
+
+      matches = params[:expiration].to_s.match /^(\d{2})\/(\d{2}|\d{4})$/
+      raise InvalidExpirationDate unless matches
+      begin
+        year = matches[2].to_i
+        year = "20#{year}" if year.size == 2
+
+        Date.new(year.to_i, matches[1].to_i)
+      rescue ArgumentError
+        raise InvalidExpirationDate
+      end
+
+      raise InvalidSecurityCode if params[:security_code].to_s.size < 1 || params[:security_code].to_s.size > 4
 
+      raise InvalidNumberPayments if params[:number_payments].to_i < 1 || params[:number_payments].to_i > 99
     end
 
+    def self.info_url
+      connection = Braspag::Connection.instance
+      connection.braspag_url + (connection.production? ? PRODUCTION_INFO_URI : HOMOLOGATION_INFO_URI)
+    end
+
+    def self.authorize_url
+      Braspag::Connection.instance.braspag_url + AUTHORIZE_URI
+    end
 
+    def self.capture_url
+      Braspag::Connection.instance.braspag_url + CAPTURE_URI
+    end
   end
 end
-

data/lib/rbraspag/crypto/jar_webservice.rb

@@ -5,31 +5,31 @@ module Braspag
         crypto_key = Braspag::Connection.instance.crypto_key
         raise Braspag::IncompleteParams if map.nil?
         raise Braspag::IncompleteParams unless map.is_a?(Hash)
-        
+
         request = ::HTTPI::Request.new encrypt_uri
-        
+
         data = {:key => crypto_key, :fields => map}
-                            
+
         request.headers["Content-Type"] = "application/json"
-        
+
         request.body = data.to_json
-        
+
         response = ::HTTPI.post request
-        
+
         begin
           response = JSON.parse(response.body)
         rescue Exception => e
           raise UnknownError
         end
-        
+
         raise IncompleteParams if (
-          response["msg"] == "INVALID FORMAT" || 
-          response["msg"] == "INVALID FIELDS" 
+          response["msg"] == "INVALID FORMAT" ||
+          response["msg"] == "INVALID FIELDS"
         )
-        
+
         raise InvalidEncryptedKey if response["msg"] == "INVALID ENCRYPTED STRING"
         raise InvalidCryptKey if response["msg"] == "INVALID KEY"
-        
+
         response["encrypt"]
       end
 
@@ -37,11 +37,11 @@ module Braspag
         crypto_key = Braspag::Connection.instance.crypto_key
         raise Braspag::InvalidEncryptedKey if encrypted.nil?
         raise Braspag::InvalidEncryptedKey unless encrypted.is_a?(String)
-        
+
         raise Braspag::IncompleteParams if fields.nil?
         raise Braspag::IncompleteParams unless fields.is_a?(Array)
-        
-        
+
+
         request = ::HTTPI::Request.new decrypt_uri
         request.body = {
         	"key" => crypto_key,
@@ -58,16 +58,16 @@ module Braspag
         rescue Exception => e
           raise UnknownError
         end
-        
+
         raise IncompleteParams if (
-          response["msg"] == "INVALID FORMAT" || 
-          response["msg"] == "INVALID FIELDS" 
+          response["msg"] == "INVALID FORMAT" ||
+          response["msg"] == "INVALID FIELDS"
         )
-        
+
         raise InvalidEncryptedKey if response["msg"] == "INVALID ENCRYPTED STRING"
 
         raise InvalidCryptKey if response["msg"] == "INVALID KEY"
-                
+
         map = {}
         response["fields"].each do |key,value|
           map[key.downcase.to_sym] = value
@@ -80,12 +80,12 @@ module Braspag
         connection_uri = Braspag::Connection.instance.crypto_url
         "#{connection_uri}/v1/encrypt.json"
       end
-      
+
       def self.decrypt_uri
         connection_uri = Braspag::Connection.instance.crypto_url
         "#{connection_uri}/v1/decrypt.json"
       end
-      
+
     end
   end
 end

data/lib/rbraspag/crypto/webservice.rb

@@ -86,7 +86,7 @@ STRING
         connection = Braspag::Connection.instance
         "#{connection.braspag_url}/BraspagGeneralService/BraspagGeneralService.asmx"
       end
-      
+
       def self.convert_request_to_map(document)
         map = {}
         document.children.children.children.children.children.each do |n|