pagseguro-sdk 2.6.2

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

data/lib/pagseguro/subscription/subscription_search.rb

@@ -0,0 +1,135 @@
+module PagSeguro
+  class SubscriptionSearch
+    # Set the report options.
+    #
+    # # +per_page+: the page size.
+    # # +starts_at+: the report's starting date. Can't be older than 6 months.
+    # # +ends_at+: the report's ending date. Can't be greater than 30 days from the starting date.
+    #
+    attr_reader :options
+
+    # Set the errors from the report request.
+    attr_reader :errors
+
+    # Return the current page.
+    attr_reader :page
+
+    def initialize(path, options)
+      @path = path
+      @page = options.delete(:page) || 0
+      @options = options
+      @errors = Errors.new
+    end
+
+    # Return the list of subscriptions.
+    # Each item will be wrapped in a PagSeguro::Subscription instance.
+    # Notice that subscriptions instantiated by the report won't have all attributes.
+    # If you need additional attributes, do a PagSeguro::Subscription.find_by_code
+    # call. Remember that this will perform an additional HTTP request.
+    def subscriptions
+      xml do |xml|
+        xml.css("preApprovalSearchResult > preApprovals > preApproval").map do |node|
+          Subscription.load_from_xml(node)
+        end
+      end
+    end
+
+    # The report's creation date.
+    def created_at
+      xml do |xml|
+        @created_at ||= Time.parse xml.css("preApprovalSearchResult > date").text
+      end
+    end
+
+    # How many results the report returned on the given page.
+    def results
+      xml do |xml|
+        @results = xml.css("preApprovalSearchResult > resultsInThisPage").text.to_i
+      end
+    end
+
+    # How many pages the report returned.
+    def total_pages
+      xml do |xml|
+        @total_pages ||= xml.css("preApprovalSearchResult > 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(@path, api_version, params)
+      @errors = Errors.new(@response)
+    end
+
+    # The params that will be sent
+    def params
+      {}.tap do |param|
+        param[:credentials] = options[:credentials]
+        param[:page] = page unless page.zero?
+        param[:maxPageResults] = options[:per_page]
+        param[:initialDate] = options[:starts_at].xmlschema if options[:starts_at]
+        param[:finalDate] = options[:ends_at].xmlschema if options[:ends_at]
+        param[:interval] = options[:interval] if options[:interval]
+      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