pagarme 0.15 → 1.0

data/lib/pagarme/request.rb

@@ -1,7 +1,7 @@
 require 'uri'
 require 'rest_client'
 require 'multi_json'
-require File.join(File.dirname(__FILE__), '.', 'utils')
+require File.join(File.dirname(__FILE__), '.', 'util')
 require File.join(File.dirname(__FILE__), '.', 'errors')
 
 module PagarMe
@@ -16,16 +16,20 @@ module PagarMe
 	  self.headers = {}
 	end
 
+	def self.encode(params)
+	  Util.normalize_params(params).to_params
+	end
+
 	def run
 	  unless PagarMe.api_key
 		raise PagarMeError.new("You need to configure a API key before performing requests.")
 	  end
 
+	  self.headers = self.live ? { 'X-Live' => '1' } : {}
+
 	  parameters = self.parameters.merge({
-		:api_key => PagarMe.api_key,
-		:live => (self.live ? "1" : "0")
+		:api_key => PagarMe.api_key
 	  })
-
 	  error = nil
 
 	  begin
@@ -34,7 +38,7 @@ module PagarMe
 		  :url => PagarMe.full_api_url(self.path),
 		  :headers => self.headers,
 		  :open_timeout => 30,
-		  :payload => parameters.to_params,
+		  :payload => self.class.encode(parameters),
 		  :timeout => 90,
 		  :verify_ssl => false # TODO: change to verify SSL
 		})
@@ -47,17 +51,13 @@ module PagarMe
 		  raise
 		end
 	  rescue RestClient::ExceptionWithResponse => e
-		if e.http_code and e.http_body
-		  parsed_error = parse_json_response(e.http_body)
-		  if parsed_error['error']
-			error = "HTTP error #{e.http_code}: #{parsed_error['error']}"
-		  else
-			error = "Invalid response code (#{e.http_code})."
-		  end
+		parsed_error = parse_json_response(e.http_body)
+		if parsed_error['errors']
+		  error = parsed_error
+		  raise PagarMeError.initFromServerResponse(error)
 		else
-		  error = "Unexpected response code (#{e.message} - #{e.http_code})"
+		  raise PagarMeError.new(e.http_body)
 		end
-		raise ResponseError.new(error)
 	  rescue RestClient::Exception, Errno::ECONNREFUSED => e
 		error = "Error connecting to server: connection refused"
 	  end
@@ -73,7 +73,7 @@ module PagarMe
 	  begin
 		MultiJson.load(response)
 	  rescue MultiJson::LoadError => e
-		raise ResponseError.new("Server response is not a valid JSON.")
+		raise PagarMeError.new("Server response is not a valid JSON.")
 	  end
 	end
   end

data/lib/pagarme/subscription.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), '..', 'pagarme')
+
+module PagarMe
+  class Subscription < TransactionCommon
+
+	def to_hash
+	  {
+		:amount => self.amount,
+		:payment_method => self.payment_method,
+		:installments => self.installments,
+		:card_hash => (self.payment_method == 'credit_card' ? self.card_hash : nil),
+		:postback_url => self.postback_url,
+		:customer_email => self.customer_email,
+		:customer => (self.customer) ? self.customer.to_hash : nil,
+		:plan_id => (self.plan) ? self.plan.id : nil
+	  }
+	end
+
+	def create
+	  validation_error = self.card_hash ? nil : validate
+	  self.card_hash = generate_card_hash unless self.card_hash
+	  super
+	end
+
+	def charge(amount)
+	  request = PagarMe::Request.new(self.url, 'POST')
+	  request.parameters = {
+		:amount => amount,
+	  }
+	  response = request.run
+	  update(response)
+	end
+
+  end
+end

data/lib/pagarme/transaction.rb

@@ -2,169 +2,32 @@
 require 'openssl'
 require 'base64'
 require File.join(File.dirname(__FILE__), '..', 'pagarme')
-require File.join(File.dirname(__FILE__), '.', 'utils')
-require File.join(File.dirname(__FILE__), '.', 'errors')
 
 module PagarMe
