locomotiva-braspag 0.1.6

data/lib/locomotiva-braspag/credit_card.rb

@@ -0,0 +1,210 @@
+module Braspag
+  class CreditCard < PaymentMethod
+
+    MAPPING = {
+      :merchant_id => "merchantId",
+      :order => 'order',
+      :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"
+    }
+
+    AUTHORIZE_URI = "/webservices/pagador/Pagador.asmx/Authorize"
+    CAPTURE_URI = "/webservices/pagador/Pagador.asmx/Capture"
+    PARTIAL_CAPTURE_URI = "/webservices/pagador/Pagador.asmx/CapturePartial"
+    CANCELLATION_URI = "/webservices/pagador/Pagador.asmx/VoidTransaction"
+    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
+
+      self.check_params(params)
+
+      data = {}
+      MAPPING.each do |k, v|
+        case k
+        when :payment_method
+          data[v] = Braspag::Connection.instance.homologation? ? PAYMENT_METHODS[:braspag] : PAYMENT_METHODS[params[:payment_method]]
+        when :amount
+          data[v] = Utils.convert_decimal_to_string(params[:amount])
+        else
+          data[v] = params[k] || ""
+        end
+      end
+
+      response = Braspag::Poster.new(self.authorize_url).do_post(:authorize, data)
+
+      Utils::convert_to_map(response.body, {
+          :amount => nil,
+          :number => "authorisationNumber",
+          :message => 'message',
+          :return_code => 'returnCode',
+          :status => 'status',
+          :transaction_id => "transactionId"
+        })
+    end
+
+    def self.capture(order_id)
+      connection = Braspag::Connection.instance
+      merchant_id = connection.merchant_id
+
+      raise InvalidOrderId unless self.valid_order_id?(order_id)
+
+      data = {
+        MAPPING[:order_id] => order_id,
+        MAPPING[:merchant_id] => merchant_id
+      }
+
+      response = Braspag::Poster.new(self.capture_url).do_post(:capture, data)
+
+      Utils::convert_to_map(response.body, {
+          :amount => nil,
+          :number => "authorisationNumber",
+          :message => 'message',
+          :return_code => 'returnCode',
+          :status => 'status',
+          :transaction_id => "transactionId"
+        })
+    end
+
+    def self.partial_capture(order_id, amount)
+      connection = Braspag::Connection.instance
+      merchant_id = connection.merchant_id
+
+      raise InvalidOrderId unless self.valid_order_id?(order_id)
+
+      data = {
+        MAPPING[:order_id] => order_id,
+        MAPPING[:merchant_id] => merchant_id,
+        "captureAmount" => Utils.convert_decimal_to_string(amount)
+      }
+
+      response = Braspag::Poster.new(self.partial_capture_url).do_post(:partial_capture, data)
+
+      Utils::convert_to_map(response.body, {
+          :amount => nil,
+          :number => "authorisationNumber",
+          :message => 'message',
+          :return_code => 'returnCode',
+          :status => 'status',
+          :transaction_id => "transactionId"
+        })
+    end
+
+    def self.void(order_id)
+      connection = Braspag::Connection.instance
+      merchant_id = connection.merchant_id
+
+      raise InvalidOrderId unless self.valid_order_id?(order_id)
+
+      data = {
+        MAPPING[:order] => order_id,
+        MAPPING[:merchant_id] => merchant_id
+      }
+
+      response = Braspag::Poster.new(self.cancellation_url).do_post(:void, data)
+
+      Utils::convert_to_map(response.body, {
+          :amount => nil,
+          :number => "authorisationNumber",
+          :message => 'message',
+          :return_code => 'returnCode',
+          :status => 'status',
+          :transaction_id => "transactionId"
+        })
+    end
+
+    def self.info(order_id)
+      connection = Braspag::Connection.instance
+
+      raise InvalidOrderId unless self.valid_order_id?(order_id)
+
+      data = {:loja => connection.merchant_id, :numeroPedido => order_id.to_s}
+      response = Braspag::Poster.new(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
+    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,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
+
+    # <b>DEPRECATED:</b> Please use <tt>ProtectedCreditCard.save</tt> instead.
+    def self.save(params)
+      warn "[DEPRECATION] `CreditCard.save` is deprecated.  Please use `ProtectedCreditCard.save` instead."
+      ProtectedCreditCard.save(params)
+    end
+
+    # <b>DEPRECATED:</b> Please use <tt>ProtectedCreditCard.get</tt> instead.
+    def self.get(just_click_key)
+      warn "[DEPRECATION] `CreditCard.get` is deprecated.  Please use `ProtectedCreditCard.get` instead."
+      ProtectedCreditCard.get(just_click_key)
+    end
+
+    # <b>DEPRECATED:</b> Please use <tt>ProtectedCreditCard.just_click_shop</tt> instead.
+    def self.just_click_shop(params = {})
+      warn "[DEPRECATION] `CreditCard.just_click_shop` is deprecated.  Please use `ProtectedCreditCard.just_click_shop` instead."
+      ProtectedCreditCard.just_click_shop(params)
+    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
+
+    def self.partial_capture_url
+      Braspag::Connection.instance.braspag_url + PARTIAL_CAPTURE_URI
+    end
+
+    def self.cancellation_url
+      Braspag::Connection.instance.braspag_url + CANCELLATION_URI
+    end
+  end
+end

data/lib/locomotiva-braspag/crypto/jar_webservice.rb

@@ -0,0 +1,91 @@
+module Braspag
+  module Crypto
+    class JarWebservice
+      def self.encrypt(map)
+        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"
+        )
+
+        raise InvalidEncryptedKey if response["msg"] == "INVALID ENCRYPTED STRING"
+        raise InvalidCryptKey if response["msg"] == "INVALID KEY"
+
+        response["encrypt"]
+      end
+
+      def self.decrypt(encrypted, fields)
+        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,
+        	"encrypted" => encrypted,
+        	"fields" => fields
+        }.to_json
+
+        request.headers["Content-Type"] = "application/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"
+        )
+
+        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
+        end
+        map
+      end
+
+      protected
+      def self.encrypt_uri
+        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/locomotiva-braspag/crypto/webservice.rb

