paypal-sdk-rest-pmrb 1.8.0

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

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

@@ -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,171 @@
+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
+          begin
+            https.ssl_version = :TLSv1_2
+          rescue => error
+            logger.warn("WARNING: Your system does not support TLSv1.2. Per PCI Security Council mandate (https://github.com/paypal/TLS-update), you MUST update to latest security library.")
+          end
+          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)
+        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
+
+        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}"
+
+        logger.debug "Request.body=#{payload[:body]}\trequest.header=#{payload[:header]}"
+
+        start_time = Time.now
+        response = yield
+        logger.info sprintf("Response[%s]: %s, Duration: %.3fs", response.code,
+          response.message, Time.now - start_time)
+
+        logger.add(
+          response_details_log_level(response),
+          "Response.body=#{response.body}\tResponse.header=#{response.to_hash}"
+        )
+
+        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
+
+      private
+
+      def response_details_log_level(response)
+        if (400...600).cover?(response.code.to_i)
+          Logger::WARN
+        else
+          Logger::DEBUG
+        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
+