-  class Transaction
-	attr_accessor :amount, :card_number, :card_holder_name, :card_expiracy_month, :card_expiracy_year, :card_cvv, :live, :card_hash, :installments, :card_last_digits
-
-	# initializers
-
-	def initialize(first_parameter = nil, server_response = nil)
-	  @statuses_codes = { :local => 0, :approved => 1, :processing => 2, :refused => 3, :chargebacked => 4 }
-	  @date_created = nil
-	  @id = nil
-	  self.status = :local
-	  self.live = PagarMe.live
-	  self.installments = 1
-
-	  self.card_number = self.card_holder_name = self.card_expiracy_month = self.card_expiracy_year = self.card_cvv = ""
-	  self.amount = 0
-
-	  # First parameter can be a hash with transaction parameters
-	  # or a encrypted card_hash that came from client.
-	  if first_parameter.class == String
-		self.card_hash = first_parameter
-	  elsif first_parameter.class == Hash
-		self.amount = first_parameter[:amount]
-		self.card_number = first_parameter[:card_number]
-		self.card_holder_name = first_parameter[:card_holder_name]
-		self.card_expiracy_month = first_parameter[:card_expiracy_month]
-		self.card_expiracy_year = first_parameter[:card_expiracy_year]
-		self.card_cvv = first_parameter[:card_cvv]
-		self.installments = first_parameter[:installments] if first_parameter[:installments]
-		self.live = first_parameter[:live]
-		self.live = PagarMe.live unless self.live
-	  end
-
-	  update_fields_from_response(server_response) if server_response
-	end
-
-	def self.find_by_id(id)
-	  request = PagarMe::Request.new("/transactions/#{id}", 'GET')
-	  response = request.run
-	  PagarMe::Transaction.new(nil, response)
-	end
-
-	def self.all(page = 1, count = 10)
-	  raise TransactionError.new("Invalid page count") if page < 1 or count < 1
-
-	  request = PagarMe::Request.new('/transactions', 'GET')
-	  request.parameters = {
-		:page => page,
-		:count => count
-	  }
-
-	  response = request.run
-	  response.map { |transaction_response| PagarMe::Transaction.new(nil, transaction_response) }
-	end
-
-	# getters
-
-	def status
-	  @statuses_codes.key(@status)
-	end
-
-	def date_created
-	  @date_created
-	end
-
-	def id
-	  @id
-	end
-
+  class Transaction < TransactionCommon
 	# server requests methods
 
