pagseguro-oficial 2.3.0 → 2.4.0

data/lib/pagseguro/transaction/serializer.rb

@@ -20,12 +20,23 @@ module PagSeguro
         end
       end
 
+      def serialize_status_history
+        xml.css("status").map do |node|
+          PagSeguro::TransactionStatus.new(
+            code: node.css("code").text,
+            date: Time.parse(node.css("date").text),
+            notification_code: node.css("notificationCode").text
+          )
+        end
+      end
+
+      private
       def serialize_general(data)
-        data[:code] = xml.css("> code").text
+        data[:code] = xml.at_css("code").text
         data[:reference] = xml.css("reference").text
-        data[:type_id] = xml.css("> type").text
+        data[:type_id] = xml.at_css("type").text
         data[:payment_link] = xml.css("paymentLink").text
-        data[:status] = xml.css("> status").text
+        data[:status] = xml.at_css("status").text
 
         cancellation_source = xml.css("cancellationSource")
         data[:cancellation_source] = cancellation_source.text if cancellation_source.any?

data/lib/pagseguro/transaction/status_collection.rb

@@ -0,0 +1,20 @@
+module PagSeguro
+  class Transaction
+    class StatusCollection
+      extend Forwardable
+
+      def_delegators :@statuses, :each, :empty?, :any?
+
+      def statuses=(objects)
+        @statuses = objects
+      end
+
+      def errors
+        @errors ||= Errors.new
+      end
+
+      # PagSeguro::TransactionStatus instances.
+      attr_reader :statuses
+    end
+  end
+end

data/lib/pagseguro/transaction.rb

@@ -76,6 +76,17 @@ module PagSeguro
       load_from_response send_request("transactions/notifications/#{code}", options)
     end
 
+    # Find a transaction by status.
+    # Return a PagSeguro::Transaction::Colletion.
+    def self.find_status_history(code)
+      request = send_request("transactions/#{code}/statusHistory")
+      collection = StatusCollection.new
+      response = Response.new(request, collection)
+      response.serialize_statuses
+
+      collection
+    end
+
     # Search transactions within a date range.
     # Return a PagSeguro::SearchByDate instance
     #
@@ -171,6 +182,21 @@ module PagSeguro
       @status = ensure_type(PaymentStatus, status)
     end
 
+    # Set errors.
+    def errors
+      @errors ||= Errors.new
+    end
+
+    # Update all attributes
+    def update_attributes(attrs)
+      attrs.each { |name, value| send("#{name}=", value) }
+    end
+
+    # Serialize the XML object.
+    def self.load_from_xml(xml) # :nodoc:
+      new Serializer.new(xml).serialize
+    end
+
     private
     def self.api_version
       'v3'
@@ -180,24 +206,18 @@ module PagSeguro
       @errors = Errors.new
     end
 
-    #
     # Serialize the HTTP response into data.
-    def self.load_from_response(response) # :nodoc:
-      if response.success? and response.xml?
-        load_from_xml Nokogiri::XML(response.body).css("transaction").first
-      else
-        Response.new Errors.new(response)
-      end
-    end
+    def self.load_from_response(request) # :nodoc:
+      transaction = new
+      response = Response.new(request, transaction)
+      response.serialize
 
-    # Send a get request to v3 API version, with the path given
-    def self.send_request(path, options)
-      Request.get(path, 'v3', options)
+      transaction
     end
 
-    # Serialize the XML object.
-    def self.load_from_xml(xml) # :nodoc:
-      new Serializer.new(xml).serialize
+    # Send a get request to v3 API version, with the path given
+    def self.send_request(path, options = {})
+      Request.get(path, api_version, options)
     end
   end
 end

data/lib/pagseguro/transaction_cancellation/request_serializer.rb

