cbraspag 0.9.0

data/lib/cbraspag/payment/billet.rb

@@ -0,0 +1,58 @@
+require "bigdecimal"
+
+module Braspag
+  class Connection
+    def generate_billet(order, billet)
+      response = self.post(:generate_billet, order, billet)
+      
+      status = (response[:status] == "0")
+
+      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.kind_of?(Time) || value.kind_of?(Date)
+        )
+          record.errors.add attribute, "invalid date"
+        end
+      end
+    end
+    
+    attr_accessor :id, :instructions, :due_date_on, :url
+
+    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 convert_to(method)
+      self.send("to_#{method}")
+    end
+    
+    def to_generate_billet
+      {
+        :number => self.id.to_s,
+        :instructions => self.instructions.to_s,
+        :expiration_date => self.due_date_on.strftime("%d/%m/%y")
+      }
+    end
+    
+    def populate!(method, response)
+      self.send("populate_#{method}!", response)
+    end
+    
+    def populate_generate_billet!(response)
+      self.url = response[:url]
+    end
+  end
+end

data/lib/cbraspag/payment/credit_card.rb

@@ -0,0 +1,203 @@
+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")
+
+      Response.new(status,
+                   response[:message],
+                   response,
+                   :test => homologation?,
+                   :authorization => response[:number])
+    end
+
+    def capture(order)
+      response = self.post(:capture, order)
+      
+      status = (response[:status] == "0")
+      
+      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")
+      
+      Response.new(status,
+                   response[:message],
+                   response,
+                   :test => homologation?)
+    end
+
+    PROTECTED_CARD_MAPPING = {
+      :request_id => "RequestId",
+      :merchant_id => "MerchantKey",
+      :customer_name => "CustomerName",
+      :holder => "CardHolder",
+      :card_number => "CardNumber",
+      :expiration => "CardExpiration"
+    }
+
+    JUST_CLICK_MAPPING = {
+      :request_id => "RequestId",
+      :merchant_id => "MerchantKey",
+      :customer_name => "CustomerName",
+      :order_id => "OrderId",
+      :amount => "Amount",
+      :payment_method => "PaymentMethod",
+      :number_installments => "NumberInstallments",
+      :payment_type => "PaymentType",
+      :just_click_key => "JustClickKey",
+      :security_code => "SecurityCode"
+    }
+
+
+    # saves credit card in Braspag PCI Compliant
+    def archive(credit_card, customer, request_id)
+      return ::Response
+
+      self.check_protected_card_params(params)
+
+      data = { 'saveCreditCardRequestWS' => {} }
+
+      PROTECTED_CARD_MAPPING.each do |k, v|
+        data['saveCreditCardRequestWS'][v] = params[k] || ""
+      end
+
+
+     client = Savon::Client.new(self.save_protected_card_url)
+     response = client.request(:web, :save_credit_card) do
+       soap.body = data
+     end
+
+      response.to_hash[:save_credit_card_response][:save_credit_card_result]
+
+    end
+
+    # request the credit card info in Braspag PCI Compliant
+    def get_recurrency(credit_card)
+      return ::Response
+
+      raise InvalidJustClickKey unless valid_just_click_key?(just_click_key)
+
+      data = { 'getCreditCardRequestWS' => {:loja => connection.merchant_id, :justClickKey => just_click_key} }
+
+      request = ::HTTPI::Request.new(self.get_protected_card_url)
+      request.body = { 'getCreditCardRequestWS' => {:loja => connection.merchant_id, :justClickKey => just_click_key} }
+
+      response = ::HTTPI.post(request)
+
+      response = Utils::convert_to_map(response.body, {
+          :holder => "CardHolder",
+          :card_number => "CardNumber",
+          :expiration => "CardExpiration",
+          :masked_card_number => "MaskedCardNumber"
+        })
+
+      raise UnknownError if response[:card_number].nil?
+      response
+    end
+
+    def recurrency(order, credit_card, request_id)
+      return ::Response
+
+      self.check_just_click_shop_params(params)
+
+      order_id = params[:order_id]
+      raise InvalidOrderId unless self.valid_order_id?(order_id)
+
+      data = { 'justClickShopRequestWS' => {} }
+
+      JUST_CLICK_MAPPING.each do |k, v|
+        case k
+        when :payment_method
+          data['justClickShopRequestWS'][v] = Braspag::Connection.instance.homologation? ? PAYMENT_METHODS[:braspag] : PAYMENT_METHODS[params[:payment_method]]
+        else
+          data['justClickShopRequestWS'][v] = params[k] || ""
+        end
+      end
+
+      client = Savon::Client.new(self.just_click_shop_url)
+      response = client.request(:web, :just_click_shop) do
+        soap.body = data
+      end
+
+      response.to_hash[:just_click_shop_response][:just_click_shop_result]
+
+    end
+
+    
+  end
+  
+  
+  class CreditCard
+    include ::ActiveAttr::Model
+
+    attr_accessor :holder_name, :number, :month, :year, :verification_value, :alias, :id
+
+    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 convert_to(method)
+      self.send("to_#{method}")
+    end
+    
+    def to_authorize
+      year_normalize = year.to_s[-2, 2]
+      {
+        :holder          => self.holder_name.to_s,
+        :card_number     => self.number.to_s,
+        :expiration      => "#{self.month}/#{year_normalize}",
+        :security_code   => self.verification_value.to_s,
+      }
+    end
+    
+    def populate!(method, response)
+      
+    end
+  end
+end

