paypal-sdk-rest 1.7.3 → 2.0.0.rc2

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/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.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

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