pagseguro-sdk 2.6.2

data/lib/pagseguro/payment_release.rb

@@ -0,0 +1,21 @@
+module PagSeguro
+  class PaymentRelease
+    include Extensions::MassAssignment
+    include Extensions::EnsureType
+
+    # Set the number of installments
+    attr_accessor :installment
+
+    # Set the total amount
+    attr_accessor :total_amount
+
+    # Set the total amount of the current release
+    attr_accessor :release_amount
+
+    # Set the status of current release
+    attr_accessor :status
+
+    # Set the release date
+    attr_accessor :release_date
+  end
+end

data/lib/pagseguro/payment_releases.rb

@@ -0,0 +1,28 @@
+module PagSeguro
+  class PaymentReleases
+    include Enumerable
+    extend Forwardable
+    include Extensions::EnsureType
+
+    def_delegators :@payments, :each, :size
+
+    def initialize
+      @payments = []
+    end
+
+    # Adds payment to payment list.
+    def <<(payment)
+      payment = ensure_type(PaymentRelease, payment)
+
+      @payments << payment unless @payments.include? payment
+    end
+
+    # Verify if a payment is already included to payment list.
+    # Returns Boolean.
+    def include?(payment)
+      self.find do |included_payment|
+        included_payment.installment == ensure_type(PaymentRelease, payment).installment
+      end
+    end
+  end
+end

data/lib/pagseguro/payment_request.rb

@@ -0,0 +1,117 @@
+module PagSeguro
+  class PaymentRequest
+    include Extensions::MassAssignment
+    include Extensions::EnsureType
+    include Extensions::Credentiable
+
+    # Set the payment currency.
+    # Defaults to BRL.
+    attr_accessor :currency
+
+    # 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
+
+    # Set the redirect url.
+    # The URL that will be used by PagSeguro to redirect the user after
+    # the payment information is processed. Typically this is a
+    # confirmation page on your web site.
+    attr_accessor :redirect_url
+
+    # Set the extra amount to be applied to the transaction's total.
+    # This value can be used to add an extra charge to the transaction
+    # or provide a discount, if negative.
+    attr_accessor :extra_amount
+
+    # Set the reference code.
+    # Optional. You can use the reference code to store an identifier so you can
+    # associate the PagSeguro transaction to a transaction in your system.
+    # Tipically this is the order id.
+    attr_accessor :reference
+
+    # Set the payment request duration, in seconds.
+    attr_accessor :max_age
+
+    # How many times the payment redirect uri returned by the payment
+    # web service can be accessed.
+    # Optional. After this payment request is submitted, the payment
+    # redirect uri returned by the payment web service will remain valid
+    # for the number of uses specified here.
+    attr_accessor :max_uses
+
+    # Determines for which url PagSeguro will send the order related
+    # notifications codes.
+    # Optional. Any change happens in the transaction status, a new notification
+    # request will be send to this url. You can use that for update the related
+    # order.
+    attr_accessor :notification_url
+
+    # Determines for which url PagSeguro will send the buyer when he doesn't
+    # complete the payment.
+    attr_accessor :abandon_url
+
+    # The extra parameters for payment request
+    attr_accessor :extra_params
+
+    # Products/items in this payment request.
+    def items
+      @items ||= Items.new
+    end
+
+    # Set the payment sender.
+    def sender=(sender)
+      @sender = ensure_type(Sender, sender)
+    end
+
+    # Set the receivers.
+    def receivers=(receivers)
+      receivers.each do |receiver|
+        @receivers << ensure_type(Receiver, receiver)
+      end
+    end
+
+    # Set the shipping info.
+    def shipping=(shipping)
+      @shipping = ensure_type(Shipping, shipping)
+    end
+
+    # Calls the PagSeguro web service and register this request for payment.
+    def register
+      request = if @receivers.empty?
+                  Request.post('checkout', api_version, params)
+                else
+                  Request.post_xml('checkouts', api_version, credentials, xml_params)
+                end
+
+      Response.new(request)
+    end
+
+    private
+
+    def xml_params
+      RequestSerializer.new(self).to_xml_params
+    end
+
+    def params
+      RequestSerializer.new(self).to_params
+    end
+
+    def before_initialize
+      self.extra_params = []
+      self.currency = "BRL"
+      @receivers = []
+    end
+
+    def api_version
+      'v2'
+    end
+  end
+end