data/lib/cbraspag/payment/eft.rb

@@ -0,0 +1,90 @@
+module Braspag
+  class Connection
+
+    MAPPING_EFT = {
+      :merchant_id => "Id_Loja",
+      :order_id => "VENDAID",
+      :customer_name => "nome",
+      :customer_id => "CPF",
+      :amount => "VALOR",
+      :payment_method => "CODPAGAMENTO",
+      :installments => "PARCELAS",
+      :has_interest => "TIPOPARCELADO"
+    }
+
+
+    def self.generate_eft(order, eft)
+      return ::Response.new
+      
+      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
+
+  end
+  
+  class EFT
+    include ::ActiveAttr::Model
+    
+    class CryptoValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        unless (
+          value.kind_of?(Braspag::Crypto::Webservice) ||
+          value.kind_of?(Braspag::Crypto::NoCrypto) ||
+          value.kind_of?(Braspag::Crypto::JarWebservice)
+        )
+          record.errors.add attribute, "invalid crypto"
+        end
+      end
+    end
+
+    attr_accessor :crypto
+    
+    validates :crypto, :presence => { :on => :generate }
+    validates :crypto, :crypto => { :on => :generate }
+
+  end
+  
+end

data/lib/cbraspag/version.rb

@@ -0,0 +1,3 @@
+module Braspag
+  VERSION = "0.9.0"
+end

