pagseguro-oficial 2.5.0 → 2.6.0

data/lib/pagseguro/subscription_plan/response_serializer.rb

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

data/lib/pagseguro/subscription_retry.rb

@@ -0,0 +1,35 @@
+module PagSeguro
+  class SubscriptionRetry
+    include Extensions::MassAssignment
+    include Extensions::Credentiable
+
+    attr_accessor :payment_order_code
+    attr_accessor :subscription_code
+
+    def errors
+      @errors ||= Errors.new
+    end
+
+    def save
+      request = Request.post_xml(url, nil, credentials, nil, extra_options)
+
+      Response.new(request, self).serialize
+
+      self
+    end
+
+    private
+
+    def url
+      "pre-approvals/#{subscription_code}/payment-orders/#{payment_order_code}/payment"
+    end
+
+    def extra_options
+      { headers: { "Accept" => "application/vnd.pagseguro.com.br.v1+xml;charset=ISO-8859-1" }}
+    end
+
+    def after_initialize
+      @errors = Errors.new
+    end
+  end
+end

data/lib/pagseguro/subscription_retry/response.rb

@@ -0,0 +1,34 @@
+module PagSeguro
+  class SubscriptionRetry
+    class Response
+      # The http response.
+      attr_reader :response
+
+      # Set the object that will receive errors or updates
+      attr_reader :object
+
+      def initialize(response, object)
+        @response = response
+        @object = object
+      end
+
+      def serialize
+        unless success?
+          object.errors.add response
+        end
+
+        object
+      end
+
+      def success?
+        response.success? && response.xml?
+      end
+
+      private
+
+      def xml
+        Nokogiri::XML(response.body)
+      end
+    end
+  end
+end

data/lib/pagseguro/subscription_search_payment_orders.rb

@@ -0,0 +1,131 @@
+module PagSeguro
+  class SubscriptionSearchPaymentOrders
+    attr_reader :code
+    attr_reader :options
+    attr_reader :status
+    attr_reader :errors
+    attr_reader :page
+
+    def initialize(code, status, options={})
+      @code = code
+      @status = status
+      @options = options
+      @page = options.delete(:page) || 0
+      @errors = Errors.new
+    end
+
+    # Return the list of subscription payment orders.
+    # Each item will be wrapped in a PagSeguro::SubscriptionPaymentOrder instance.
+    def payment_orders
+      xml do |xml|
+        xml.css("paymentOrdersResult > paymentOrders > paymentOrder").map do |node|
+          SubscriptionPaymentOrder.load_from_xml(node)
+        end
+      end
+    end
+
+    # The report's creation date.
+    def created_at
+      xml do |xml|
+        @created_at ||= Time.parse xml.css("paymentOrdersResult > date").text
+      end
+    end
+
+    # How many results the report returned on the given page.
+    def results
+      xml do |xml|
+        @results = xml.css("paymentOrdersResult > resultsInThisPage").text.to_i
+      end
+    end
+
+    # How many pages the report returned.
+    def total_pages
+      xml do |xml|
+        @total_pages ||= xml.css("paymentOrdersResult > totalPages").text.to_i
+      end
+    end
+
+    # Detect if the report has a next page.
+    def next_page?
+      page.zero? || page < total_pages
+    end
+
+    # Detect if the report has a previous page.
+    def previous_page?
+      page > 1
+    end
+
+    # Move the page pointer to the next page.
+    def next_page!
+      return unless next_page?
+      @page += 1
+      clear!
+    end
+
+    # Move the page pointer to the previous page.
+    def previous_page!
+      return unless previous_page?
+      @page -= 1
+      clear!
+    end
+
+    # Detect if the report request returned errors.
+    def valid?
+      fetch { errors.empty? }
+    end
+
+    private
+    def perform_request_and_serialize
+      @response = Request.get_without_api_version(path, params, header)
+      @errors = Errors.new(@response)
+    end
+
+    def path
+      PagSeguro.api_url "pre-approvals/#{code}/payment-orders"
+    end
+
+    def header
+      { "Accept" => "application/vnd.pagseguro.com.br.v1+xml;charset=ISO-8859-1" }
+    end
+
+    # The params that will be sent
+    def params
+      {}.tap do |param|
+        param[:status] = SubscriptionPaymentOrder::STATUSES[status.to_sym]
+        param[:page] = page
+        param[:maxPageResults] = options[:per_page]
+        param[:credentials] = options[:credentials]
+      end
+    end
+
+    # The default PagSeguro API version
+    def api_version
+      :v2
+    end
+
+    def fetched?
+      @fetched
+    end
+
+    def fetched!
+      @fetched = true
+    end
+
+    def clear!
+      @fetched = false
+    end
+
+    def fetch(&block)
+      unless fetched?
+        perform_request_and_serialize
+        fetched!
+      end
+
+      instance_eval(&block)
+    end
+
+    def xml(&block)
+      valid? && block.call(@response.data)
+    end
+  end
+end

data/lib/pagseguro/subscription_transaction.rb

