libwebpayplus 2.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f5b3c05fcd844b62833e828d532b6ca33b48603a
+  data.tar.gz: e19679ebc32bf2c23cfbf25e63bce630168101a8
+SHA512:
+  metadata.gz: 3367776fc5f8c2fafedb5a3955b28a79668c95554a572e82cf739fe4ee174add12e0a04410d615d26deb57d0c7f59e67b866a0e95c0775084f9e9805ea1efe51
+  data.tar.gz: 5c078ed9e0c520f654af85ca78dddf446823f06db3da55a21b07c83c7570e10b70cc01d2d86fd6c6bf3dd9ae81b22ade7a7edb862692977449cae1061f05d0a8

data/lib/configuration.rb

@@ -0,0 +1,18 @@
+
+
+class Configuration
+
+@environment
+@commerce_code
+@private_key
+@public_cert
+@webpay_cert
+@store_codes
+
+
+  #getter y setter de los elementos
+  attr_accessor :environment,:commerce_code,:private_key,:public_cert,:webpay_cert,:store_codes
+
+end
+
+

data/lib/libwebpay.rb

@@ -0,0 +1,29 @@
+require 'signer'
+require 'savon'
+require_relative 'verifier'
+require_relative 'configuration'
+require_relative 'webpay'
+
+
+class Libwebpay
+
+	
+  @configuration
+  @webpay
+  
+	
+	def getWebpay(config)
+      if @webpay == nil
+        @webpay = Webpay.new(config)
+      end
+      return @webpay
+    end
+	
+	def getConfiguration
+      if @configuration == nil
+        @configuration = Configuration.new
+      end
+      return @configuration
+    end
+
+end

data/lib/utils.rb

@@ -0,0 +1,42 @@
+require 'signer'
+require 'savon'
+require_relative "verifier"
+
+class Util
+
+  def ejemplo
+    return true
+  end
+
+  def signXml (input_xml)
+
+    document = Nokogiri::XML(input_xml.body)
+    envelope = document.at_xpath("//env:Envelope")
+    envelope.prepend_child("<env:Header><wsse:Security xmlns:wsse='http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd' wsse:mustUnderstand='1'/></env:Header>")
+    xml = document.to_s
+
+    signer = Signer.new(xml)
+
+    signer.cert = OpenSSL::X509::Certificate.new(@public_cert)
+    signer.private_key = OpenSSL::PKey::RSA.new(@private_key)
+
+    signer.document.xpath("//soapenv:Body", { "soapenv" => "http://schemas.xmlsoap.org/soap/envelope/" }).each do |node|
+      signer.digest!(node)
+    end
+
+    signer.sign!(:issuer_serial => true)
+    signed_xml = signer.to_xml
+
+    document = Nokogiri::XML(signed_xml)
+    x509data = document.at_xpath("//*[local-name()='X509Data']")
+    new_data = x509data.clone()
+    new_data.set_attribute("xmlns:ds", "http://www.w3.org/2000/09/xmldsig#")
+
+    n = Nokogiri::XML::Node.new('wsse:SecurityTokenReference', document)
+    n.add_child(new_data)
+    x509data.add_next_sibling(n)
+
+    return document
+  end
+
+end

data/lib/verifier.rb

