paypal-sdk-rest-pmrb 1.8.0

data/lib/paypal-sdk/core/credential.rb

@@ -0,0 +1,16 @@
+module PayPal
+  module SDK
+    module Core
+      module Credential
+        autoload :Base,         "paypal-sdk/core/credential/base"
+        autoload :Certificate,  "paypal-sdk/core/credential/certificate"
+        autoload :Signature,    "paypal-sdk/core/credential/signature"
+
+        module ThirdParty
+          autoload :Token,    "paypal-sdk/core/credential/third_party/token"
+          autoload :Subject,  "paypal-sdk/core/credential/third_party/subject"
+        end
+      end
+    end
+  end
+end

data/lib/paypal-sdk/core/credential/base.rb

@@ -0,0 +1,27 @@
+module PayPal::SDK::Core
+  module Credential
+
+    # Base credential Class for authentication
+    class Base
+      attr_accessor :username, :password, :app_id, :device_ipaddress, :sandbox_email_address
+
+      # Initialize authentication configurations
+      # === Arguments
+      #  * <tt>config</tt> -- Configuration object
+      def initialize(config)
+        self.username = config.username
+        self.password = config.password
+        self.app_id   = config.app_id
+        self.device_ipaddress = config.device_ipaddress
+        self.sandbox_email_address = config.sandbox_email_address
+      end
+
+      # Return credential properties
+      def properties
+        { :username => username, :password => password, :app_id => app_id,
+          :device_ipaddress => device_ipaddress, :sandbox_email_address => sandbox_email_address }
+      end
+
+    end
+  end
+end

data/lib/paypal-sdk/core/credential/certificate.rb

@@ -0,0 +1,32 @@
+module PayPal::SDK::Core
+  module Credential
+
+    # Certificate class for SSL Certificate authentication
+    class Certificate < Base
+
+      attr_reader :cert_path
+
+      def initialize(config)
+        super
+        @cert_path = config.cert_path
+      end
+
+      # Return SSL certificate
+      def cert
+        @cert ||= OpenSSL::X509::Certificate.new(cert_content)
+      end
+
+      # Return SSL certificate key
+      def key
+        @key  = OpenSSL::PKey::RSA.new(cert_content)
+      end
+
+      private
+      # Return certificate content from the configured file.
+      def cert_content
+        @cert_content ||= File.read(cert_path)
+      end
+
+    end
+  end
+end

data/lib/paypal-sdk/core/credential/signature.rb

@@ -0,0 +1,22 @@
+module PayPal::SDK::Core
+  module Credential
+    class Signature < Base
+
+      attr_accessor :signature
+
+      # Initialize configuration
+      # === Argument
+      # * <tt>config</tt> -- Configuration object
+      def initialize(config)
+        super
+        self.signature = config.signature
+      end
+
+      # Return properties for authentication
+      def properties
+        super.merge({ :signature => signature })
+      end
+
+    end
+  end
+end

data/lib/paypal-sdk/core/credential/third_party/subject.rb

@@ -0,0 +1,25 @@
+module PayPal::SDK::Core
+  module Credential
+    module ThirdParty
+      class Subject
+
+        attr_accessor :subject, :credential
+
+        # Initialize configuration
+        # === Arguments
+        # * <tt>credential</tt> -- Credential object
+        # * <tt>config</tt> -- Configuration object
+        def initialize(credential, config)
+          @credential   = credential
+          @subject      = config.subject
+        end
+
+        # Return properties for authentication.
+        def properties
+          credential.properties.merge( :subject => subject )
+        end
+
+      end
+    end
+  end
+end

data/lib/paypal-sdk/core/credential/third_party/token.rb

@@ -0,0 +1,39 @@
+module PayPal::SDK::Core
+  module Credential
+    module ThirdParty
+      class Token
+
+        attr_accessor :token, :token_secret, :credential, :url
+
+        # Initialize Token credentials
+        # === Arguments
+        # * <tt>credential</tt> -- Credential Object
+        # * <tt>config</tt> -- Configuration object
+        # * <tt>url</tt> -- Request url
+        def initialize(credential, config, url)
+          @credential   = credential
+          @token        = config.token
+          @token_secret = config.token_secret
+          @url          = url
+        end
+
+        RemoveProperties = [ :username, :password, :signature ]
+
+        # Return credential properties for authentication.
+        def properties
+          credential_properties = credential.properties
+          credential_properties.delete_if{|k,v| RemoveProperties.include? k }
+          credential_properties.merge( :authorization => oauth_authentication )
+        end
+
+        private
+        # Return OAuth authentication string.
+        def oauth_authentication
+          Util::OauthSignature.new(credential.username, credential.password, token, token_secret, url).
+            authorization_string
+        end
+
+      end
+    end
+  end
+end

data/lib/paypal-sdk/core/exceptions.rb