@@ -0,0 +1,100 @@
+module Braspag
+  module Crypto
+    class Webservice
+      def self.encrypt(map)
+        connection = Braspag::Connection.instance
+        raise Braspag::IncompleteParams if map.nil?
+        raise Braspag::IncompleteParams unless map.is_a?(Hash)
+
+        request = ::HTTPI::Request.new self.uri
+
+        fields = "\n"
+        map.each do |key, value|
+          fields.concat("        <tns:string>#{key}=#{value}</tns:string>\n")
+        end
+
+        request.body = <<-STRING
+<?xml version="1.0" encoding="utf-8"?>
+<env:Envelope xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+  <env:Header />
+  <env:Body>
+    <tns:EncryptRequest xmlns:tns="https://www.pagador.com.br/webservice/BraspagGeneralService">
+      <tns:merchantId>#{connection.merchant_id}</tns:merchantId>
+      <tns:request>
+        #{fields}
+      </tns:request>
+    </tns:EncryptRequest>
+  </env:Body>
+</env:Envelope>
+STRING
+
+        request.headers["Content-Type"] = "text/xml"
+
+        response = ::HTTPI.post request
+
+        document = Nokogiri::XML(response.body)
+
+        raise Braspag::UnknownError if document.children.empty?
+
+        #melhorar este parser cof cof
+        response = document.children.children.children.children.children.to_s
+
+        raise Braspag::InvalidMerchantId if (response == 'Erro BP 011' || response == 'Erro BP 012')
+        raise Braspag::InvalidIP if (response == 'Erro BP 067' || response == 'Erro BP 068')
+
+        response
+      end
+
+      def self.decrypt(encripted_text)
+        connection = Braspag::Connection.instance
+
+        raise Braspag::IncompleteParams if encripted_text.nil?
+        raise Braspag::IncompleteParams unless encripted_text.is_a?(String)
+
+        request = ::HTTPI::Request.new self.uri
+
+        request.body = <<-STRING
+<?xml version="1.0" encoding="utf-8"?>
+<env:Envelope xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+  <env:Header />
+  <env:Body>
+    <tns:DecryptRequest xmlns:tns="https://www.pagador.com.br/webservice/BraspagGeneralService">
+      <tns:merchantId>#{connection.merchant_id}</tns:merchantId>
+      <tns:cryptString>#{encripted_text}</tns:cryptString>
+    </tns:DecryptRequest>
+  </env:Body>
+</env:Envelope>
+STRING
+
+        request.headers["Content-Type"] = "text/xml"
+
+        response = ::HTTPI.post request
+
+        document = Nokogiri::XML(response.body)
+        raise Braspag::UnknownError if document.children.empty?
+
+        result_error = document.children.children.children.children.children.first.content.to_s
+
+        raise Braspag::InvalidMerchantId if (result_error == 'Erro BP 011' || result_error == 'Erro BP 012')
+        raise Braspag::InvalidIP if (result_error == 'Erro BP 067' || result_error == 'Erro BP 068')
+
+        self.convert_request_to_map document
+      end
+
+      protected
+      def self.uri
+        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|
+          values = n.content.to_s.split("=")
+          map[values[0].downcase.to_sym] = values[1]
+        end
+        map
+      end
+    end
+  end
+end