@@ -0,0 +1,29 @@
+module PagSeguro
+  class SubscriptionTransaction
+    include Extensions::MassAssignment
+
+    STATUSES = {
+      waiting_payment: 1,
+      in_review: 2,
+      paid: 3,
+      available: 4,
+      in_dispute: 5,
+      returned: 6,
+      canceled: 7,
+      charged: 8,
+      temporary_retention: 9
+    }
+
+    attr_accessor :code
+    attr_accessor :status
+    attr_accessor :date
+
+    def status_code
+      STATUSES[status.to_sym]
+    end
+
+    def ==(object)
+      [code, status, date] == [object.code, object.status, object.date]
+    end
+  end
+end

data/lib/pagseguro/subscription_transactions.rb

@@ -0,0 +1,5 @@
+module PagSeguro
+  class SubscriptionTransactions
+    include Extensions::CollectionObject
+  end
+end

data/lib/pagseguro/transaction.rb

@@ -79,16 +79,6 @@ 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.new(request, collection).serialize_statuses
-
-      collection
-    end
-
     # Search transactions within a date range.
     # Return a PagSeguro::SearchByDate instance
     #

data/lib/pagseguro/transaction/serializer.rb

@@ -34,9 +34,10 @@ module PagSeguro
       def serialize_general(data)
         data[:code] = xml.at_css("code").text
         data[:reference] = xml.css("reference").text
-        data[:type_id] = xml.at_css("type").text
         data[:payment_link] = xml.css("paymentLink").text
-        data[:status] = xml.at_css("status").text
+
+        data[:type_id] = serialize_general_type_id
+        data[:status] = serialize_general_status
 
         cancellation_source = xml.css("cancellationSource")
         data[:cancellation_source] = cancellation_source.text if cancellation_source.any?
@@ -156,6 +157,22 @@ module PagSeguro
       def address_node
         @address_node ||= xml.css("shipping > address")
       end
+
+      def serialize_general_type_id
+        type = xml.css('type').detect do |node|
+          node if node.parent.name == 'transaction'
+        end
+
+        type.text if type
+      end
+
+      def serialize_general_status
+        status = xml.css('status').detect do |node|
+          node if node.parent.name == 'transaction'
+        end
+
+        status.text if status
+      end
     end
   end
 end

data/lib/pagseguro/transaction_request.rb

@@ -2,6 +2,7 @@ module PagSeguro
   class TransactionRequest
     include Extensions::MassAssignment
     include Extensions::EnsureType
+    include Extensions::Credentiable
 
     # Set the payment currency.
     # Defaults to BRL.
@@ -10,6 +11,12 @@ module PagSeguro
     # Get the payment sender.
     attr_reader :sender
 
+    # Set and get primary receiver email.
+    attr_accessor :primary_receiver
+
+    # Get the payment receivers.
+    attr_reader :receivers
+
     # Get the shipping info.
     attr_reader :shipping
 
@@ -99,7 +106,12 @@ module PagSeguro
     # Calls the PagSeguro web service and create this request for payment.
     # Return boolean.
     def create
-      request = Request.post("transactions", api_version, params)
+      request = if receivers.empty?
+                  Request.post('transactions', api_version, params)
+                else
+                  Request.post_xml('transactions/', nil, credentials, xml_params)
+                end
+
       Response.new(request, self).serialize
     end
 
@@ -107,7 +119,15 @@ module PagSeguro
       attrs.map { |name, value| send("#{name}=", value) }
     end
 
+    # Set the receivers.
+    def receivers=(receivers)
+      @receivers = receivers.map do |receiver|
+                     ensure_type(Receiver, receiver)
+                   end
+    end
+
     private
+
     attr_writer :code, :type_id, :payment_link, :status, :payment_method,
       :gross_amount, :discount_amount, :net_amount, :installment_count,
       :created_at, :updated_at
@@ -115,12 +135,17 @@ module PagSeguro
     def before_initialize
       self.currency = "BRL"
       self.extra_params = []
+      self.receivers = []
     end
 
     def params
       RequestSerializer.new(self).to_params
     end
 
+    def xml_params
+      RequestSerializer.new(self).to_xml_params
+    end
+
     # Used to set response items from api.
     def items=(items)
       @items = Items.new

data/lib/pagseguro/transaction_request/request_serializer.rb

@@ -8,6 +8,14 @@ module PagSeguro
         @transaction_request = transaction_request
       end
 
+      def to_xml_params
+        xml_builder.to_xml(
+          save_with:
+          Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS |
+          Nokogiri::XML::Node::SaveOptions::FORMAT
+        )
+      end
+
       def to_params
         params[:receiverEmail] = PagSeguro.receiver_email
         params[:currency] = transaction_request.currency
@@ -90,12 +98,21 @@ module PagSeguro
 
         params[:senderEmail] =  sender.email
         params[:senderName] = sender.name
-        params[:senderCPF] = sender.cpf
         params[:senderHash] = sender.hash
 
+        serialize_sender_documents(sender.documents)
         serialize_sender_phone(sender.phone)
       end
 
+      def serialize_sender_documents(documents)
+        return if documents.empty?
+
+        documents.each do |document|
+          params[:senderCPF] = document.value if document.cpf?
+          params[:senderCNPJ] = document.value if document.cnpj?
+        end
+      end
+
       def serialize_sender_phone(phone)
         return unless phone
 
