pagseguro-oficial 2.5.0 → 2.6.0

data/lib/pagseguro/receiver.rb

@@ -6,6 +6,9 @@ module PagSeguro
     # Set receiver's email.
     attr_accessor :email
 
+    # Set receiver's public_key.
+    attr_accessor :public_key
+
     # Get receiver split.
     attr_reader :split
 

data/lib/pagseguro/request.rb

@@ -18,6 +18,17 @@ module PagSeguro
       execute :get, path, api_version, data, headers
     end
 
+    def get_with_auth_on_url(path, api_version, credentials)
+      request.public_send(
+        :get,
+        PagSeguro.api_url("#{api_version}/#{path}?#{credentials_to_params(credentials)}")
+      )
+    end
+
+    def get_without_api_version(path, data={}, headers={})
+      request.get(path, extended_data(data), headers)
+    end
+
     # Perform a POST request.
     #
     # # +path+: the path that will be requested. Must be something like <tt>"checkout"</tt>.
@@ -36,12 +47,31 @@ module PagSeguro
     # # +credentials+: the credentials like ApplicationCredentials or AccountCredentials.
     # # +data+: the data that will be sent as body data. Must be a XML.
     #
-    def post_xml(path, api_version, credentials, data)
+    def post_xml(path, api_version, credentials, data = '', options={})
       credentials_params = credentials_to_params(credentials)
+      url_path = [api_version, path].reject(&:nil?).join('/')
 
       request.post do
-        url PagSeguro.api_url("#{api_version}/#{path}?#{credentials_params}")
+        url PagSeguro.api_url("#{url_path}?#{credentials_params}")
         headers "Content-Type" => "application/xml; charset=#{PagSeguro.encoding}"
+        headers.merge!(options[:headers]) if options[:headers]
+        body data
+      end
+    end
+
+    # Perform a PUT request, sending XML data.
+    #
+    # # +path+: the path that will be requested. Must be something like <tt>"checkout"</tt>.
+    # # +credentials+: the credentials like ApplicationCredentials or AccountCredentials.
+    # # +data+: the data that will be sent as body data. Must be a XML.
+    #
+    def put_xml(path, credentials, data)
+      full_url = PagSeguro.api_url("#{path}?#{credentials_to_params(credentials)}")
+
+      request.put do
+        url full_url
+        headers "Content-Type" => "application/xml; charset=#{PagSeguro.encoding}",
+                "Accept" => "application/vnd.pagseguro.com.br.v1+xml;charset=ISO-8859-1"
         body data
       end
     end

data/lib/pagseguro/sender.rb

@@ -9,14 +9,17 @@ module PagSeguro
     # Get the sender document
     attr_reader :document
 
+    # Get the sender address
+    attr_reader :address
+
     # Set the sender name.
     attr_accessor :name
 
     # Set the sender e-mail.
     attr_accessor :email
 
-    # Set the CPF document.
-    attr_accessor :cpf
+    # Set the sender ip
+    attr_accessor :ip
 
     # Set sender hash.
     # It's used to identify the sender.
@@ -27,9 +30,24 @@ module PagSeguro
       @phone = ensure_type(Phone, phone)
     end
 
+    def documents
+      @documents ||= Documents.new
+    end
+
+    def documents=(_documents=[])
+      _documents.each do |document|
+        documents << document
+      end
+    end
+
     # Set the sender document.
     def document=(document)
-      @document = ensure_type(Document, document)
+      documents << ensure_type(Document, document)
+    end
+
+    # Set the sender address.
+    def address=(address)
+      @address = ensure_type(Address, address)
     end
   end
 end

data/lib/pagseguro/subscription.rb