data/lib/pagseguro/payment_request/request_serializer.rb

@@ -0,0 +1,203 @@
+module PagSeguro
+  class PaymentRequest
+    class RequestSerializer
+      # The payment request that will be serialized.
+      attr_reader :payment_request
+
+      def initialize(payment_request)
+        @payment_request = payment_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
+        {}.tap do |data|
+          data[:receiverEmail] = PagSeguro.receiver_email
+          data[:currency] = payment_request.currency
+          data[:reference] = payment_request.reference
+          data[:extraAmount] = to_amount(payment_request.extra_amount)
+          data[:redirectURL] = payment_request.redirect_url
+          data[:notificationURL] = payment_request.notification_url
+          data[:abandonURL] = payment_request.abandon_url
+          data[:maxUses] = payment_request.max_uses
+          data[:maxAge] = payment_request.max_age
+          data[:credentials] = payment_request.credentials
+          payment_request.items.each_with_index do |item, index|
+            serialize_item(data, item, index.succ)
+          end
+
+          serialize_sender(data, payment_request.sender)
+          serialize_shipping(data, payment_request.shipping)
+          serialize_receivers(data, payment_request.receivers)
+          serialize_extra_params(data, payment_request.extra_params)
+        end.delete_if { |_, value| value.nil? }
+      end
+
+      private
+
+      def serialize_receivers(data, receivers)
+        receivers.each.with_index(1) do |receiver, idx|
+          data["receiver[#{idx}].email"] = receiver.email
+          serialize_receiver_split(data, receiver, idx, receiver.split)
+        end
+      end
+
+      def serialize_receiver_split(data, receiver, idx, split)
+        data["receiver[#{idx}].split.amount"] = receiver.split.amount
+        data["receiver[#{idx}].split.feePercent"] = receiver.split.fee_percent
+        data["receiver[#{idx}].split.ratePercent"] = receiver.split.rate_percent
+      end
+
+      def serialize_item(data, item, index)
+        data["itemId#{index}"] = item.id
+        data["itemDescription#{index}"] = item.description
+        data["itemAmount#{index}"] = to_amount(item.amount)
+        data["itemQuantity#{index}"] = item.quantity
+        data["itemShippingCost#{index}"] = to_amount(item.shipping_cost)
+        data["itemWeight#{index}"] = item.weight if item.weight
+      end
+
+      def serialize_sender(data, sender)
+        return unless sender
+
+        data[:senderEmail] =  sender.email
+        data[:senderName] = sender.name
+
+        serialize_documents(data, sender.documents)
+        serialize_phone(data, sender.phone)
+      end
+
+      def serialize_documents(data, documents)
+        return if documents.empty?
+
+        documents.each do |document|
+          data[:senderCPF] = document.value if document.cpf?
+          data[:senderCNPJ] = document.value if document.cnpj?
+        end
+      end
+
+      def serialize_phone(data, phone)
+        return unless phone
+
+        data[:senderAreaCode] = phone.area_code
+        data[:senderPhone] = phone.number
+      end
+
+      def serialize_shipping(data, shipping)
+        return unless shipping
+
+        data[:shippingType] = shipping.type_id
+        data[:shippingCost] = to_amount(shipping.cost)
+
+        serialize_address(data, shipping.address)
+      end
+
+      def serialize_address(data, address)
+        return unless address
+
+        data[:shippingAddressCountry] = address.country
+        data[:shippingAddressState] = address.state
+        data[:shippingAddressCity] = address.city
+        data[:shippingAddressPostalCode] = address.postal_code
+        data[:shippingAddressDistrict] = address.district
+        data[:shippingAddressStreet] = address.street
+        data[:shippingAddressNumber] = address.number
+        data[:shippingAddressComplement] = address.complement
+      end
+
+      def serialize_extra_params(data, extra_params)
+        return unless extra_params
+
+        extra_params.each do |extra_param|
+          data[extra_param.keys.first] = extra_param.values.first
+        end
+      end
+
+      def to_amount(amount)
+        "%.2f" % BigDecimal(amount.to_s.to_f.to_s).round(2).to_s("F") if amount
+      end
+
+      def xml_builder
+        Nokogiri::XML::Builder.new(encoding: PagSeguro.encoding) do |xml|
+          xml.send(:checkout) {
+            xml_serialize_receivers(xml)
+            xml_serialize_sender(xml, payment_request.sender)
+            xml.send(:currency, payment_request.currency)
+            xml.send(:reference, payment_request.reference)
+            xml.send(:redirectURL, payment_request.redirect_url)
+            xml.send(:notificationURL, payment_request.notification_url)
+            xml_serialize_items(xml, payment_request.items)
+          }
+        end
+      end
+
+      def xml_serialize_items(xml, items)
+        xml.send(:items) {
+          items.each do |item|
+            xml.send(:item) {
+              xml.send(:id, item.id)
+              xml.send(:description, item.description)
+              xml.send(:quantity, item.quantity)
+              xml.send(:amount, to_amount(item.amount))
+              xml.send(:weight, item.weight) if item.weight
+              xml.send(:shippingCost, to_amount(item.shipping_cost))
+            }
+          end
+        }
+      end
+
+      def xml_serialize_documents(xml, documents)
+        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_sender(xml, sender)
+        return unless sender
+
+        xml.send(:sender) {
+          xml.send(:name, sender.name)
+          xml.send(:email, sender.email)
+          if sender.phone
+            xml.send(:phone) {
+              xml.send(:areaCode, sender.phone.area_code)
+              xml.send(:number, sender.phone.number)
+            }
+          end
+
+          xml_serialize_documents(xml, sender.documents)
+        }
+      end
+
+      def xml_serialize_receivers(xml)
+        xml.send(:primaryReceiver) {
+          xml.send(:email, payment_request.primary_receiver)
+        }
+
+        xml.send(:receivers) {
+          payment_request.receivers.each do |receiver|
+            xml.send(:receiver) {
+              xml.send(:email, receiver.email)
+              xml.send(:split) {
+                xml.send(:amount, receiver.split.amount)
+              }
+            }
+          end
+        }
+      end
+    end
+  end
+end