@@ -0,0 +1,60 @@
+require "nokogiri"
+require "base64"
+require "digest/sha1"
+require "openssl"
+
+class Verifier
+ 
+  def self.verify(document, cert)    
+    document = Nokogiri::XML(document.to_s, &:noblanks)
+    signed_info_node = document.at_xpath("/soap:Envelope/soap:Header/wsse:Security/ds:Signature/ds:SignedInfo",  {ds: 'http://www.w3.org/2000/09/xmldsig#', wsse: "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd", soap:"http://schemas.xmlsoap.org/soap/envelope/"})
+
+
+    #revisar que digest coincida
+    if !check_digest(document, signed_info_node)       
+       return false
+    end 
+
+    if !check_signature(document, signed_info_node, cert)       
+       return false
+    end 
+
+    
+    true
+  end
+
+  protected
+
+  def self.check_digest(doc, signed_info_node)
+      signed_info_node.xpath("//ds:Reference", ds: 'http://www.w3.org/2000/09/xmldsig#').each do |node| 
+        if !process_ref_node(doc, node)
+            return false
+        end
+      end
+      true
+  end    
+
+  def self.check_signature(doc, signed_info_node, cert)
+    signed_info_canon = canonicalize(signed_info_node, ['soap'])
+    signature = doc.at_xpath('//wsse:Security/ds:Signature/ds:SignatureValue', {ds: 'http://www.w3.org/2000/09/xmldsig#', wsse: "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd"}).text
+    cert.public_key.verify(OpenSSL::Digest::SHA1.new, Base64.decode64(signature), signed_info_canon)
+  end
+
+  def self.digest(message)
+    OpenSSL::Digest::SHA1.new.reset.digest(message)
+  end
+
+  def self.process_ref_node(doc, node)
+        uri = node.attr('URI')
+        element = doc.at_xpath("//*[@wsu:Id='" + uri[1..-1] + "']", wsu: "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd")
+        target = canonicalize(element, nil)
+        my_digest_value = Base64.encode64(digest(target)).strip
+        digest_value = node.at_xpath("//ds:DigestValue", ds: 'http://www.w3.org/2000/09/xmldsig#').text
+        return my_digest_value == digest_value
+  end
+
+  def self.canonicalize(node = document, inclusive_namespaces=nil)
+    node.canonicalize(Nokogiri::XML::XML_C14N_EXCLUSIVE_1_0, inclusive_namespaces, nil) # The last argument should be exactly +nil+ to remove comments from result
+  end
+
+end

data/lib/webpay.rb

@@ -0,0 +1,69 @@
+
+require_relative 'webpaymallnormal'
+require_relative 'webpaynormal'
+require_relative 'webpaynullify'
+require_relative 'webpaycapture'
+require_relative 'webpayoneclick'
+require_relative 'webpaycomplete'
+
+class Webpay
+
+  @configuration
+  @webpayNormal
+  @webpayMallNormal
+  @webpayNullify
+  @webpayCapture
+  @webpayOneClick
+  @webpayCompleteTransaction
+
+
+    # método inicializar clase
+    def initialize(params)
+      @configuration = params
+    end
+
+    def getNormalTransaction
+      if @webpayNormal == nil
+        @webpayNormal = WebpayNormal.new(@configuration)
+      end
+      return @webpayNormal
+    end
+
+  def getMallNormalTransaction
+    if @webpayMallNormal == nil
+      @webpayMallNormal = WebpayMallNormal.new(@configuration)
+    end
+    return @webpayMallNormal
+  end
+
+  def getNullifyTransaction
+    if @webpayNullify == nil
+      @webpayNullify = WebpayNullify.new(@configuration)
+    end
+    return @webpayNullify
+  end
+
+  def getCaptureTransaction
+    if @webpayCapture == nil
+      @webpayCapture = WebpayCapture.new(@configuration)
+    end
+    return @webpayCapture
+  end
+
+  def getOneClickTransaction
+    if @webpayOneClick == nil
+      @webpayOneClick = WebpayOneClick.new(@configuration)
+    end
+    return @webpayOneClick
+  end
+
+  def getCompleteTransaction
+    if @webpayCompleteTransaction == nil
+      @webpayCompleteTransaction = WebpayComplete.new(@configuration)
+    end
+    return @webpayCompleteTransaction
+  end
+end
+
+
+

data/lib/webpaycapture.rb