@@ -0,0 +1,132 @@
+module PagSeguro
+  # It lets you create a subscription without going through PagSeguro screens.
+  class Subscription
+    include Extensions::MassAssignment
+    include Extensions::EnsureType
+    include Extensions::Credentiable
+
+    API_VERSION = :v2
+    TEN_DAYS_IN_SECONDS = 864_000
+
+    # Set the name
+    attr_accessor :name
+
+    # Set the date
+    attr_accessor :date
+
+    # Set the tracker
+    attr_accessor :tracker
+
+    # Set the status
+    attr_accessor :status
+
+    # Set the last event date
+    attr_accessor :last_event_date
+
+    # Set the charge
+    attr_accessor :charge
+
+    # Set the plan
+    attr_accessor :plan
+
+    # Set the reference
+    attr_accessor :reference
+
+    # Get the sender
+    attr_reader :sender
+
+    # Get the payment method
+    attr_reader :payment_method
+
+    # The code of a created to the subscription, must be saved
+    attr_accessor :code
+
+    # Set the sender
+    def sender=(sender)
+      @sender = ensure_type(Sender, sender)
+    end
+
+    # Set the payment method
+    def payment_method=(payment_method)
+      @payment_method = ensure_type(SubscriptionPaymentMethod, payment_method)
+    end
+
+    def update_attributes(attrs)
+      attrs.each {|name, value| send("#{name}=", value)  }
+    end
+
+    def create
+      request = Request.post_xml('pre-approvals', nil, credentials, xml_params, extra_options)
+      Response.new(request, self).serialize
+      self
+    end
+
+    def errors
+      @errors ||= Errors.new
+    end
+
+    # Find subscription by notification code
+    def self.find_by_notification_code(code, options={})
+      load_from_response send_request("pre-approvals/notifications/#{code}", options[:credentials])
+    end
+
+    # Find subscription by subscription code
+    def self.find_by_code(code, options={})
+      load_from_response send_request("pre-approvals/#{code}", options[:credentials])
+    end
+
+    def self.search_by_days_interval(options={})
+      # Default options
+      options = {
+        interval: 30,
+        per_page: 50,
+        page: 0
+      }.merge(options)
+
+      SubscriptionSearch.new('pre-approvals/notifications', options)
+    end
+
+    def self.search_by_date_interval(options={})
+      # Default options
+      options = {
+        starts_at: Time.now,
+        ends_at: Time.now - TEN_DAYS_IN_SECONDS,
+        per_page: 50,
+        page: 0
+      }.merge(options)
+
+      SubscriptionSearch.new('pre-approvals', options)
+    end
+
+    def self.load_from_xml(xml)
+      new ResponseSerializer.new(xml).serialize_from_search
+    end
+
+    private
+
+    # Serialize the HTTP response into data.
+    def self.load_from_response(request) # :nodoc:
+      subscription = new
+      Response.new(request, subscription).serialize(:search)
+
+      subscription
+    end
+
+    # Send a get request to API version, with the path given
+    def self.send_request(path, credentials)
+      Request.get_with_auth_on_url(path, API_VERSION, credentials)
+    end
+
+    def xml_params
+      RequestSerializer.new(self).serialize
+    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/request_serializer.rb

@@ -0,0 +1,129 @@
+module PagSeguro
+  class Subscription
+    class RequestSerializer
+      # Get the object
+      attr_reader :object
+
+      def initialize(object)
+        @object = object
+      end
+
+      def serialize
+        build.to_xml(save_with:
+          Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS |
+          Nokogiri::XML::Node::SaveOptions::FORMAT
+        )
+      end
+
+      private
+
+      def build
+        Nokogiri::XML::Builder.new(encoding: PagSeguro.encoding) do |xml|
+          xml.send(:directPreApproval) {
+            xml.send(:plan, object.plan) if object.plan
+            xml.send(:reference, object.reference) if object.reference
+            serialize_sender(xml, object.sender)
+            serialize_payment_method(xml, object.payment_method)
+          }
+        end
+      end
+
+      def serialize_sender(xml, sender)
+        return unless sender
+
+        xml.send(:sender) {
+          xml.send(:name, sender.name) if sender.name
+          xml.send(:email, sender.email) if sender.email
+          xml.send(:ip, sender.ip) if sender.ip
+          xml.send(:hash_, sender.hash) if sender.hash
+
+          serialize_phone(xml, sender.phone)
+          serialize_address(xml, sender.address)
+          serialize_documents(xml, sender.documents)
+        }
+      end
+
+      def serialize_phone(xml, phone)
+        return unless phone
+
+        xml.send(:phone) {
+          xml.send(:areaCode, phone.area_code)
+          xml.send(:number, phone.number)
+        }
+      end
+
+      def serialize_address(xml, address)
+        return unless address
+
+        xml.send(:address) {
+          xml.send(:street, address.street) if address.street
+          xml.send(:number, address.number) if address.number
+          xml.send(:complement, address.complement) if address.complement
+          xml.send(:district, address.district) if address.district
+          xml.send(:city, address.city) if address.city
+          xml.send(:state, address.state) if address.state
+          xml.send(:country, address.country) if address.country
+          xml.send(:postalCode, address.postal_code) if address.postal_code
+        }
+      end
+
+      def serialize_billing_address(xml, address)
+        return unless address
+
+        xml.send(:billingAddress) {
+          xml.send(:street, address.street) if address.street
+          xml.send(:number, address.number) if address.number
+          xml.send(:complement, address.complement) if address.complement
+          xml.send(:district, address.district) if address.district
+          xml.send(:city, address.city) if address.city
+          xml.send(:state, address.state) if address.state
+          xml.send(:country, address.country) if address.country
+          xml.send(:postalCode, address.postal_code) if address.postal_code
+        }
+      end
+
+      def serialize_documents(xml, documents)
+        return if documents.empty?
+
+        xml.send(:documents) {
+          documents.each do |document|
+            serialize_document(xml, document)
+          end
+        }
+      end
+
+      def serialize_document(xml, document)
+        return unless document
+
+        xml.send(:document) {
+          xml.send(:type, document.type)
+          xml.send(:value, document.value)
+        }
+      end
+
+      def serialize_payment_method(xml, payment_method)
+        return unless payment_method
+
+        xml.send(:paymentMethod) {
+          xml.send(:type, payment_method.type)
+          xml.send(:creditCard) {
+            xml.send(:token, payment_method.token)
+            serialize_holder(xml, payment_method.holder)
+          }
+        }
+      end
+
+      def serialize_holder(xml, holder)
+        return unless holder
+
+        xml.send(:holder) {
+          xml.send(:name, holder.name) if holder.name
+          xml.send(:birthDate, holder.birth_date) if holder.birth_date
+          serialize_document(xml, holder.document)
+          serialize_billing_address(xml, holder.billing_address)
+          serialize_phone(xml, holder.phone)
+        }
+      end
+    end
+  end
+end

