pagseguro-sdk 2.6.2

data/lib/pagseguro/account.rb

@@ -0,0 +1,29 @@
+module PagSeguro
+  class Account
+    include Extensions::MassAssignment
+    include Extensions::EnsureType
+
+    # Set the account e-mail.
+    attr_accessor :email
+
+    # Set the account type.
+    # Must be PERSONAL, SELLER or COMPANY.
+    attr_accessor :type
+
+    # Get the person account.
+    attr_reader :person
+
+    # Get the company account.
+    attr_reader :company
+
+    def person=(person)
+      return if company
+      @person = ensure_type(Person, person)
+    end
+
+    def company=(company)
+      return if person
+      @company = ensure_type(Company, company)
+    end
+  end
+end

data/lib/pagseguro/account_credentials.rb

@@ -0,0 +1,14 @@
+module PagSeguro
+  class AccountCredentials
+    # The user email
+    attr_accessor :email
+
+    # The token related to the user
+    attr_accessor :token
+
+    def initialize(email, token)
+      @email = email
+      @token = token
+    end
+  end
+end

data/lib/pagseguro/address.rb

@@ -0,0 +1,40 @@
+module PagSeguro
+  # Set the shipping address information.
+  class Address
+    include Extensions::MassAssignment
+
+    # Set the street name.
+    attr_accessor :street
+
+    # Set the house/building number.
+    attr_accessor :number
+
+    # Set the address complement.
+    # Can be the apartment, suite number or any other qualifier after
+    # the street/number pair.
+    attr_accessor :complement
+
+    # Set the district.
+    # Can be the district, county or neighborhood, if applicable.
+    attr_accessor :district
+
+    # Set the city name.
+    attr_accessor :city
+
+    # Set the state or province.
+    attr_accessor :state
+
+    # Set the postal code.
+    # Must contain 8 numbers.
+    attr_accessor :postal_code
+
+    # Set the country code.
+    # Defaults to +BRA+.
+    attr_accessor :country
+
+    private
+    def before_initialize
+      self.country = "BRA"
+    end
+  end
+end

data/lib/pagseguro/application_credentials.rb

@@ -0,0 +1,18 @@
+module PagSeguro
+  class ApplicationCredentials
+    # The application id
+    attr_accessor :app_id
+
+    # The token related to the application
+    attr_accessor :app_key
+
+    # The application authorization code
+    attr_accessor :authorization_code
+
+    def initialize(app_id, app_key, authorization_code = nil)
+      @app_id = app_id
+      @app_key = app_key
+      @authorization_code = authorization_code
+    end
+  end
+end

data/lib/pagseguro/authorization.rb

@@ -0,0 +1,61 @@
+module PagSeguro
+  class Authorization
+    include Extensions::MassAssignment
+    include Extensions::Credentiable
+
+    # The authorization code
+    attr_accessor :code
+
+    # The authorization creation date
+    attr_accessor :created_at
+
+    # The reference related to the authorization
+    attr_accessor :reference
+
+    # The authorization permissions
+    attr_accessor :permissions
+
+    # The authorization authorizerEmail
+    attr_accessor :authorizer_email
+
+    # Find an authorization by it's notification code
+    def self.find_by_notification_code(code, options = {})
+      request = Request.get("authorizations/notifications/#{code}", api_version, options)
+      authorization = PagSeguro::Authorization.new
+      Response.new(request, authorization).serialize
+
+      authorization
+    end
+
+    # Find an authorization by it's code
+    def self.find_by_code(code, options = {})
+      request = Request.get("authorizations/#{code}", api_version, options)
+      authorization = PagSeguro::Authorization.new
+      Response.new(request, authorization).serialize
+
+      authorization
+    end
+
+    def self.find_by(options)
+      request = Request.get("authorizations", api_version, RequestSerializer.new(options).to_params)
+      collection = Collection.new
+      Response.new(request, collection).serialize_collection
+
+      collection
+    end
+
+    def update_attributes(attrs)
+      attrs.map { |name, value| send("#{name}=", value) }
+    end
+
+    def errors
+      @errors ||= Errors.new
+    end
+
+    private
+
+    def self.api_version
+      'v2'
+    end
+  end
+end

data/lib/pagseguro/authorization/collection.rb

@@ -0,0 +1,28 @@
+module PagSeguro
+  class Authorization
+    class Collection
+      extend Forwardable
+
+      attr_writer :authorizations
+
+      def_delegators :@authorizations, :each, :empty?, :any?
+
+      def initialize(options = {})
+        @errors = options[:errors] if options[:errors]
+        @authorizations = instantiate_authorizations(options[:authorizations])
+      end
+
+      def errors
+        @errors ||= Errors.new
+      end
+
+      private
+      def instantiate_authorizations(authorizations)
+        return [] unless authorizations
+        authorizations.map do |authorization|
+          Authorization.new(authorization)
+        end
+      end
+    end
+  end
+end

