Class: PagarMe::TransactionCommon

Inherits:
Model show all
Defined in:
lib/pagarme/transaction_common.rb

Direct Known Subclasses

Subscription, Transaction

Instance Method Summary collapse

Methods inherited from Model

all, class_name, find_by, find_by_id, #save, url, #url

Methods inherited from PagarMeObject

#[], #[]=, build, #each, #to_hash, #unsaved_values, #update

Constructor Details

#initialize(response = {}) ⇒ TransactionCommon

Returns a new instance of TransactionCommon.



7
8
9
10
11
12
13
 
# File 'lib/pagarme/transaction_common.rb', line 7

def initialize(response = {})
  super(response)
  self.payment_method = 'credit_card' unless self.payment_method
  self.installments = 1  unless self.installments
  self.status = 'local' unless self.status
  before_set_filter :amount, :format_amount
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class PagarMe::PagarMeObject

Instance Method Details

#card_data_parameters ⇒ Object 



80
81
82
83
84
85
86
87
 
# File 'lib/pagarme/transaction_common.rb', line 80

def card_data_parameters
  {
	:card_number => self.card_number,
	:card_holder_name => self.card_holder_name,
	:card_expiration_date => "#{self.card_expiration_month}#{self.card_expiration_year}",
	:card_cvv => self.card_cvv
  }
end

#create ⇒ Object 



15
16
17
18
19
20
 
# File 'lib/pagarme/transaction_common.rb', line 15

def create
  validation_error = self.card_hash ? nil : validate
  self.card_hash = generate_card_hash unless self.card_hash
  unset_creditcard_information
  super
end

#format_amount(amount) ⇒ Object 



70
71
72
73
74
75
76
77
78
 
# File 'lib/pagarme/transaction_common.rb', line 70

def format_amount(amount)
  if amount.kind_of?(String)
	value = amount.gsub(/\./, "")
	value = value.strip
	value = value.match(/\d+/)[0]
	amount = value
  end
  amount
end

#generate_card_hash ⇒ Object 



89
90
91
92
93
94
95
 
# File 'lib/pagarme/transaction_common.rb', line 89

def generate_card_hash
  request = PagarMe::Request.new("/transactions/card_hash_key", 'GET')
  response = request.run

  public_key = OpenSSL::PKey::RSA.new(response['public_key'])
  ret = "#{response['id']}_#{Base64.strict_encode64(public_key.public_encrypt(card_data_parameters.to_params))}"
end

#is_valid_credit_card(card) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/pagarme/transaction_common.rb', line 30

def is_valid_credit_card(card)
  s1 = s2 = 0
  card.to_s.reverse.chars.each_slice(2) do |odd, even| 
	s1 += odd.to_i

	double = even.to_i * 2
	double -= 9 if double >= 10
	s2 += double
  end
  (s1 + s2) % 10 == 0
end

#unset_creditcard_information ⇒ Object 



22
23
24
25
26
27
28
 
# File 'lib/pagarme/transaction_common.rb', line 22

def unset_creditcard_information
  self.card_number = nil
  self.card_holder_name = nil
  self.card_expiration_year = nil
  self.card_expiration_month = nil
  self.card_cvv = nil
end

#validate ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/pagarme/transaction_common.rb', line 42

def validate
  error = PagarMeError.new
  if self.payment_method == 'credit_card'
	if !self.card_number || self.card_number.to_s.length > 20 || !is_valid_credit_card(self.card_number.to_s)
	  error.errors << PagarMeError.new("Número do cartão inválido.", 'card_number')
	end
	if !self.card_holder_name || !self.card_holder_name || self.card_holder_name.length == 0
	  error.errors << PagarMeError.new("Nome do portador inválido.", 'card_holder_name')
	end
	if !self.card_expiration_month || self.card_expiration_month.to_i <= 0 || self.card_expiration_month.to_i > 12
	  error.errors << PagarMeError.new("Mês de expiração inválido.", 'card_expiration_date')
	end
	if !self.card_expiration_year || self.card_expiration_year.to_i <= 0
	  error.errors << PagarMeError.new("Ano de expiração inválido.", 'card_expiration_date')
	end
	if !self.card_cvv || self.card_cvv.to_s.length < 3 || self.card_cvv.to_s.length > 4
	  error.errors << PagarMeError.new("Código de segurança inválido.", 'card_cvv')
	end
  end
  if(error.errors.any?)
	error.message = error.errors.map {|e| e.message}
	error.message = error.message.join(',')
	raise error
  else
	nil
  end
end