data/lib/pagseguro/payment_request/response.rb

@@ -0,0 +1,35 @@
+module PagSeguro
+  class PaymentRequest
+    class Response
+      extend Forwardable
+
+      def_delegators :response, :success?
+      attr_reader :response
+
+      def initialize(response)
+        @response = response
+      end
+
+      def errors
+        @errors ||= Errors.new(response)
+      end
+
+      def url
+        PagSeguro.site_url("#{api_version}/checkout/payment.html?code=#{code}") if code
+      end
+
+      def code
+        @code ||= response.data.css("checkout > code").text if success?
+      end
+
+      def created_at
+        @created_at ||= Time.parse(response.data.css("checkout > date").text) if success?
+      end
+
+      # Default PagSeguro API version for payments
+      def api_version
+        'v2'
+      end
+    end
+  end
+end

data/lib/pagseguro/payment_status.rb

@@ -0,0 +1,39 @@
+module PagSeguro
+  class PaymentStatus
+    STATUSES = {
+      "0" => :initiated,
+      "1" => :waiting_payment,
+      "2" => :in_analysis,
+      "3" => :paid,
+      "4" => :available,
+      "5" => :in_dispute,
+      "6" => :refunded,
+      "7" => :cancelled,
+      "8" => :chargeback_charged,
+      "9" => :contested
+    }.freeze
+
+    # The payment status id.
+    attr_reader :id
+
+    def initialize(id)
+      @id = id
+    end
+
+    # Dynamically define helpers.
+    STATUSES.each do |id, _status|
+      define_method "#{_status}?" do
+        _status == status
+      end
+    end
+
+    # Return a readable status.
+    def status
+      STATUSES.fetch(id.to_s) { raise "PagSeguro::PaymentStatus#id isn't mapped" }
+    end
+
+    def description
+      I18n.t(id, scope: "pagseguro.payment_status")
+    end
+  end
+end