data/lib/pagseguro/authorization/request_serializer.rb

@@ -0,0 +1,24 @@
+module PagSeguro
+  class Authorization
+    class RequestSerializer
+      attr_reader :authorization
+
+      def initialize(options)
+        @options = options
+      end
+
+      def to_params
+        params[:credentials] = @options[:credentials] if @options[:credentials]
+        params[:reference]   = @options[:reference] if @options[:reference]
+        params[:initialDate] = @options[:initial_date].xmlschema if @options[:initial_date]
+        params[:finalDate]   = @options[:final_date].xmlschema if @options[:final_date]
+        params
+      end
+
+      private
+      def params
+        @params ||= {}
+      end
+    end
+  end
+end

data/lib/pagseguro/authorization/response.rb

@@ -0,0 +1,49 @@
+module PagSeguro
+  class Authorization
+    class Response
+      def initialize(response, object)
+        @response = response
+        @object = object
+      end
+
+      def serialize
+        if success?
+          xml = Nokogiri::XML(response.body).css('authorization').first
+          serializer = ResponseSerializer.new(xml).serialize
+          object.update_attributes(serializer)
+        else
+          object.errors.add(response)
+        end
+
+        object
+      end
+
+      def serialize_collection
+        if success?
+          object.authorizations = serialize_authorizations
+        else
+          object.errors.add(response)
+        end
+
+        object
+      end
+
+      def success?
+        response.success? && response.xml?
+      end
+
+      private
+      # The request response.
+      attr_reader :response
+
+      # The PagSeguro::Authorization or PagSeguro::Authorization::Collection object
+      attr_reader :object
+
+      def serialize_authorizations
+        Nokogiri::XML(response.body).css('authorizations > authorization').map do |node|
+          Authorization.new(ResponseSerializer.new(node).serialize)
+        end
+      end
+    end
+  end
+end

data/lib/pagseguro/authorization/response_serializer.rb

@@ -0,0 +1,40 @@
+module PagSeguro
+  class Authorization
+    class ResponseSerializer
+
+      def initialize(xml)
+        @xml = xml
+      end
+
+      def serialize
+        {}.tap do |data|
+          serialize_general(data)
+          serialize_permissions(data)
+        end
+      end
+
+      private
+      def serialize_general(data)
+        data[:code] = xml.css("> code").text
+        data[:reference] = xml.css("reference").text
+        data[:created_at] = Time.parse xml.css("creationDate").text
+        data[:authorizer_email] = xml.css("authorizerEmail").text
+      end
+
+      def serialize_permissions(data)
+        data[:permissions] = []
+
+        xml.css("permission").each do |node|
+          permission = PagSeguro::Permission.new
+          permission.code = node.css("code").text
+          permission.status = node.css("status").text
+          permission.last_update = node.css("lastUpdate").text
+
+          data[:permissions] << permission
+        end
+      end
+
+      attr_reader :xml
+    end
+  end
+end

data/lib/pagseguro/authorization_request.rb

@@ -0,0 +1,84 @@
+module PagSeguro
+  class AuthorizationRequest
+    include Extensions::MassAssignment
+    include Extensions::EnsureType
+    include Extensions::Credentiable
+
+    # The permissions given to the application
+    # Defaults to all permissions
+    attr_accessor :permissions
+
+    # The seller reference (optional)
+    attr_accessor :reference
+
+    # The url which PagSeguro can send notifications
+    attr_accessor :notification_url
+
+    # The url which the application is going to be redirected after the proccess
+    attr_accessor :redirect_url
+
+    # The account that can be passed to register suggestion
+    attr_reader :account
+
+    # The code used to confirm the authorization
+    attr_reader :code
+
+    # The date of authorization creation
+    attr_reader :date
+
+    # Errors object.
+    attr_writer :errors
+
+    PERMISSIONS = {
+      checkouts: 'CREATE_CHECKOUTS',
+      notifications: 'RECEIVE_TRANSACTION_NOTIFICATIONS',
+      searches: 'SEARCH_TRANSACTIONS',
+      pre_approvals: 'MANAGE_PAYMENT_PRE_APPROVALS',
+      payments: 'DIRECT_PAYMENT',
+      refunds: 'REFUND_TRANSACTIONS',
+      cancels: 'CANCEL_TRANSACTIONS'
+    }
+
+    def account=(account)
+      @account = ensure_type(Account, account)
+    end
+
+    # Post and create an Authorization.
+    # Return Boolean.
+    def create
+      request = Request.post_xml('authorizations/request', api_version, credentials, xml)
+      response = Response.new(request)
+      update_attributes(response.serialize)
+
+      response.success?
+    end
+
+    # URL to confirm authorization after create one.
+    def url
+      PagSeguro.site_url("#{api_version}/authorization/request.jhtml?code=#{code}") if code
+    end
+
+    def errors
+      @errors ||= Errors.new
+    end
+
+    private
+    attr_writer :code, :date
+
+    def before_initialize
+      self.permissions = PERMISSIONS.keys
+    end
+
+    def xml
+      RequestSerializer.new(self).build_xml
+    end
+
+    def update_attributes(attrs)
+      attrs.each { |method, value| send("#{method}=", value) }
+    end
+
+    def api_version
+      'v2'
+    end
+  end
+end