-	def charge
-	  validation_error = self.card_hash ? nil : error_in_transaction
-	  raise TransactionError.new(validation_error) if validation_error
-	  raise TransactionError.new("Transaction already charged!") if self.status != :local
-
-	  request = PagarMe::Request.new('/transactions', 'POST', self.live)
-	  request.parameters = {
-		:amount => self.amount.to_s,
-		:installments => self.installments.to_i,
-		:card_hash => (self.card_hash ? self.card_hash : generate_card_hash)
+	def to_hash
+	  {
+		:amount => self.amount,
+		:payment_method => self.payment_method,
+		:installments => self.installments,
+		:card_hash => (self.payment_method == 'credit_card' ? self.card_hash : nil),
+		:postback_url => self[:postback_url],
+		:customer => (self.customer) ? self.customer.to_hash : nil
 	  }
-
-	  response = request.run
-	  update_fields_from_response(response)
-	end
-
-	def chargeback
-	  raise TransactionError.new("Transaction already chargebacked!") if self.status == :chargebacked
-	  raise TransactionError.new("Transaction needs to be approved to be chargebacked") if self.status != :approved
-
-	  request = PagarMe::Request.new("/transactions/#{self.id}", 'DELETE', self.live)
-	  response = request.run
-	  update_fields_from_response(response)
-	end
-
-
-	private
-
-
-	def status=(status)
-	  @status = @statuses_codes[status]
-	end
-
-	def update_fields_from_response(response)
-	  @status = @statuses_codes[response['status'].to_sym]
-	  @date_created = response['date_created']
-	  self.amount = response['amount']
-	  self.live = response['live']
-	  self.card_holder_name = response['costumer_name']
-	  self.installments = (!response['installments'] ? 1 : response['installments'].to_i)
-	  self.card_last_digits = response['card_last_digits']
-	  @id = response['id']
-	end
-
-	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
 
-	def error_in_transaction
-	  if self.card_number.length < 16 || self.card_number.length > 20 || !is_valid_credit_card(self.card_number)
-		"Número do cartão inválido."
-	  elsif self.card_holder_name.length == 0
-		"Nome do portador inválido."
-	  elsif self.card_expiracy_month.to_i <= 0 || self.card_expiracy_month.to_i > 12
-		"Mês de expiração inválido."
-	  elsif self.card_expiracy_year.to_i <= 0
-		"Ano de expiração inválido."
-	  elsif self.card_cvv.length < 3 || self.card_cvv.length > 4
-		"Código de segurança inválido."
-	  elsif self.amount.to_i <= 0
-		"Valor inválido."
-	  else
-		nil
-	  end
-	end
-
-	def card_data_parameters
-	  {
-		:card_number => self.card_number,
-		:card_holder_name => self.card_holder_name,
-		:card_expiracy_date => "#{self.card_expiracy_month}#{self.card_expiracy_year}",
-		:card_cvv => self.card_cvv
-	  }
+	def charge
+	  validation_error = self[:card_hash] ? nil : validate
+	  self.card_hash = generate_card_hash unless self[:card_hash]
+	  create
 	end
 
-	def generate_card_hash
-	  request = PagarMe::Request.new("/transactions/card_hash_key", 'GET', self.live)
+	def refund
+	  request = PagarMe::Request.new(self.url + '/refund', 'POST')
 	  response = request.run
-
-	  public_key = OpenSSL::PKey::RSA.new(response['public_key'])
-	  "#{response['id']}_#{Base64.strict_encode64(public_key.public_encrypt(card_data_parameters.to_params))}"
+	  update(response)
 	end
   end
 end

data/lib/pagarme/transaction_common.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+require File.join(File.dirname(__FILE__), '..', 'pagarme')
+
+module PagarMe
+  class TransactionCommon < Model
+
+	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
+
+	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
+
+	def validate
+	  error = PagarMeError.new
+	  if self.payment_method == 'credit_card'
+		if !self.card_number || self.card_number.to_s.length < 16 || 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
+
+	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
+
+	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
+
+	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
+  end
+end

data/lib/pagarme/util.rb

@@ -0,0 +1,75 @@
+module PagarMe
+  class Util
+    def self.pagarme_classes
+      return {
+      'transaction' => Transaction,
+      'plan' => Plan,
+      'customer' => Customer,
+      'subscription' => Subscription,
+      'address' => Address,
+      'phone' => Phone,
+      }
+    end
+
+    def self.convert_to_pagarme_object(response)
+      case response
+      when Array
+      response.map{ |i| convert_to_pagarme_object(i)}
+      when Hash
+      self.pagarme_classes.fetch(response['object'], PagarMeObject).build(response)
+      else
+      response
+      end
+    end
+
+    def self.url_encode(key)
+      URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+
+    def self.normalize_params(parameters, parent = nil)
+      ret = []
+      parameters.each do |k, v|
+        current_key = parent ? "#{parent}[#{url_encode(k)}]" : url_encode(k)
+        case v
+        when Hash
+          ret += normalize_params(v, current_key)
+        when Array
+          ret += normalize_array_params(v, current_key)
+        else
+          ret << [current_key, v]
+        end
+      end
+      ret
+    end
+
+    def self.normalize_array_params(value, current_key)
+      ret = []
+      value.each do |element|
+        case element
+        when Hash
+          ret += normalize_params(element, current_key)
+        when Array
+          ret += normalize_array_params(element, current_key)
+        else
+          ret << ["#{current_key}[]", element]
+        end
+      end
+      ret
+    end
+  end
+end
+
+class Hash
+  def to_params
+    self.map{ |key, value| "#{key}=#{value}" }.join('&')
+  end
+end
+
+class Array
+  def to_params
+    self.map{ |key, value| "#{key}=#{value}" }.join('&')
+  end
+end
+
+