paypal-sdk-rest 0.10.0 → 1.0.0

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

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

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

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

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

@@ -0,0 +1,11 @@
+module PayPal
+  module SDK
+    module Core
+      module Util
+        autoload :OauthSignature, "paypal-sdk/core/util/oauth_signature"
+        autoload :OrderedHash,    "paypal-sdk/core/util/ordered_hash"
+        autoload :HTTPHelper,     "paypal-sdk/core/util/http_helper"
+      end
+    end
+  end
+end

data/lib/paypal-sdk/core/util/http_helper.rb

@@ -0,0 +1,159 @@
+require 'net/https'
+require 'uri'
+require 'cgi'
+
+module PayPal::SDK::Core
+  module Util
+    module HTTPHelper
+
+      include Configuration
+      include Logging
+      include Authentication
+      include Exceptions
+
+      # Create HTTP connection based on given service name or configured end point
+      def create_http_connection(uri)
+        new_http(uri).tap do |http|
+          if config.http_timeout
+            http.open_timeout = config.http_timeout
+            http.read_timeout = config.http_timeout
+          end
+          configure_ssl(http) if uri.scheme == "https"
+        end
+      end
+
+      # New raw HTTP object
+      def new_http(uri)
+        if config.http_proxy
+          proxy = URI.parse(config.http_proxy)
+          Net::HTTP.new(uri.host, uri.port, proxy.host, proxy.port, proxy.user, proxy.password)
+        else
+          Net::HTTP.new(uri.host, uri.port)
+        end
+      end
+
+      # Default ca file
+      def default_ca_file
+        File.expand_path("../../../../../data/paypal.crt", __FILE__)
+      end
+
+      # Apply ssl configuration to http object
+      def configure_ssl(http)
+        http.tap do |https|
+          https.use_ssl = true
+          https.ca_file = default_ca_file
+          https.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          config.ssl_options.each do |key, value|
+            http.send("#{key}=", value)
+          end
+          add_certificate(https)
+        end
+      end
+
+      # Join url
+      def url_join(path, action)
+        path.sub(/\/?$/, "/#{action}")
+      end
+
+      # Make Http call
+      # * payload - Hash(:http, :method, :uri, :body, :header)
+      def http_call(payload)
+        if Config.config.verbose_logging
+          logger.info payload.inspect
+        end
+
+        response =
+          log_http_call(payload) do
+            http = payload[:http] || create_http_connection(payload[:uri])
+            http.start do |session|
+              if [ :get, :delete, :head ].include? payload[:method]
+                session.send(payload[:method], payload[:uri].request_uri, payload[:header])
+              else
+                session.send(payload[:method], payload[:uri].request_uri, payload[:body], payload[:header])
+              end
+            end
+          end
+
+        if Config.config.verbose_logging
+          if response.code.to_i == 200
+            logger.info(response.body)
+          else
+            logger.warn(response.body)
+          end
+        end
+
+        handle_response(response)
+      end
+
+      # Log Http call
+      # * payload - Hash(:http, :method, :uri, :body, :header)
+      def log_http_call(payload)
+        logger.info "Request[#{payload[:method]}]: #{payload[:uri].to_s}"
+        start_time = Time.now
+        response = yield
+        logger.info sprintf("Response[%s]: %s, Duration: %.3fs", response.code,
+          response.message, Time.now - start_time)
+        response
+      end
+
+      # Generate header based on given header keys and properties
+      # === Arguments
+      # * <tt>header_keys</tt> -- List of Header keys for the properties
+      # * <tt>properties</tt>  -- properties
+      # === Return
+      #  Hash with header as key property as value
+      # === Example
+      # map_header_value( { :username => "X-PAYPAL-USERNAME"}, { :username => "guest" })
+      # # Return: { "X-PAYPAL-USERNAME" => "guest" }
+      def map_header_value(header_keys, properties)
+        header = {}
+        properties.each do |key, value|
+          key = header_keys[key]
+          header[key] = value.to_s if key and value
+        end
+        header
+      end
+
+      def encode_www_form(hash)
+        if defined? URI.encode_www_form
+          URI.encode_www_form(hash)
+        else
+          hash.map{|key, value| "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}" }.join("&")
+        end
+      end
+
+      # Handles response and error codes from the remote service.
+      def handle_response(response)
+        case response.code.to_i
+          when 301, 302, 303, 307
+            raise(Redirection.new(response))
+          when 200...400
+            response
+          when 400
+            raise(BadRequest.new(response))
+          when 401
+            raise(UnauthorizedAccess.new(response))
+          when 403
+            raise(ForbiddenAccess.new(response))
+          when 404
+            raise(ResourceNotFound.new(response))
+          when 405
+            raise(MethodNotAllowed.new(response))
+          when 409
+            raise(ResourceConflict.new(response))
+          when 410
+            raise(ResourceGone.new(response))
+          when 422
+            raise(ResourceInvalid.new(response))
+          when 401...500
+            raise(ClientError.new(response))
+          when 500...600
+            raise(ServerError.new(response))
+          else
+            raise(ConnectionError.new(response, "Unknown response code: #{response.code}"))
+        end
+      end
+
+    end
+  end
+end

data/lib/paypal-sdk/core/util/oauth_signature.rb

