cbraspag 0.9.3 → 0.9.4

data/lib/cbraspag/payment/billet.rb

@@ -4,10 +4,9 @@ module Braspag
   class Connection
     def generate_billet(order, billet)
       response = self.post(:generate_billet, order, billet)
-      
       status = (response[:status] == "0")
 
-      Response.new(status,
+      ActiveMerchant::Billing::Response.new(status,
                    response[:message],
                    response,
                    :test => homologation?,
@@ -20,6 +19,7 @@ module Braspag
     
     class DueDateValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
+        # unless value.class.in? [Date, Time]
         unless (
           value.kind_of?(Time) || value.kind_of?(Date)
         )
@@ -28,31 +28,52 @@ module Braspag
       end
     end
     
-    attr_accessor :id, :instructions, :due_date_on, :url
+    attr_accessor :id, :instructions, :due_date_on, :url, :code, :created_at, :due_date_on
+    attr_accessor :receiver, :bank, :agency, :account, :wallet, :amount, :amount_paid, :paid_at
 
     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
+    def self.to_generate_billet(connection, order, billet)
       {
-        :number => self.id.to_s,
-        :instructions => self.instructions.to_s,
-        :expiration_date => self.due_date_on.strftime("%d/%m/%y")
+        "merchantId"       => connection.merchant_id,
+        "boletoNumber"     => billet.id.to_s,
+        "instructions"     => billet.instructions.to_s,
+        "expirationDate"   => billet.due_date_on.strftime("%d/%m/%y"),
+        "customerName"     => order.customer.name.to_s,
+        "customerIdNumber" => order.customer.document.to_s,
+        "emails"           => order.customer.email.to_s,
+        "orderId"          => order.id.to_s,
+        "amount"           => Braspag::Converter::decimal_to_string(order.amount),
+        "paymentMethod"    => order.payment_method
       }
     end
     
-    def populate!(method, response)
-      self.send("populate_#{method}!", response)
-    end
-    
-    def populate_generate_billet!(response)
-      self.url = response[:url]
+    def self.from_generate_billet(connection, order, billet, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+        :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
+      })
+      
+      order.gateway_return_code = response[:return_code]
+      order.gateway_status = response[:status]
+      order.gateway_amount = BigDecimal.new(response[:amount].to_s) if response[:amount]
+      billet.url = response[:url]
+      
+      response
     end
   end
 end

data/lib/cbraspag/payment/credit_card.rb

@@ -11,7 +11,7 @@ module Braspag
       
       status = (response[:status] == "0" || response[:status] == "1")
 
-      Response.new(status,
+      ActiveMerchant::Billing::Response.new(status,
                    response[:message],
                    response,
                    :test => homologation?,
@@ -23,7 +23,7 @@ module Braspag
       
       status = (response[:status] == "0")
       
-      Response.new(status,
+      ActiveMerchant::Billing::Response.new(status,
                    response[:message],
                    response,
                    :test => homologation?,
@@ -35,117 +35,19 @@ module Braspag
       
       status = (response[:status] == "0")
       
-      Response.new(status,
+      ActiveMerchant::Billing::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
+    attr_accessor :checking_number, :avs, :autorization_number, :transaction_number
+    attr_accessor :avs_response, :issuing, :authenticated_number
 
     class ExpiratorValidator < ActiveModel::EachValidator
       def validate_each(record, attribute, value)
@@ -181,23 +83,95 @@ module Braspag
     [:get_recurrency, :recurrency].each do |check_on|
       validates :id, :length => {:is => 36, :on => check_on}
     end
+        
+    def self.to_authorize(connection, order, credit_card)
+      year_normalize = credit_card.year.to_s[-2, 2]
+      {
+        "merchantId"     => connection.merchant_id,
+        "holder"         => credit_card.holder_name.to_s,
+        "cardNumber"     => credit_card.number.to_s,
+        "expiration"     => "#{credit_card.month}/#{year_normalize}",
+        "securityCode"   => credit_card.verification_value.to_s,
+        "customerName"   => order.customer.name.to_s,
+        "orderId"        => order.id.to_s,
+        "amount"         => Braspag::Converter::decimal_to_string(order.amount),
+        "paymentMethod"  => order.payment_method,
+        "numberPayments" => order.installments,
+        "typePayment"    => order.installments_type
+      }
+    end
     
-    def convert_to(method)
-      self.send("to_#{method}")
+    def self.from_authorize(connection, order, credit_card, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+              :amount         => nil,
+              :number         => "authorisationNumber",
+              :message        => nil,
+              :return_code    => 'returnCode',
+              :status         => nil,
+              :transaction_id => "transactionId"
+      })
+      
+      order.gateway_authorization = response[:number]
+      order.gateway_id = response[:transaction_id]
+      order.gateway_return_code = response[:return_code]
+      order.gateway_status = response[:status]
+      order.gateway_message = response[:message]
+      order.gateway_amount = Braspag::Converter::string_to_decimal(response[:amount])
+      
+      response
     end
     
-    def to_authorize
-      year_normalize = year.to_s[-2, 2]
+    def self.to_capture(connection, order)
       {
-        :holder          => self.holder_name.to_s,
-        :card_number     => self.number.to_s,
-        :expiration      => "#{self.month}/#{year_normalize}",
-        :security_code   => self.verification_value.to_s,
+        "merchantId"  => connection.merchant_id,
+        "orderId"     => order.id.to_s
       }
     end
     
-    def populate!(method, response)
+    def self.from_capture(connection, order, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+              :amount => nil,
+              :message => 'message',
+              :return_code => 'returnCode',
+              :status => 'status',
+              :transaction_id => "transactionId"
+      })
       
+      #TODO: CHECK IF IS NECESSARY
+      # order.gateway_capture_id = response[:transaction_id]
+      order.gateway_capture_return_code = response[:return_code]
+      order.gateway_capture_status = response[:status]
+      order.gateway_capture_message = response[:message]
+      order.gateway_capture_amount = Braspag::Converter::string_to_decimal(response[:amount])
+      
+      response
+    end
+    
+    def self.to_void(connection, order)
+      {
+        "merchantId" => connection.merchant_id,
+        "order"      => order.id.to_s
+      }
+    end
+    
+    def self.from_void(connection, order, params)
+      response = Braspag::Converter::hash_from_xml(params.body, {
+              :order_id => "orderId",
+              :amount => nil,
+              :message => 'message',
+              :return_code => 'returnCode',
+              :status => 'status',
+              :transaction_id => "transactionId"
+      })
+      
+      #TODO: CHECK IF IS NECESSARY
+      # order.gateway_void_id = response[:transaction_id]
+      order.gateway_void_return_code = response[:return_code]
+      order.gateway_void_status = response[:status]
+      order.gateway_void_message = response[:message]
+      order.gateway_void_amount = Braspag::Converter::string_to_decimal(response[:amount])
+      
+      response
     end
   end
 end

data/lib/cbraspag/payment/eft.rb

@@ -14,13 +14,9 @@ module Braspag
 
 
     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 = {}
 
@@ -51,18 +47,6 @@ module Braspag
 
       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

data/lib/cbraspag/payment/recurrency_credit_card.rb

@@ -0,0 +1,99 @@
+module Braspag
+  class Connection
+    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)
+
+      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)
+
+      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)
+
+      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
+end