@@ -0,0 +1,18 @@
+module PagSeguro
+  class TransactionCancellation
+    class RequestSerializer
+      # The transaction_cancellation that will be serialized.
+      attr_reader :transaction_cancellation
+
+      def initialize(transaction_cancellation)
+        @transaction_cancellation = transaction_cancellation
+      end
+
+      def to_params
+        {}.tap do |data|
+          data[:transactionCode] = transaction_cancellation.transaction_code
+        end.delete_if { |_, value| value.nil? }
+      end
+    end
+  end
+end

data/lib/pagseguro/transaction_cancellation/response.rb

@@ -0,0 +1,32 @@
+module PagSeguro
+  class TransactionCancellation
+    class Response
+      def initialize(response, cancellation)
+        @response = response
+        @cancellation = cancellation
+      end
+
+      def serialize
+        if success?
+          xml = Nokogiri::XML(response.body)
+          cancellation.update_attributes(ResponseSerializer.new(xml).serialize)
+        else
+          cancellation.errors.add(response)
+        end
+
+        cancellation
+      end
+
+      def success?
+        response.success? && response.xml?
+      end
+
+      private
+      # The request response.
+      attr_reader :response
+
+      # The PagSeguro::TransactionCancellation instance.
+      attr_reader :cancellation
+    end
+  end
+end

data/lib/pagseguro/transaction_cancellation/response_serializer.rb

@@ -0,0 +1,17 @@
+module PagSeguro
+  class TransactionCancellation
+    class ResponseSerializer
+      attr_reader :xml
+
+      def initialize(xml)
+        @xml = xml
+      end
+
+      def serialize
+        {}.tap do |data|
+          data[:result] = xml.css("> result").text
+        end
+      end
+    end
+  end
+end

data/lib/pagseguro/transaction_cancellation/serializer.rb

@@ -0,0 +1,18 @@
+module PagSeguro
+  class TransactionCancellation
+    class Serializer
+      # The refund that will be serialized.
+      attr_reader :refund
+
+      def initialize(refund)
+        @refund = refund
+      end
+
+      def to_params
+        {}.tap do |data|
+          data[:transactionCode] = refund.transaction_code
+        end
+      end
+    end
+  end
+end

data/lib/pagseguro/transaction_cancellation.rb

@@ -0,0 +1,40 @@
+module PagSeguro
+  class TransactionCancellation
+    include Extensions::MassAssignment
+
+    # Set the transaction code.
+    # The transaction status must be: Aguardando pagamento or Em análise.
+    attr_accessor :transaction_code
+
+    # Result from http request.
+    attr_accessor :result
+
+    # Calls the PagSeguro webservice and register the cancellation.
+    # Return boolean.
+    def register
+      request = Request.post("transactions/cancels", api_version, params)
+      response = Response.new(request, self)
+      response.serialize
+
+      response.success?
+    end
+
+    # Errors object.
+    def errors
+      @errors ||= Errors.new
+    end
+
+    def update_attributes(attrs)
+      attrs.each { |name, value| send("#{name}=", value) }
+    end
+
+    private
+    def api_version
+      "v2"
+    end
+
+    def params
+      RequestSerializer.new(self).to_params
+    end
+  end
+end

data/lib/pagseguro/transaction_status.rb

@@ -0,0 +1,14 @@
+module PagSeguro
+  class TransactionStatus
+    include Extensions::MassAssignment
+
+    # The transaction status code
+    attr_accessor :code
+
+    # The date of the status change
+    attr_accessor :date
+
+    # The code of the notification sent when the status changed
+    attr_accessor :notification_code
+  end
+end

data/lib/pagseguro/version.rb

@@ -1,3 +1,3 @@
 module PagSeguro
-  VERSION = "2.3.0"
+  VERSION = "2.4.0"
 end

data/lib/pagseguro.rb

@@ -50,6 +50,11 @@ require "pagseguro/payment_request/response"
 require "pagseguro/payment_status"
 require "pagseguro/permission"
 require "pagseguro/request"