@@ -0,0 +1,134 @@
+require 'signer'
+require 'savon'
+require_relative "verifier"
+
+
+      class WebpayCapture
+
+        def initialize(configuration)
+
+
+          @wsdl_path = ''
+          @ambient = configuration.environment
+
+          case @ambient
+            when 'INTEGRACION'
+              @wsdl_path='https://webpay3gint.transbank.cl/WSWebpayTransaction/cxf/WSCommerceIntegrationService?wsdl'
+            when 'CERTIFICACION'
+              @wsdl_path='https://webpay3gint.transbank.cl/WSWebpayTransaction/cxf/WSCommerceIntegrationService?wsdl'
+            when 'PRODUCCION'
+              @wsdl_path='https://webpay3g.transbank.cl/WSWebpayTransaction/cxf/WSCommerceIntegrationService?wsdl'
+            else
+              #Por defecto esta el ambiente de INTEGRACION
+              @wsdl_path='https://webpay3gint.transbank.cl/WSWebpayTransaction/cxf/WSCommerceIntegrationService?wsdl'
+          end
+
+          @commerce_code = configuration.commerce_code
+          @private_key = OpenSSL::PKey::RSA.new(configuration.private_key)
+          @public_cert = OpenSSL::X509::Certificate.new(configuration.public_cert)
+          @webpay_cert = OpenSSL::X509::Certificate.new(configuration.webpay_cert)
+          @client = Savon.client(wsdl: @wsdl_path)
+
+        end
+
+
+        #######################################################
+    def capture(authorizationCode, captureAmount, buyOrder)
+
+
+    captureInput ={
+        "captureInput" => {
+          "captureAmount" => captureAmount,
+          "buyOrder" => buyOrder,
+          "commerceId" => @commerce_code,
+          "authorizationCode" => authorizationCode
+        }
+    }
+
+
+    req = @client.build_request(:capture, message: captureInput)
+
+
+    #Firmar documento
+    document = sign_xml(req)
+    puts document
+
+    begin
+      response = @client.call(:capture) do
+        xml document.to_xml(:save_with => 0)
+      end
+    rescue Exception, RuntimeError => e
+      response_array ={
+          "error_desc" => "Ocurrio un error en la llamada a Webpay: "+e.message
+      }
+      return response_array
+    end
+
+    #Verificacion de certificado respuesta
+    tbk_cert = OpenSSL::X509::Certificate.new(@webpay_cert)
+
+    if !Verifier.verify(response, tbk_cert)
+      puts "El Certificado de respuesta es Invalido."
+      response_array ={
+          "error_desc" => 'El Certificado de respuesta es Invalido'
+      }
+      return response_array
+    else
+      puts "El Certificado de respuesta es Valido."
+    end
+
+
+    response_document = Nokogiri::HTML(response.to_s)
+    puts 'response capture: '
+    puts response_document
+
+    authorizationCode = response_document.xpath("//authorizationcode").text
+    authorizationDate = response_document.xpath("//authorizationdate").text
+    capturedAmount 		= response_document.xpath("//capturedamount").text
+    token 	          = response_document.xpath("//token").text
+
+    response_array ={
+        "authorizationCode" => authorizationCode.to_s,
+        "authorizationDate" => authorizationDate.to_s,
+        "capturedAmount" 		=> capturedAmount.to_s,
+        "token" 	          => token.to_s,
+        "error_desc"        => "TRX_OK"
+    }
+
+
+    return response_array
+  end
+
+
+  def sign_xml (input_xml)
+
+    document = Nokogiri::XML(input_xml.body)
+    envelope = document.at_xpath("//env:Envelope")
+    envelope.prepend_child("<env:Header><wsse:Security xmlns:wsse='http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd' wsse:mustUnderstand='1'/></env:Header>")
+    xml = document.to_s
+
+    signer = Signer.new(xml)
+
+    signer.cert = OpenSSL::X509::Certificate.new(@public_cert)
+    signer.private_key = OpenSSL::PKey::RSA.new(@private_key)
+
+    signer.document.xpath("//soapenv:Body", { "soapenv" => "http://schemas.xmlsoap.org/soap/envelope/" }).each do |node|
+      signer.digest!(node)
+    end
+
+    signer.sign!(:issuer_serial => true)
+    signed_xml = signer.to_xml
+
+    document = Nokogiri::XML(signed_xml)
+    x509data = document.at_xpath("//*[local-name()='X509Data']")
+    new_data = x509data.clone()
+    new_data.set_attribute("xmlns:ds", "http://www.w3.org/2000/09/xmldsig#")
+
+    n = Nokogiri::XML::Node.new('wsse:SecurityTokenReference', document)
+    n.add_child(new_data)
+    x509data.add_next_sibling(n)
+
+    return document
+  end
+
+end

data/lib/webpaycomplete.rb