@@ -0,0 +1,112 @@
+require 'json'
+require 'pp'
+
+module PayPal::SDK::Core
+  module Exceptions
+    class ConnectionError < StandardError # :nodoc:
+      attr_reader :response
+
+      def initialize(response, message = nil)
+        @response = response
+        @message  = message
+      end
+
+      def to_s
+        begin
+          response_body = JSON.parse(response.body)
+          debug_id = response["paypal-debug-id"]
+          debug_id = response["correlation-id"] if debug_id.to_s == ''
+          debug_id = response_body["debug_id"] if debug_id.to_s == ''
+        rescue
+        end
+        message = "Failed."
+        message << "  Response code = #{response.code}." if response.respond_to?(:code)
+        message << "  Response message = #{response.message}." if response.respond_to?(:message)
+        message << "  Response debug ID = #{debug_id}." if debug_id
+        message
+      end
+    end
+
+    # Raised when a Timeout::Error occurs.
+    class TimeoutError < ConnectionError
+      def initialize(message)
+        @message = message
+      end
+      def to_s; @message ;end
+    end
+
+    # Raised when a OpenSSL::SSL::SSLError occurs.
+    class SSLError < ConnectionError
+      def initialize(message)
+        @message = message
+      end
+      def to_s; @message ;end
+    end
+
+    # 3xx Redirection
+    class Redirection < ConnectionError # :nodoc:
+      def to_s
+        response['Location'] ? "#{super} => #{response['Location']}" : super
+      end
+    end
+
+    class MissingParam < ArgumentError # :nodoc:
+    end
+
+    class MissingConfig < StandardError # :nodoc:
+    end
+
+    # 4xx Client Error
+    class ClientError < ConnectionError # :nodoc:
+    end
+
+    # 400 Bad Request
+    class BadRequest < ClientError # :nodoc:
+    end
+
+    # 401 Unauthorized
+    class UnauthorizedAccess < ClientError # :nodoc:
+    end
+
+    # 403 Forbidden
+    class ForbiddenAccess < ClientError # :nodoc:
+    end
+
+    # 404 Not Found
+    class ResourceNotFound < ClientError # :nodoc:
+    end
+
+    # 409 Conflict
+    class ResourceConflict < ClientError # :nodoc:
+    end
+
+    # 410 Gone
+    class ResourceGone < ClientError # :nodoc:
+    end
+
+    # 422 Unprocessable Entity
+    class ResourceInvalid < ClientError # :nodoc:
+    end
+
+    # 5xx Server Error
+    class ServerError < ConnectionError # :nodoc:
+    end
+
+    # 405 Method Not Allowed
+    class MethodNotAllowed < ClientError # :nodoc:
+      def allowed_methods
+        @response['Allow'].split(',').map { |verb| verb.strip.downcase.to_sym }
+      end
+    end
+
+    # API error: returned as 200 + "error" key in response.
+    class UnsuccessfulApiCall < RuntimeError
+      attr_reader :api_error
+
+      def initialize(api_error)
+        super(api_error['message'])
+        @api_error = api_error
+      end
+    end
+  end
+end

data/lib/paypal-sdk/core/logging.rb

@@ -0,0 +1,50 @@
+require 'logger'
+
+module PayPal::SDK::Core
+
+  # Include Logging module to provide logger functionality.
+  # == Configure logger
+  #   Logging.logger = Logger.new(STDERR)
+  #
+  # == Example
+  #   include Logger
+  #   logger.info "Debug message"
+  module Logging
+
+    # Get logger object
+    def logger
+      @logger ||= Logging.logger
+    end
+
+    def log_event(message, &block)
+      start_time = Time.now
+      block.call
+    ensure
+      logger.info sprintf("[%.3fs] %s", Time.now - start_time, message)
+    end
+
+    class << self
+
+      # Get or Create configured logger based on the default environment configuration
+      def logger
+        @logger ||= Logger.new(STDERR)
+      end
+
+      # Set logger directly and clear the loggers cache.
+      # === Attributes
+      # * <tt>logger</tt> -- Logger object
+      # === Example
+      #   Logging.logger = Logger.new(STDERR)
+      def logger=(logger)
+        @logger = logger
+        if Config.config.mode.eql? 'live' and @logger.level == Logger::DEBUG
+          @logger.warn "DEBUG log level not allowed in sandbox mode for security of confidential information. Changing log level to INFO..."
+          @logger.level = Logger::INFO
+        end
+      end
+
+    end
+  end
+
+end
+

data/lib/paypal-sdk/core/openid_connect.rb