+require "pagseguro/refund"
+require "pagseguro/refund/request_serializer"
+require "pagseguro/refund/response"
+require "pagseguro/refund/response_serializer"
+require "pagseguro/refund/serializer"
 require "pagseguro/sender"
 require "pagseguro/session"
 require "pagseguro/session/response"
@@ -58,8 +63,16 @@ require "pagseguro/notification"
 require "pagseguro/notification/authorization"
 require "pagseguro/notification/transaction"
 require "pagseguro/transaction"
+require "pagseguro/transaction_status"
 require "pagseguro/transaction/response"
 require "pagseguro/transaction/serializer"
+require "pagseguro/transaction/collection"
+require "pagseguro/transaction/status_collection"
+require "pagseguro/transaction_cancellation"
+require "pagseguro/transaction_cancellation/request_serializer"
+require "pagseguro/transaction_cancellation/response"
+require "pagseguro/transaction_cancellation/response_serializer"
+require "pagseguro/transaction_cancellation/serializer"
 require "pagseguro/transaction/search"
 require "pagseguro/transaction/search/search_by_date"
 require "pagseguro/transaction/search/search_by_reference"

data/spec/fixtures/refund/success.xml

@@ -0,0 +1,2 @@
+<?xml version=”1.0” encoding=”ISO-8859-1” standalone=”yes”?>
+<result>OK</result>

data/spec/fixtures/transaction_cancellation/success.xml

@@ -0,0 +1,2 @@
+<?xml version=”1.0” encoding=”ISO-8859-1” standalone=”yes”?>
+<result>OK</result>

data/spec/fixtures/transactions/status_history.xml

@@ -0,0 +1,12 @@
+<statusHistory>
+  <status>
+    <code>1</code>
+    <date>2015-02-24T10:23:34.000-03:00</date>
+    <notificationCode>B7C381-7AADE5ADE576-8CC4159F8FBB-25C7D6</notificationCode>
+  </status>
+  <status>
+    <code>3</code>
+    <date>2015-02-24T10:23:36.000-03:00</date>
+    <notificationCode>0EF4E7-1F96B496B41B-CFF4ABAFABF3-47CEF2</notificationCode>
+  </status>
+</statusHistory>

data/spec/pagseguro/refund/request_serializer_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe PagSeguro::Refund::RequestSerializer do
+  subject(:serializer) { PagSeguro::Refund::RequestSerializer.new(refund) }
+
+  let(:refund) do
+    PagSeguro::Refund.new transaction_code: "1234",
+      value: "100.50"
+  end
+
+  let(:params) { serializer.to_params }
+
+  it { expect(params).to include(transactionCode: "1234") }
+  it { expect(params).to include(refundValue: "100.50") }
+end

data/spec/pagseguro/refund/response_serializer_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe PagSeguro::Refund::ResponseSerializer do
+  context "for existing refund response" do
+    let(:source) { File.read("./spec/fixtures/refund/success.xml") }
+    let(:xml) { Nokogiri::XML(source) }
+    let(:serializer) { described_class.new(xml) }
+    subject(:data) { serializer.serialize }
+
+    it { expect(data).to include(result: "OK") }
+  end
+end

data/spec/pagseguro/refund/response_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+
+describe PagSeguro::Refund::Response do
+  let(:refund) do
+    PagSeguro::Refund.new
+  end
+
+  subject { PagSeguro::Refund::Response.new(http_response, refund) }
+
+  context '#success?' do
+    let(:http_response) do
+      double(:HttpResponse, xml?: true)
+    end
+
+    it 'delegate to response' do
+      allow(http_response).to receive(:success?).and_return(true)
+      expect(subject).to be_success
+
+      allow(http_response).to receive(:success?).and_return(false)
+      expect(subject).not_to be_success
+    end
+  end
+
+  context '#serialize' do
+    let(:http_response) do
+      double(:HttpResponse, body: raw_xml, success?: true, xml?: true, unauthorized?: false, bad_request?: false)
+    end
+
+    let(:raw_xml) { File.read("./spec/fixtures/refund/success.xml") }
+
+    it 'return refund instance' do
+      expect(subject.serialize).to eq refund
+    end
+
+    it 'change result' do
+      expect { subject.serialize }.to change { refund.result }
+    end
+  end
+end