@@ -0,0 +1,377 @@
+require 'signer'
+require 'savon'
+require_relative 'verifier'
+require_relative 'utils'
+
+
+class WebpayComplete
+
+  def initialize(configuration)
+
+
+    @wsdl_path = ''
+    @ambient = configuration.environment
+
+    case @ambient
+      when 'INTEGRACION'
+        @wsdl_path='https://webpay3gint.transbank.cl/WSWebpayTransaction/cxf/WSCompleteWebpayService?wsdl'
+      when 'CERTIFICACION'
+        @wsdl_path='https://webpay3gint.transbank.cl/WSWebpayTransaction/cxf/WSCompleteWebpayService?wsdl'
+      when 'PRODUCCION'
+        @wsdl_path='https://webpay3g.transbank.cl/WSWebpayTransaction/cxf/WSCompleteWebpayService?wsdl'
+      else
+        #Por defecto esta el ambiente de INTEGRACION
+        @wsdl_path='https://webpay3gint.transbank.cl/WSWebpayTransaction/cxf/WSCompleteWebpayService?wsd'
+    end
+
+    @commerce_code = configuration.commerce_code
+    @private_key = OpenSSL::PKey::RSA.new(configuration.private_key)
+    @public_cert = OpenSSL::X509::Certificate.new(configuration.public_cert)
+    @webpay_cert = OpenSSL::X509::Certificate.new(configuration.webpay_cert)
+    @client = Savon.client(wsdl: @wsdl_path)
+
+  end
+
+
+  #######################################################
+  def initComplete(amount, buyOrder, sessionId, cardExpirationDate, cvv, cardNumber)
+
+    inputComplete ={
+        "wsCompleteInitTransactionInput" => {
+            "transactionType" => 'TR_COMPLETA_WS',
+            "sessionId" => sessionId,
+            "transactionDetails" => {
+                "amount" => amount,
+                "buyOrder" => buyOrder,
+                "commerceCode" => @commerce_code,
+            },
+            "cardDetail" => {
+                "cardExpirationDate" => cardExpirationDate,
+                "cvv" => cvv,
+                "cardNumber" => cardNumber
+            }
+        }
+    }
+
+    req = @client.build_request(:init_complete_transaction, message: inputComplete)
+
+    #Firmar documento
+    document = sign_xml(req)
+    puts document
+
+    begin
+      puts "Iniciando initComplete..."
+      response = @client.call(:init_complete_transaction) do
+        xml document.to_xml(:save_with => 0)
+      end
+    rescue Exception, RuntimeError => e
+      puts "Ocurrio un error en la llamada a Webpay: "+e.message
+      response_array ={
+          "error_desc" => "Ocurrio un error en la llamada a Webpay: "+e.message
+      }
+      return response_array
+    end
+
+    #Verificacion de certificado respuesta
+    tbk_cert = OpenSSL::X509::Certificate.new(@webpay_cert)
+
+    if !Verifier.verify(response, tbk_cert)
+      response_array ={
+          "error_desc" => 'El Certificado de respuesta es Invalido'
+      }
+      return response_array
+    else
+      puts "El Certificado de respuesta es Valido."
+    end
+
+    token=''
+    response_document = Nokogiri::HTML(response.to_s)
+    response_document.xpath("//token").each do |token_value|
+      token = token_value.text
+    end
+    url=''
+    response_document.xpath("//urlwebpay").each do |url_value|
+      url = url_value.text
+    end
+
+    puts 'token: '+token
+    puts 'url: '+url
+
+    response_array ={
+        "token"      => token.to_s,
+        "error_desc" => 'TRX_OK'
+    }
+
+    return response_array
+  end
+
+
+  ##############################################
+  def queryShare(token, buyOrder, shareNumber)
+
+    inputQuery ={
+        "token" => token,
+        "buyOrder" => buyOrder,
+        "shareNumber" => shareNumber
+    }
+
+    #Preparacion firma
+    req = @client.build_request(:query_share, message: inputQuery)
+    #firmar la peticion
+    document = sign_xml(req)
+    #document = Util.signXml(req)
+
+
+    #Se realiza el getResult
+    begin
+      puts "Iniciando queryShare..."
+      response = @client.call(:query_share) do
+        xml document.to_xml(:save_with => 0)
+      end
+
+    rescue Exception, RuntimeError => e
+      puts "Ocurrio un error en la llamada a Webpay: "+e.message
+      response_array ={
+          "error_desc" => "Ocurrio un error en la llamada a Webpay: "+e.message
+      }
+      return response_array
+    end
+
+    #Se revisa que respuesta no sea nula.
+    if response
+      puts 'Respuesta finishInscription: '+ response.to_s
+    else
+      puts 'Webservice Webpay responde con null'
+      response_array ={
+          "error_desc" => 'Webservice Webpay responde con null'
+      }
+      return response_array
+    end
+
+    puts response
+
+    #Verificacion de certificado respuesta
+    tbk_cert = OpenSSL::X509::Certificate.new(@webpay_cert)
+
+    if !Verifier.verify(response, tbk_cert)
+      response_array ={
+          "error_desc" => 'El Certificado de respuesta es Invalido'
+      }
+      return response_array
+    else
+      puts "El Certificado de respuesta es Valido."
+    end
+
+
+    response_document = Nokogiri::HTML(response.to_s)
+    puts response_document.to_s
+
+    buyOrder 		  = response_document.xpath("//buyorder").text
+    queryId 			= response_document.xpath("//queryid").text
+    shareAmount 	= response_document.xpath("//shareamount").text
+    token		      = response_document.xpath("//token").text
+
+    response_array ={
+        "buyOrder" 		  => buyOrder.to_s,
+        "queryId" 			=> queryId.to_s,
+        "shareAmount" 	=> shareAmount.to_s,
+        "token" 	      => token.to_s,
+        "error_desc"    => 'TRX_OK'
+    }
+
+
+    return response_array
+  end
+
+
+  ##############################################
+  def authorize(token, buyOrder, gracePeriod, idQueryShare, deferredPeriodIndex)
+
+    input ={
+        "token" => token,
+        "paymentTypeList" => {
+        #    "wsCompletePaymentTypeInput" => {
+                "commerceCode" => @commerce_code,
+                "buyOrder" => buyOrder,
+                "gracePeriod" => gracePeriod,
+                "wsCompleteQueryShareInput" => {
+                    "idQueryShare" => idQueryShare,
+                    "deferredPeriodIndex" => deferredPeriodIndex
+                }
+          #  }
+       }
+    }
+
+    #Preparacion firma
+    req = @client.build_request(:authorize, message: input)
+    #firmar la peticion
+    document = sign_xml(req)
+    #document = Util.signXml(req)
+
+    #Se realiza el getResult
+    begin
+      puts "Iniciando authorize..."
+      puts document.to_s
+      response = @client.call(:authorize) do
+        xml document.to_xml(:save_with => 0)
+      end
+
+    rescue Exception, RuntimeError => e
+      puts "Ocurrio un error en la llamada a Webpay: "+e.message
+      response_array ={
+          "error_desc" => "Ocurrio un error en la llamada a Webpay: "+e.message
+      }
+      return response_array
+    end
+
+    #Se revisa que respuesta no sea nula.
+    if response
+      puts 'Respuesta authorize: '+ response.to_s
+    else
+      puts 'Webservice Webpay responde con null'
+      response_array ={
+          "error_desc" => 'Webservice Webpay responde con null'
+      }
+      return response_array
+    end
+
+    puts response
+
+    #Verificacion de certificado respuesta
+    tbk_cert = OpenSSL::X509::Certificate.new(@webpay_cert)
+
+    if !Verifier.verify(response, tbk_cert)
+      response_array ={
+          "error_desc" => 'El Certificado de respuesta es Invalido'
+      }
+      return response_array
+    else
+      puts "El Certificado de respuesta es Valido."
+    end
+
+
+    response_document = Nokogiri::HTML(response.to_s)
+    puts response_document.to_s
+
+    responseCode 		  = response_document.xpath("//responsecode").text
+    buyOrder 					= response_document.xpath("//buyorder")
+    sharesNumber 			= response_document.xpath("//sharesnumber").text
+    amount		        = response_document.xpath("//amount").text
+    commerceCode		  = response_document.xpath("//commercecode").text
+    authorizationCode = response_document.xpath("//authorizationcode").text
+    paymentTypeCode 	= response_document.xpath("//paymenttypecode").text
+    sessionId		      = response_document.xpath("//sessionid").text
+    transactionDate		= response_document.xpath("//transactiondate").text
+
+
+    response_array ={
+        "responseCode" 		  => responseCode.to_s,
+        "buyOrder" 					=> buyOrder.to_s,
+        "sharesNumber" 		  => sharesNumber.to_s,
+        "amount" 	          => amount.to_s,
+        "commerceCode" 		  => commerceCode.to_s,
+        "authorizationCode"	=> authorizationCode.to_s,
+        "paymentTypeCode" 	=> paymentTypeCode.to_s,
+        "sessionId" 	      => sessionId.to_s,
+        "transactionDate" 	=> transactionDate.to_s,
+        "error_desc"        => 'TRX_OK'
+    }
+
+    acknowledgeTransaction(token)
+
+    return response_array
+  end
+
+
+  ################################
+  def acknowledgeTransaction(token)
+    acknowledgeInput ={
+        "tokenInput" => token
+    }
+
+    #Preparacion firma
+    req = @client.build_request(:acknowledge_complete_transaction, message: acknowledgeInput)
+
+    #Se firma el body de la peticion
+    document = sign_xml(req)
+
+    #Se realiza el acknowledge_transaction
+    begin
+      puts "Iniciando acknowledge_transaction..."
+      response = @client.call(:acknowledge_complete_transaction, message: acknowledgeInput) do
+        xml document.to_xml(:save_with => 0)
+      end
+
+    rescue Exception, RuntimeError => e
+      puts "Ocurrio un error en la llamada a Webpay: "+e.message
+      response_array ={
+          "error_desc" => "Ocurrio un error en la llamada a Webpay: "+e.message
+      }
+      return response_array
+    end
+
+    #Se revisa que respuesta no sea nula.
+    if response
+      puts 'Respuesta acknowledge_transaction: '+ response.to_s
+    else
+      puts 'Webservice Webpay responde con null'
+      response_array ={
+          "error_desc" => 'Webservice Webpay responde con null'
+      }
+      return response_array
+    end
+
+    #Verificacion de certificado respuesta
+    tbk_cert = OpenSSL::X509::Certificate.new(@webpay_cert)
+
+    if !Verifier.verify(response, tbk_cert)
+      response_array ={
+          "error_desc" => 'El Certificado de respuesta es Invalido'
+      }
+      return response_array
+    else
+      puts "El Certificado de respuesta es Valido."
+    end
+
+    response_array ={
+        "error_desc"        => 'TRX_OK'
+    }
+
+    return response_array
+  end
+
+
+  def sign_xml (input_xml)
+
+    document = Nokogiri::XML(input_xml.body)
+    envelope = document.at_xpath("//env:Envelope")
+    envelope.prepend_child("<env:Header><wsse:Security xmlns:wsse='http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd' wsse:mustUnderstand='1'/></env:Header>")
+    xml = document.to_s
+
+    signer = Signer.new(xml)
+
+    signer.cert = OpenSSL::X509::Certificate.new(@public_cert)
+    signer.private_key = OpenSSL::PKey::RSA.new(@private_key)
+
+    signer.document.xpath("//soapenv:Body", { "soapenv" => "http://schemas.xmlsoap.org/soap/envelope/" }).each do |node|
+      signer.digest!(node)
+    end
+
+    signer.sign!(:issuer_serial => true)
+    signed_xml = signer.to_xml
+
+    document = Nokogiri::XML(signed_xml)
+    x509data = document.at_xpath("//*[local-name()='X509Data']")
+    new_data = x509data.clone()
+    new_data.set_attribute("xmlns:ds", "http://www.w3.org/2000/09/xmldsig#")
+
+    n = Nokogiri::XML::Node.new('wsse:SecurityTokenReference', document)
+    n.add_child(new_data)
+    x509data.add_next_sibling(n)
+
+    return document
+  end
+
+
+
+end