data/lib/pagseguro/subscription/response.rb

@@ -0,0 +1,49 @@
+module PagSeguro
+  class Subscription
+    class Response
+      # The http response
+      attr_reader :response
+
+      # Set the object that will recive errors or updates
+      attr_reader :object
+
+      def initialize(response, object)
+        @response = response
+        @object = object
+      end
+
+      def serialize(kind = :normal)
+        if success?
+          case kind
+          when :normal
+            object.update_attributes(serialized_data)
+          when :search
+            object.update_attributes(serialized_data_from_search)
+          end
+        else
+          object.errors.add response
+        end
+
+        object
+      end
+
+      def success?
+        response.success? && response.xml?
+      end
+
+      private
+
+      def xml
+        Nokogiri::XML(response.body)
+      end
+
+      def serialized_data
+        ResponseSerializer.new(xml).serialize
+      end
+
+      def serialized_data_from_search
+        ResponseSerializer.new(xml).serialize_from_search
+      end
+    end
+  end
+end

data/lib/pagseguro/subscription/response_serializer.rb

@@ -0,0 +1,62 @@
+module PagSeguro
+  class Subscription
+    class ResponseSerializer
+      attr_reader :xml
+
+      def initialize(xml)
+        @xml = xml
+      end
+
+      def serialize
+        {}.tap do |data|
+          data[:code] = xml.css('directPreApproval > code').text
+        end
+      end
+
+      def serialize_from_search
+        {}.tap do |data|
+          data[:name] = xml.at_css('name').text
+          data[:code] = xml.css('code').text
+          data[:date] = xml.css('date').text
+          data[:tracker] = xml.css('tracker').text
+          data[:status] = xml.css('status').text
+          data[:reference] = xml.css('reference').text
+          data[:last_event_date] = xml.css('lastEventDate').text
+          data[:charge] = xml.css('charge').text
+          data[:sender] = serialize_sender if xml.at_css('sender')
+        end
+      end
+
+      private
+
+      def serialize_sender
+        {}.tap do |data|
+          data[:name] = xml.at_css('sender > name').text
+          data[:email] = xml.at_css('sender > email').text
+          data[:phone] = serialize_phone if xml.at_css('phone')
+          data[:address] = serialize_address if xml.at_css('address')
+        end
+      end
+
+      def serialize_phone
+        {}.tap do |data|
+          data[:area_code] = xml.css('sender > phone > areaCode').text
+          data[:number] = xml.css('sender > phone > number').text
+        end
+      end
+
+      def serialize_address
+        {}.tap do |data|
+          data[:street] = xml.at_css('sender > address > street').text
+          data[:number] = xml.at_css('sender > address > number').text
+          data[:complement] = xml.at_css('sender > address > complement').text
+          data[:district] = xml.at_css('sender > address > district').text
+          data[:city] = xml.at_css('sender > address > city').text
+          data[:state] = xml.at_css('sender > address > state').text
+          data[:country] = xml.at_css('sender > address > country').text
+          data[:postal_code] = xml.at_css('sender > address > postalCode').text
+        end
+      end
+    end
+  end
+end