@@ -0,0 +1,64 @@
+require 'uri'
+require 'cgi'
+require 'openssl'
+require 'base64'
+
+module PayPal::SDK::Core
+  module Util
+    class OauthSignature
+      attr_accessor :username, :password, :token, :token_secret, :url, :timestamp
+
+      def initialize(username, password, token, token_secret, url, timestamp = nil)
+        @username = username
+        @password = password
+        @token = token
+        @token_secret = token_secret
+        @url = url
+        @timestamp = timestamp || Time.now.to_i.to_s
+      end
+
+      def authorization_string
+        signature = oauth_signature
+        "token=#{token},signature=#{signature},timestamp=#{timestamp}"
+      end
+
+      def oauth_signature
+        key = [
+          paypal_encode(password),
+          paypal_encode(token_secret),
+        ].join("&").gsub(/%[0-9A-F][0-9A-F]/, &:downcase )
+
+        digest = OpenSSL::HMAC.digest('sha1', key, base_string)
+        Base64.encode64(digest).chomp
+      end
+
+      def base_string
+        params = {
+          "oauth_consumer_key" => username,
+          "oauth_version" => "1.0",
+          "oauth_signature_method" => "HMAC-SHA1",
+          "oauth_token" => token,
+          "oauth_timestamp" => timestamp,
+        }
+        sorted_query_string = params.sort.map{|v| v.join("=") }.join("&")
+
+        base = [
+          "POST",
+          paypal_encode(url),
+          paypal_encode(sorted_query_string)
+        ].join("&")
+        base = base.gsub(/%[0-9A-F][0-9A-F]/, &:downcase )
+      end
+
+      # The PayPalURLEncoder java class percent encodes everything other than 'a-zA-Z0-9 _'.
+      # Then it converts ' ' to '+'.
+      # Ruby's CGI.encode takes care of the ' ' and '*' to satisfy PayPal
+      # (but beware, URI.encode percent encodes spaces, and does nothing with '*').
+      # Finally, CGI.encode does not encode '.-', which we need to do here.
+      def paypal_encode str
+        CGI.escape(str.to_s).gsub('.', '%2E').gsub('-', '%2D')
+      end
+    end
+  end
+end
+

data/lib/paypal-sdk/core/util/ordered_hash.rb

@@ -0,0 +1,165 @@
+module PayPal::SDK::Core
+  module Util
+    class OrderedHash < ::Hash #:nodoc:
+
+      def to_yaml_type
+        "!tag:yaml.org,2002:map"
+      end
+
+      # Hash is ordered in Ruby 1.9!
+      if RUBY_VERSION < '1.9'
+
+        # In MRI the Hash class is core and written in C. In particular, methods are
+        # programmed with explicit C function calls and polymorphism is not honored.
+        #
+        # For example, []= is crucial in this implementation to maintain the @keys
+        # array but hash.c invokes rb_hash_aset() originally. This prevents method
+        # reuse through inheritance and forces us to reimplement stuff.
+        #
+        # For instance, we cannot use the inherited #merge! because albeit the algorithm
+        # itself would work, our []= is not being called at all by the C code.
+
+        def initialize(*args, &block)
+          super
+          @keys = []
+        end
+
+        def self.[](*args)
+          ordered_hash = new
+
+          if (args.length == 1 && args.first.is_a?(Array))
+            args.first.each do |key_value_pair|
+              next unless (key_value_pair.is_a?(Array))
+              ordered_hash[key_value_pair[0]] = key_value_pair[1]
+            end
+
+            return ordered_hash
+          end
+
+          unless (args.size % 2 == 0)
+            raise ArgumentError.new("odd number of arguments for Hash")
+          end
+
+          args.each_with_index do |val, ind|
+            next if (ind % 2 != 0)
+            ordered_hash[val] = args[ind + 1]
+          end
+
+          ordered_hash
+        end
+
+        def initialize_copy(other)
+          super
+          # make a deep copy of keys
+          @keys = other.keys
+        end
+
+        def []=(key, value)
+          @keys << key if !has_key?(key)
+          super
+        end
+
+        def delete(key)
+          if has_key? key
+            index = @keys.index(key)
+            @keys.delete_at index
+          end
+          super
+        end
+
+        def delete_if
+          super
+          sync_keys!
+          self
+        end
+
+        def reject!
+          super
+          sync_keys!
+          self
+        end
+
+        def reject(&block)
+          dup.reject!(&block)
+        end
+
+        def keys
+          @keys.dup
+        end
+
+        def values
+          @keys.collect { |key| self[key] }
+        end
+
+        def to_hash
+          self
+        end
+
+        def to_a
+          @keys.map { |key| [ key, self[key] ] }
+        end
+
+        def each_key
+          @keys.each { |key| yield key }
+        end
+
+        def each_value
+          @keys.each { |key| yield self[key]}
+        end
+
+        def each
+          @keys.each {|key| yield [key, self[key]]}
+        end
+
+        alias_method :each_pair, :each
+
+        def clear
+          super
+          @keys.clear
+          self
+        end
+
+        def shift
+          k = @keys.first
+          v = delete(k)
+          [k, v]
+        end
+
+        def merge!(other_hash)
+          if block_given?
+            other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
+          else
+            other_hash.each { |k, v| self[k] = v }
+          end
+          self
+        end
+
+        alias_method :update, :merge!
+
+        def merge(other_hash, &block)
+          dup.merge!(other_hash, &block)
+        end
+
+        # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+        def replace(other)
+          super
+          @keys = other.keys
+          self
+        end
+
+        def invert
+          OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
+        end
+
+        def inspect
+          "#<OrderedHash #{super}>"
+        end
+
+        private
+          def sync_keys!
+            @keys.delete_if {|k| !has_key?(k)}
+          end
+      end
+    end
+  end
+end