paypal-sdk-rest 1.7.6 → 2.0.0.rc1

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

@@ -1,32 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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/credential.rb

@@ -1,16 +0,0 @@
-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/exceptions.rb

@@ -1,112 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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/api.rb

@@ -1,50 +0,0 @@
-require 'multi_json'
-require 'paypal-sdk/rest/version'
-
-module PayPal::SDK
-  module Core
-    module OpenIDConnect
-      class API < Core::API::Base
-
-        DEFAULT_OPENID_ENDPOINT = {
-          :sandbox => "https://api.sandbox.paypal.com",
-          :live => "https://api.paypal.com" }
-
-        def initialize(environment = nil, options = {})
-          super("", environment, options)
-        end
-
-        def service_endpoint
-          self.config.openid_endpoint || DEFAULT_OPENID_ENDPOINT[self.api_mode] || DEFAULT_OPENID_ENDPOINT[:sandbox]
-        end
-
-        def format_request(payload)
-          payload[:uri].path = url_join(payload[:uri].path, payload[:action])
-          payload[:body]    = encode_www_form(payload[:params]) if payload[:params]
-          payload[:header]  = {"Content-Type" => "application/x-www-form-urlencoded" }.merge(payload[:header])
-          payload
-        end
-
-        def format_response(payload)
-          payload[:data] =
-            if payload[:response].code >= "200" and payload[:response].code <= "299"
-              MultiJson.load(payload[:response].body)
-            elsif payload[:response].content_type == "application/json"
-              { "error" => MultiJson.load(payload[:response].body) }
-            else
-              { "error" => { "name" => payload[:response].code, "message" => payload[:response].message,
-                "developer_msg" => payload[:response] } }
-            end
-          payload
-        end
-
-        class << self
-          def user_agent
-            @user_agent ||= "PayPalSDK/openid-connect-ruby #{PayPal::SDK::REST::VERSION} (#{sdk_library_details})"
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,73 +0,0 @@
-require 'paypal-sdk-core'
-
-module PayPal::SDK::Core
-  module OpenIDConnect
-    module DataTypes
-      class Base < PayPal::SDK::Core::API::DataTypes::Base
-      end
-
-      class Address < Base
-        def self.load_members
-          object_of :street_address, String
-          object_of :locality, String
-          object_of :region, String
-          object_of :postal_code, String
-          object_of :country, String
-        end
-      end
-
-      class Userinfo < Base
-        def self.load_members
-          object_of :user_id, String
-          object_of :sub, String
-          object_of :name, String
-          object_of :given_name, String
-          object_of :family_name, String
-          object_of :middle_name, String
-          object_of :picture, String
-          object_of :email, String
-          object_of :email_verified, Boolean
-          object_of :gender, String
-          object_of :birthday, String
-          object_of :zoneinfo, String
-          object_of :locale, String
-          object_of :language, String
-          object_of :verified, Boolean
-          object_of :phone_number, String
-          object_of :address, Address
-          object_of :verified_account, Boolean
-          object_of :account_type, String
-          object_of :account_creation_date, String
-          object_of :age_range, String
-          object_of :payer_id, String
-        end
-      end
-
-      class Tokeninfo < Base
-        def self.load_members
-          object_of :scope, String
-          object_of :access_token, String
-          object_of :refresh_token, String
-          object_of :token_type, String
-          object_of :id_token, String
-          object_of :expires_in, Integer
-        end
-      end
-
-      class Error < Base
-        def self.load_members
-          object_of :error, String
-          object_of :error_description, String
-          object_of :error_uri, String
-        end
-      end
-
-
-      constants.each do |data_type_klass|
-        data_type_klass = const_get(data_type_klass)
-        data_type_klass.load_members if defined? data_type_klass.load_members
-      end
-
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-module PayPal::SDK
-  module Core
-    module OpenIDConnect
-      module GetAPI
-        # Get API object
-        # === Example
-        #   Payment.api
-        #   payment.api
-        def api
-          @api || parent_api
-        end
-
-        # Parent API object
-        def parent_api
-          superclass.respond_to?(:api) ? superclass.api : RequestDataType.api
-        end
-
-        def client_id
-          api.config.openid_client_id || api.config.client_id
-        end
-
-        def client_secret
-          api.config.openid_client_secret || api.config.client_secret
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-module PayPal::SDK
-  module Core
-    module OpenIDConnect
-      module RequestDataType
-
-        # Get a local API object or Class level API object
-        def api
-          @api || self.class.api
-        end
-
-        class << self
-          # Global API object
-          # === Example
-          #   RequestDataType.api
-          def api
-            @api ||= API.new({})
-          end
-
-          def client_id
-            api.config.openid_client_id || api.config.client_id
-          end
-
-          def client_secret
-            api.config.openid_client_secret || api.config.client_secret
-          end
-
-          # Setter for RequestDataType.api
-          # === Example
-          #   RequestDataType.set_config(..)
-          include SetAPI
-
-          # Configure depended module, when RequestDataType is include.
-          # === Example
-          #   class Payment < DataTypes
-          #     include RequestDataType
-          #   end
-          #   Payment.set_config(..)
-          #   payment.set_config(..)
-          #   Payment.api
-          #   payment.api
-          def included(klass)
-            klass.class_eval do
-              extend GetAPI
-              extend SetAPI
-              include SetAPI
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,36 +0,0 @@
-module PayPal::SDK
-  module Core
-    module OpenIDConnect
-      module SetAPI
-        # Set new api
-        # === Examples
-        #   payment.set_config(:development)
-        #   payment.set_config(:client_id => "XYZ", :client_secret => "SECRET")
-        #   payment.set_config
-        #   payment.api = API.new(:development)
-        def set_config(*args)
-          if args[0].is_a?(API)
-            @api = args[0]
-          else
-            @api ||= API.new({})
-            @api.set_config(*args)  # Just override the configuration and Not
-            @api
-          end
-        end
-        alias_method :config=, :set_config
-        alias_method :set_api, :set_config
-        alias_method :api=, :set_config
-
-        # Override client id
-        def client_id=(client_id)
-          set_config(:client_id => client_id)
-        end
-
-        # Override client secret
-        def client_secret=(client_secret)
-          set_config(:client_secret => client_secret)
-        end
-      end
-    end
-  end
-end

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

@@ -1,140 +0,0 @@
-
-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