data/spec/core/connection_spec.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Braspag::Connection do
+  let(:merchant_id) { "{12345678-1234-1234-1234-123456789000}" }
+  
+  it "should accept a valid merchant" do
+    expect {
+      Braspag::Connection.new(:merchant_id => merchant_id)
+    }.to_not raise_error(Braspag::Connection::InvalidMerchantId)
+  end
+  
+  it "should raise error with invalid merchant" do
+    expect {
+      Braspag::Connection.new(:merchant_id => "INVALID")
+    }.to raise_error(Braspag::Connection::InvalidMerchantId)
+  end
+  
+  [:homologation, :production].each do |env|
+    it "should accept #{env} environment" do
+      expect {
+        Braspag::Connection.new(:merchant_id => merchant_id, :environment => env)
+      }.to_not raise_error(Braspag::Connection::InvalidEnvironment)
+    end
+  end
+  
+  it "should raise error with invalid environment" do
+    expect {
+      Braspag::Connection.new(:merchant_id => merchant_id, :environment => :bla)
+    }.to raise_error(Braspag::Connection::InvalidEnvironment)
+  end
+  
+  describe  ".production?" do
+    it "should return true" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :production)
+      connection.production?.should be(true)
+    end
+    
+    it "should return false" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)
+      connection.production?.should be(false)
+    end
+  end
+  
+  describe  ".homologation?" do
+    it "should return true" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)
+      connection.homologation?.should be(true)
+    end
+    
+    it "should return false" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :production)
+      connection.homologation?.should be(false)
+    end
+  end
+  
+  describe ".url_for" do
+    let(:braspag_homologation_url) { "https://homologacao.pagador.com.br" }
+    let(:braspag_production_url) { "https://transaction.pagador.com.br" }
+    let(:braspag_homologation_protected_card_url) { "https://homologacao.braspag.com.br/services/testenvironment" }
+    let(:braspag_production_protected_card_url) { "https://cartaoprotegido.braspag.com.br/Services" }
+    
+    it "should return the correct credit card creation url when connection environment is homologation" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :homologation)
+      connection.url_for(:authorize).should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/Authorize"
+      connection.url_for(:capture).should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/Capture"
+      connection.url_for(:void).should == "#{braspag_homologation_url}/webservices/pagador/Pagador.asmx/VoidTransaction"
+      connection.url_for(:generate_billet).should == "#{braspag_homologation_url}/webservices/pagador/Boleto.asmx/CreateBoleto"
+      connection.url_for(:generate_eft).should == "#{braspag_homologation_url}/pagador/passthru.asp"
+      connection.url_for(:info_billet).should == "#{braspag_homologation_url}/pagador/webservice/pedido.asmx/GetDadosBoleto"
+      connection.url_for(:info_card).should == "#{braspag_homologation_url}/pagador/webservice/pedido.asmx/GetDadosCartao"
+      connection.url_for(:info).should == "#{braspag_homologation_url}/pagador/webservice/pedido.asmx/GetDadosPedido"
+      connection.url_for(:encrypt).should == "#{braspag_homologation_url}/BraspagGeneralService/BraspagGeneralService.asmx"
+      connection.url_for(:archive_card).should == "#{braspag_homologation_protected_card_url}/CartaoProtegido.asmx?wsdl"
+      connection.url_for(:get_card).should == "#{braspag_homologation_protected_card_url}/CartaoProtegido.asmx/GetCreditCard"
+      connection.url_for(:recurrency).should == "#{braspag_homologation_protected_card_url}/CartaoProtegido.asmx?wsdl"
+    end
+
+    it "should return the correct credit card creation url when connection environment is production" do
+      connection = Braspag::Connection.new(:merchant_id => merchant_id, :environment => :production)
+      connection.url_for(:authorize).should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/Authorize"
+      connection.url_for(:capture).should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/Capture"
+      connection.url_for(:void).should == "#{braspag_production_url}/webservices/pagador/Pagador.asmx/VoidTransaction"
+      connection.url_for(:generate_billet).should == "#{braspag_production_url}/webservices/pagador/Boleto.asmx/CreateBoleto"
+      connection.url_for(:generate_eft).should == "#{braspag_production_url}/pagador/passthru.asp"
+      connection.url_for(:info_billet).should == "#{braspag_production_url}/webservices/pagador/pedido.asmx/GetDadosBoleto"
+      connection.url_for(:info_card).should == "#{braspag_production_url}/webservices/pagador/pedido.asmx/GetDadosCartao"
+      connection.url_for(:info).should == "#{braspag_production_url}/webservices/pagador/pedido.asmx/GetDadosPedido"
+      connection.url_for(:encrypt).should == "#{braspag_production_url}/BraspagGeneralService/BraspagGeneralService.asmx"
+      connection.url_for(:archive_card).should == "#{braspag_production_protected_card_url}/CartaoProtegido.asmx?wsdl"
+      connection.url_for(:get_card).should == "#{braspag_production_protected_card_url}/CartaoProtegido.asmx/GetCreditCard"
+      connection.url_for(:recurrency).should == "#{braspag_production_protected_card_url}/CartaoProtegido.asmx?wsdl"
+    end
+  end
+end