data/lib/pagseguro/authorization_request/request_serializer.rb

@@ -0,0 +1,142 @@
+module PagSeguro
+  class AuthorizationRequest
+    class RequestSerializer
+
+      attr_accessor :request
+
+      def initialize(request)
+        @request = request
+        @builder = Nokogiri::XML::Builder
+      end
+
+      def build_xml
+        build.to_xml(save_with:
+          Nokogiri::XML::Node::SaveOptions::NO_EMPTY_TAGS |
+          Nokogiri::XML::Node::SaveOptions::FORMAT
+        )
+      end
+
+      private
+
+      attr_reader :builder
+
+      def build
+        builder.new(encoding: PagSeguro.encoding) do |xml|
+          xml.send(:authorizationRequest) {
+            xml.send(:reference, request.reference) if request.reference
+            xml.send(:redirectURL, request.redirect_url)
+            xml.send(:notificationURL, request.notification_url)
+            serialize_permissions(xml, request.permissions)
+            serialize_account(xml, request.account)
+          }
+        end
+      end
+
+      def serialize_permissions(xml, permissions)
+        return unless permissions.any?
+        xml.send(:permissions) {
+          format_permissions(permissions).each do |permission|
+            xml.send(:code, permission)
+          end
+        }
+      end
+
+      def format_permissions(permissions)
+        permissions.map { |value| PagSeguro::AuthorizationRequest::PERMISSIONS[value] }
+      end
+
+      def serialize_account(xml, account)
+        return unless account
+
+        xml.send(:account) {
+          xml.send(:email, account.email) if account.email
+          xml.send(:type, account.type) if account.type
+
+          if account.person
+            serialize_person(xml, account.person)
+          elsif account.company
+            serialize_company(xml, account.company)
+          end
+        }
+      end
+
+      def serialize_person(xml, person)
+        return unless person
+
+        xml.send(:person) {
+          xml.send(:name, person.name) if person.name
+          xml.send(:birthDate, person.birth_date.to_s) if person.birth_date
+          serialize_address(xml, person.address)
+          serialize_documents(xml, person.documents)
+          serialize_phones(xml, person.phones)
+        }
+      end
+
+      def serialize_company(xml, company)
+        return unless company
+
+        xml.send(:company) {
+          xml.send(:name, company.name) if company.name
+          xml.send(:displayName, company.display_name) if company.display_name
+          xml.send(:websiteURL, company.website_url) if company.website_url
+          serialize_partner(xml, company.partner)
+          serialize_phones(xml, company.phones)
+          serialize_documents(xml, company.documents)
+          serialize_address(xml, company.address)
+        }
+      end
+
+      def serialize_address(xml, address)
+        return unless address
+
+        xml.send(:address) {
+          xml.send(:postalCode, address.postal_code) if address.postal_code
+          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
+        }
+      end
+
+      def serialize_phones(xml, phones)
+        return unless phones.any?
+
+        xml.send(:phones) {
+          phones.each do |phone|
+            xml.send(:phone) {
+              xml.send(:type, phone.type)
+              xml.send(:areaCode, phone.area_code)
+              xml.send(:number, phone.number)
+            }
+          end
+        }
+      end
+
+      def serialize_documents(xml, documents)
+        return unless documents.any?
+
+        xml.send(:documents) {
+          documents.each do |document|
+            xml.send(:document) {
+              xml.send(:type, document.type)
+              xml.send(:value, document.value)
+            }
+          end
+        }
+      end
+
+      def serialize_partner(xml, partner)
+        return unless partner
+
+        xml.send(:partner) {
+          xml.send(:name, partner.name) if partner.name
+          xml.send(:birthDate, partner.birth_date.to_s) if partner.birth_date
+          serialize_documents(xml, partner.documents)
+        }
+      end
+    end
+  end
+end