data/lib/locomotiva-braspag/eft.rb

@@ -0,0 +1,90 @@
+module Braspag
+  class Eft < PaymentMethod
+
+    PAYMENT_METHODS = {
+      :bradesco => 11,
+      :itau => 12,
+      :banco_do_brasil => 15,
+      :banco_real => 16,
+      :banrisul => 30,
+      :unibanco => 31
+    }
+
+    MAPPING = {
+      :merchant_id => "Id_Loja",
+      :order_id => "VENDAID",
+      :customer_name => "nome",
+      :customer_id => "CPF",
+      :amount => "VALOR",
+      :payment_method => "CODPAGAMENTO",
+      :installments => "PARCELAS",
+      :has_interest => "TIPOPARCELADO"
+    }
+
+    ACTION_URI = "/pagador/passthru.asp"
+
+    def self.generate(params, crypto_strategy = nil)
+      connection = Braspag::Connection.instance
+      params[:merchant_id] = connection.merchant_id
+
+      params = self.normalize_params(params)
+      self.check_params(params)
+
+      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
+          data[v] = params[k] || ""
+        end
+      end
+
+      html = "<form id=\"form_tef_#{params[:order_id]}\" name=\"form_tef_#{params[:order_id]}\" action=\"#{self.action_url}\" method=\"post\">"
+
+      if crypto_strategy.nil?
+        data.each do |key, value|
+          html << "<input type=\"text\" name=\"#{key}\" value=\"#{value}\" />"
+        end
+      else
+        data.delete("Id_Loja")
+        html << "<input type=\"text\" name=\"Id_Loja\" value=\"#{params[:merchant_id]}\" />"
+        html << "<input type=\"text\" name=\"crypt\" value=\"#{crypto_strategy.encrypt(data)}\" />"
+      end
+
+      html << "</form><script type=\"text/javascript\" charset=\"utf-8\">document.forms[\"form_tef_#{params[:order_id]}\"].submit();</script>"
+
+      html
+    end
+
+    def self.normalize_params(params)
+      params = super
+
+      params[:installments] = params[:installments].to_i unless params[:installments].nil?
+      params[:installments] ||= 1
+
+      params[:has_interest] = params[:has_interest] == true ? "1" : "0"
+
+      params
+    end
+
+    def self.check_params(params)
+      super
+
+      if params[:installments]
+        raise InvalidInstallments if params[:installments].to_i < 1 || params[:installments].to_i > 99
+      end
+
+      if params[:has_interest]
+        raise InvalidHasInterest if params[:has_interest] != "1" && params[:has_interest] != "0"
+      end
+    end
+
+    def self.action_url
+      Braspag::Connection.instance.braspag_url + ACTION_URI
+    end
+  end
+end