@@ -143,6 +160,152 @@ module PagSeguro
       def to_amount(amount)
         "%.2f" % BigDecimal(amount.to_s).round(2).to_s("F") if amount
       end
+
+      def xml_builder
+        Nokogiri::XML::Builder.new(encoding: PagSeguro.encoding) do |xml|
+          xml.send(:payment) {
+            xml.mode transaction_request.payment_mode
+            xml.method_ transaction_request.payment_method
+            xml.currency transaction_request.currency
+            xml.notificationURL transaction_request.notification_url
+            xml.extraAmount to_amount(transaction_request.extra_amount || 0)
+            xml.reference transaction_request.reference
+
+            xml_serialize_sender(xml, transaction_request.sender)
+            xml_serialize_items(xml, transaction_request.items)
+            xml_serialize_receivers(xml, transaction_request.receivers)
+            xml_serialize_shipping(xml, transaction_request.shipping)
+            xml_serialize_credit_card(xml)
+          }
+        end
+      end
+
+      def xml_serialize_credit_card(xml)
+        return unless transaction_request.is_a?(PagSeguro::CreditCardTransactionRequest)
+
+        xml.send(:creditCard) do
+          xml.send(:token, transaction_request.credit_card_token)
+
+          if transaction_request.installment
+            xml.send(:installment) do
+              xml.send(:quantity, transaction_request.installment.quantity)
+              xml.send(:value, to_amount(transaction_request.installment.value))
+            end
+          end
+
+          if transaction_request.billing_address
+            xml.send(:billingAddress) do
+              xml.send(:street, transaction_request.billing_address.street)
+              xml.send(:number, transaction_request.billing_address.number)
+              xml.send(:complement, transaction_request.billing_address.complement)
+              xml.send(:district, transaction_request.billing_address.district)
+              xml.send(:city, transaction_request.billing_address.city)
+              xml.send(:state, transaction_request.billing_address.state)
+              xml.send(:country, transaction_request.billing_address.country)
+              xml.send(:postalCode, transaction_request.billing_address.postal_code)
+            end
+          end
+
+          if transaction_request.holder
+            xml.send(:holder) do
+              xml.send(:name, transaction_request.holder.name)
+              xml_serialize_documents(xml, [transaction_request.holder.document])
+
+              xml.send(:birthDate, transaction_request.holder.birth_date)
+              xml_serialize_phone(xml, transaction_request.holder.phone)
+            end
+          end
+        end
+      end
+
+      def xml_serialize_documents(xml, documents = [])
+        documents = documents.reject(&:nil?)
+
+        return if documents.empty?
+
+        xml.send(:documents) {
+          documents.each do |document|
+            xml.send(:document) {
+              xml.send(:type, document.type)
+              xml.send(:value, document.value)
+            }
+          end
+        }
+      end
+
+      def xml_serialize_phone(xml, phone)
+        if phone
+          xml.send(:phone) {
+            xml.send(:areaCode, phone.area_code)
+            xml.send(:number, phone.number)
+          }
+        end
+      end
+
+      def xml_serialize_shipping(xml, shipping)
+        return unless shipping
+
+        xml.send(:shipping) do
+          if shipping.address
+            xml.send(:address) do
+              xml.send(:street, shipping.address.street)
+              xml.send(:number, shipping.address.number)
+              xml.send(:district, shipping.address.district)
+              xml.send(:country, shipping.address.country)
+              xml.send(:postalCode, shipping.address.postal_code)
+              xml.send(:city, shipping.address.city)
+              xml.send(:state, shipping.address.state)
+              xml.send(:complement, shipping.address.complement)
+            end
+          end
+        end
+      end
+
+      def xml_serialize_items(xml, items)
+        return unless items
+
+        xml.send(:items) do
+          items.each do |item|
+            xml.send(:item) do
+              xml.send(:id, item.id)
+              xml.send(:description, item.description)
+              xml.send(:quantity, item.quantity)
+              xml.send(:amount, to_amount(item.amount))
+            end
+          end
+        end
+      end
+
+      def xml_serialize_sender(xml, sender)
+        return unless sender
+
+        xml.send(:sender) {
+          xml.send(:name, sender.name)
+          xml.send(:email, sender.email)
+
+          xml_serialize_phone(xml, sender.phone)
+          xml_serialize_documents(xml, sender.documents)
+
+          xml.send(:hash_, sender.hash)
+        }
+      end
+
+      def xml_serialize_receivers(xml, receivers)
+        return if receivers.empty?
+
+        xml.send(:receivers) {
+          receivers.each do |receiver|
+            xml.send(:receiver) {
+              xml.send(:publicKey, receiver.public_key)
+              xml.send(:split) {
+                xml.send(:amount, to_amount(receiver.split.amount))
+                xml.send(:ratePercent, to_amount(receiver.split.rate_percent))
+                xml.send(:feePercent, to_amount(receiver.split.fee_percent))
+              }
+            }
+          end
+        }
+      end
     end
   end
 end