data/spec/pagseguro/refund/serializer_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe PagSeguro::Refund::Serializer do
+  let(:refund) { PagSeguro::Refund.new }
+  let(:params) { serializer.to_params }
+  subject(:serializer) { described_class.new(refund) }
+
+  before do
+    refund.transaction_code = "1234"
+    refund.value = 100.50
+  end
+
+  it { expect(params).to include(transactionCode: "1234") }
+  it { expect(params).to include(refundValue: "100.50") }
+end

data/spec/pagseguro/refund_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+
+describe PagSeguro::Refund do
+  let(:xml_parsed) { Nokogiri::XML(raw_xml) }
+
+  it_assigns_attribute :transaction_code
+  it_assigns_attribute :value
+
+  it "errors must be a instante of PagSeguro::Errors" do
+    expect(subject.errors).to be_a(PagSeguro::Errors)
+  end
+
+  describe "#register" do
+    let(:refund) { PagSeguro::Refund.new }
+
+    context 'a correct response' do
+      before { FakeWeb.register_uri :any, %r[.*?], body: raw_xml }
+
+      let(:raw_xml) { File.read("./spec/fixtures/refund/success.xml") }
+
+      let :response_request do
+        double(:ResponseRequest, success?: true, unauthorized?: false, bad_request?: false, data: xml_parsed, body: raw_xml, :xml? => true)
+      end
+
+      it "performs request" do
+        expect(PagSeguro::Request).to receive(:post)
+          .with("transactions/refunds", "v2", {})
+          .and_return(response_request)
+
+        refund.register
+      end
+
+      it "returns a PagSeguro::Refund" do
+        expect(refund.register).to be_a(PagSeguro::Refund)
+      end
+    end
+
+    context "a failure response" do
+      before do
+        allow(PagSeguro::Request).to receive(:post)
+          .and_return(response_request)
+      end
+
+      let(:raw_xml) { File.read("./spec/fixtures/invalid_code.xml") }
+
+      let :response_request do
+        double(:ResponseRequest, success?: false, unauthorized?: false, not_found?: false, bad_request?: true, data: xml_parsed, body: raw_xml, :xml? => true)
+      end
+
+      it "returns a PagSeguro::Refund with errors" do
+        expect(refund.register.errors).not_to be_empty
+      end
+    end
+  end
+
+  it '#update_attributes' do
+    refund = PagSeguro::Refund.new
+
+    expect(refund).to receive(:result=).with("OK")
+
+    refund.update_attributes(result: "OK")
+  end
+end

data/spec/pagseguro/request_spec.rb

@@ -11,10 +11,6 @@ describe PagSeguro::Request do
   context "POST request" do
     before do
       FakeWeb.register_uri :post, %r[.+], body: "BODY"
-      PagSeguro.configure do |config|
-        config.app_id = nil
-        config.app_key = nil
-      end
     end
 
     it "includes credentials" do

data/spec/pagseguro/transaction/collection_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+describe PagSeguro::Transaction::Collection do
+  let(:transactions) { [PagSeguro::Transaction.new] }
+
+  it "should have a PagSeguro::Errors instance" do
+    expect(subject.errors).to be_a(PagSeguro::Errors)
+  end
+
+  context "when there are no transactions" do
+    before do
+      subject.transactions = []
+    end
+
+    it "is blank" do
+      expect(subject).to be_empty
+    end
+
+    it "doesn't have any transaction" do
+      expect(subject).not_to be_any
+    end
+  end
+
+  context "when there are transactions" do
+    before do
+      subject.transactions = transactions
+    end
+
+    it "is not blank" do
+      expect(subject).not_to be_empty
+    end
+
+    it "has any transaction" do
+      expect(subject).to be_any
+    end
+
+    it "has PagSeguro::Transaction instances" do
+      subject.each do |transaction|
+        expect(transaction).to be_a(PagSeguro::Transaction)
+      end
+    end
+  end
+end