@@ -0,0 +1,140 @@
+
+module PayPal::SDK
+  module Core
+    module OpenIDConnect
+      autoload :API,             "paypal-sdk/core/openid_connect/api"
+      autoload :SetAPI,          "paypal-sdk/core/openid_connect/set_api"
+      autoload :GetAPI,          "paypal-sdk/core/openid_connect/get_api"
+      autoload :RequestDataType, "paypal-sdk/core/openid_connect/request_data_type"
+      autoload :DataTypes,       "paypal-sdk/core/openid_connect/data_types"
+
+      include DataTypes
+
+      class << self
+        def api
+          RequestDataType.api
+        end
+
+        def set_config(*args)
+          RequestDataType.set_config(*args)
+        end
+        alias_method :config=, :set_config
+
+        AUTHORIZATION_URL  = "paypal.com/signin/authorize"
+        ENDSESSION_URL     = "paypal.com/webapps/auth/protocol/openidconnect/v1/endsession"
+        DEFAULT_SCOPE      = "openid"
+
+        def authorize_url(params = {})
+          uri = URI(url_for_mode(AUTHORIZATION_URL))
+          uri.query = api.encode_www_form({
+            :response_type => "code",
+            :scope => DEFAULT_SCOPE,
+            :client_id => RequestDataType.client_id,
+            :redirect_uri => api.config.openid_redirect_uri
+          }.merge(params))
+          uri.to_s
+        end
+
+        def logout_url(params = {})
+          uri = URI(url_for_mode(ENDSESSION_URL))
+          uri.query = api.encode_www_form({
+            :logout   => "true",
+            :redirect_uri => api.config.openid_redirect_uri
+          }.merge(params))
+          uri.to_s
+        end
+
+        private
+
+        def url_for_mode(url)
+          "https://www.#{"sandbox." if api.api_mode == :sandbox}#{url}"
+        end
+      end
+
+      module DataTypes
+        class Tokeninfo < Base
+          include RequestDataType
+          PATH = "v1/identity/openidconnect/tokenservice"
+          FP_PATH = "v1/oauth2/token"
+
+          class << self
+
+            def basic_auth_header(options)
+              credentials = options[:client_id].to_s + ":" + options[:client_secret].to_s
+              encoded = Base64.encode64(credentials.force_encoding('UTF-8')).gsub!(/\n/, "")
+              "Basic #{encoded}"
+            end
+
+            def create_from_authorization_code(options, http_header = {})
+              options = { :code => options } if options.is_a? String
+              options = options.merge( :grant_type => "authorization_code" )
+              Tokeninfo.new(api.post(PATH, with_credentials(options), http_header))
+            end
+            alias_method :create, :create_from_authorization_code
+
+            def create_from_refresh_token(options, http_header = {})
+              options = { :refresh_token => options } if options.is_a? String
+              options = options.merge( :grant_type => "refresh_token" )
+              http_header = http_header.merge( { "Content-Type" => "application/x-www-form-urlencoded", "Authorization" => basic_auth_header(with_credentials(options)) } )
+              Tokeninfo.new(api.post(PATH, options, http_header))
+            end
+            alias_method :refresh, :create_from_refresh_token
+
+            def create_from_future_payment_auth_code(options, http_header = {})
+              options = { :code => options } if options.is_a? String
+              options = options.merge( { :grant_type => "authorization_code", :response_type => "token", :redirect_uri => "urn:ietf:wg:oauth:2.0:oob" } )
+              http_header = http_header.merge( { "Content-Type" => "application/x-www-form-urlencoded", "Authorization" => basic_auth_header(with_credentials(options)) } )
+              Tokeninfo.new(api.post(FP_PATH, options, http_header))
+            end
+            alias_method :token_hash, :create_from_future_payment_auth_code
+            alias_method :create_fp, :create_from_future_payment_auth_code
+
+            def with_credentials(options = {})
+              options = options.dup
+              [ :client_id, :client_secret ].each do |key|
+                options[key] = self.send(key) unless options[key] or options[key.to_s]
+              end
+              options
+            end
+
+            def authorize_url(options = {})
+              OpenIDConnect.authorize_url(options)
+            end
+          end
+
+          def refresh(options = {})
+            tokeninfo = self.class.refresh({
+              :refresh_token => self.refresh_token}.merge(options))
+            self.merge!(tokeninfo.to_hash)
+          end
+
+          def userinfo(options = {})
+            Userinfo.get({ :access_token => self.access_token }.merge(options))
+          end
+
+          def logout_url(options = {})
+            OpenIDConnect.logout_url({ :id_token => self.id_token }.merge(options))
+          end
+
+        end
+
+        class Userinfo < Base
+          include RequestDataType
+          PATH = "v1/identity/openidconnect/userinfo"
+
+          class << self
+            def get_userinfo(options = {}, http_header = {})
+              options = { :access_token => options } if options.is_a? String
+              options = options.merge( :schema => "openid" ) unless options[:schema] or options["schema"]
+              Userinfo.new(api.post(PATH, options, http_header))
+            end
+            alias_method :get, :get_userinfo
+          end
+        end
+      end
+    end
+  end
+
+  # Alias for the Core::OpenIDConnect constant
+  OpenIDConnect = Core::OpenIDConnect
+end