data/spec/pagseguro/transaction/response_spec.rb

@@ -0,0 +1,96 @@
+require "spec_helper"
+
+describe PagSeguro::Transaction::Response do
+  subject { PagSeguro::Transaction::Response.new(http_response, object) }
+
+  context "#success?" do
+    let(:object) { double(:Object) }
+    let(:http_response) { double(:HttpResponse, xml?: true) }
+
+    it "delegates to response" do
+      allow(http_response).to receive(:success?).and_return(true)
+      expect(subject).to be_success
+
+      allow(http_response).to receive(:success?).and_return(false)
+      expect(subject).not_to be_success
+    end
+  end
+
+  describe "#serialize_statuses" do
+    let(:object) { PagSeguro::Transaction::StatusCollection.new }
+    let(:http_response) do
+      double(:Response, xml?: true, success?: true, unauthorized?: false,
+             bad_request?: false, body: raw_xml, data: parsed_xml)
+    end
+    let(:parsed_xml) { Nokogiri::XML(raw_xml) }
+
+    context "when request succeeds" do
+      let(:raw_xml) { File.read("./spec/fixtures/transactions/status_history.xml") }
+
+      it "returns a collection" do
+        expect(subject.serialize_statuses).to be_a(PagSeguro::Transaction::StatusCollection)
+      end
+
+      it "not change errors" do
+        expect { subject.serialize_statuses }.not_to change { object.errors.empty? }
+      end
+    end
+
+    context "when request fails" do
+      before do
+        allow(http_response).to receive(:success?).and_return(false)
+        allow(http_response).to receive(:bad_request?).and_return(true)
+        allow(http_response).to receive(:not_found?).and_return(true)
+        allow(http_response).to receive(:body).and_return(raw_xml)
+      end
+      let(:raw_xml) { File.read("./spec/fixtures/invalid_code.xml") }
+
+      it "returns PagSeguro::Transaction::StatusCollection instance" do
+        expect(subject.serialize_statuses).to be_a(PagSeguro::Transaction::StatusCollection)
+      end
+
+      it "change collection errors" do
+        expect { subject.serialize_statuses }.to change { object.errors.empty? }
+      end
+    end
+  end
+
+  describe "#serialize" do
+    let(:object) { PagSeguro::Transaction.new }
+    let(:http_response) do
+      double(:Response, xml?: true, success?: true, unauthorized?: false,
+             bad_request?: false, body: raw_xml, data: parsed_xml)
+    end
+    let(:parsed_xml) { Nokogiri::XML(raw_xml) }
+
+    context "when request succeeds" do
+      let(:raw_xml) { File.read("./spec/fixtures/transactions/success.xml") }
+
+      it "returns a transaction" do
+        expect(subject.serialize).to be_a(PagSeguro::Transaction)
+      end
+
+      it "not change errors" do
+        expect { subject.serialize }.not_to change { object.errors.empty? }
+      end
+    end
+
+    context "when request fails" do
+      before do
+        allow(http_response).to receive(:success?).and_return(false)
+        allow(http_response).to receive(:bad_request?).and_return(true)
+        allow(http_response).to receive(:not_found?).and_return(false)
+        allow(http_response).to receive(:body).and_return(raw_xml)
+      end
+      let(:raw_xml) { File.read("./spec/fixtures/invalid_code.xml") }
+
+      it "returns the transaction" do
+        expect(subject.serialize).to be_a(PagSeguro::Transaction)
+      end
+
+      it "change transaction errors" do
+        expect { subject.serialize }.to change { object.errors.empty? }
+      end
+    end
+  end
+end