paypal-sdk-rest 0.10.0 → 1.0.0

data/lib/paypal-sdk/core/api/data_types/enum.rb

@@ -0,0 +1,26 @@
+module PayPal::SDK::Core
+  module API
+    module DataTypes
+
+      class Enum < SimpleTypes::String
+        class << self
+          def options
+            @options ||= []
+          end
+
+          def options=(options)
+            if options.is_a? Hash
+              options.each do |const_name, value|
+                const_set(const_name, value)
+              end
+              @options = options.values
+            else
+              @options = options
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/paypal-sdk/core/api/data_types/simple_types.rb

@@ -0,0 +1,52 @@
+require 'date'
+
+module PayPal::SDK::Core
+  module API
+    module DataTypes
+
+      module SimpleTypes
+        class String < ::String
+          def self.new(string = "")
+            string.is_a?(::String) ? super : super(string.to_s)
+          end
+
+          def to_yaml_type
+            "!tag:yaml.org,2002:str"
+          end
+        end
+
+        class Integer < ::Integer
+          def self.new(number)
+            number.to_i
+          end
+        end
+
+        class Float < ::Float
+          def self.new(float)
+            float.to_f
+          end
+        end
+
+        class Boolean
+          def self.new(boolean)
+            ( boolean == 0 || boolean == "" || boolean =~ /^(false|f|no|n|0)$/i ) ? false : !!boolean
+          end
+        end
+
+        class Date < ::Date
+          def self.new(date)
+            date.is_a?(::Date) ? date : Date.parse(date.to_s)
+          end
+        end
+
+        class DateTime < ::DateTime
+          def self.new(date_time)
+            date_time = "0001-01-01T00:00:00" if date_time.to_s == "0"
+            date_time.is_a?(::DateTime) ? date_time : parse(date_time.to_s)
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+module PayPal
+  module SDK
+    module Core
+      module API
+        module IPN
+
+          END_POINTS = {
+            :sandbox => "https://www.sandbox.paypal.com/cgi-bin/webscr",
+            :live    => "https://ipnpb.paypal.com/cgi-bin/webscr"
+          }
+          VERIFIED   = "VERIFIED"
+          INVALID    = "INVALID"
+
+          class Message
+            include Util::HTTPHelper
+
+            attr_accessor :message
+
+            def initialize(message, env = nil, options = {})
+              @message = message
+              set_config(env, options)
+            end
+
+            # Fetch end point
+            def ipn_endpoint
+              config.ipn_endpoint || default_ipn_endpoint
+            end
+
+            # Default IPN end point
+            def default_ipn_endpoint
+              endpoint = END_POINTS[(config.mode || :sandbox).to_sym] rescue nil
+              endpoint || END_POINTS[:sandbox]
+            end
+
+            # Request IPN service for validating the content
+            # === Return
+            # return http response object
+            def request
+              uri  = URI(ipn_endpoint)
+              query_string = "cmd=_notify-validate&#{message}"
+              http_call(:method => :post, :uri => uri, :body => query_string)
+            end
+
+            # Validate the given content
+            # === Return
+            # return true or false
+            def valid?
+              request.body == VERIFIED
+            end
+          end
+
+          class << self
+            def valid?(*args)
+              Message.new(*args).valid?
+            end
+
+            def request(*args)
+              Message.new(*args).request
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+require 'multi_json'
+
+module PayPal::SDK::Core
+  module API
+    class REST < Base
+      NVP_AUTH_HEADER = {
+        :sandbox_email_address => "X-PAYPAL-SANDBOX-EMAIL-ADDRESS",
+        :device_ipaddress      => "X-PAYPAL-DEVICE-IPADDRESS"
+      }
+      DEFAULT_HTTP_HEADER = {
+        "Content-Type" => "application/json"
+      }
+
+      DEFAULT_REST_END_POINTS = {
+        :sandbox => "https://api.sandbox.paypal.com",
+        :live    => "https://api.paypal.com"
+      }
+      TOKEN_REQUEST_PARAMS = "grant_type=client_credentials"
+
+      # Get REST service end point
+      def service_endpoint
+        config.rest_endpoint || super || DEFAULT_REST_END_POINTS[api_mode]
+      end
+
+      # Token endpoint
+      def token_endpoint
+        config.rest_token_endpoint || service_endpoint
+      end
+
+      # Clear cached values.
+      def set_config(*args)
+        @token_uri = nil
+        @token_hash = nil
+        super
+      end
+
+      # URI object token endpoint
+      def token_uri
+        @token_uri ||=
+          begin
+            new_uri = URI.parse(token_endpoint)
+            new_uri.path = "/v1/oauth2/token" if new_uri.path =~ /^\/?$/
+            new_uri
+          end
+      end
+
+      # Generate Oauth token or Get cached
+      def token_hash(auth_code=nil)
+        validate_token_hash
+        @token_hash ||=
+          begin
+            @token_request_at = Time.now
+            basic_auth = ["#{config.client_id}:#{config.client_secret}"].pack('m').delete("\r\n")
+            token_headers = default_http_header.merge({
+              "Content-Type"  => "application/x-www-form-urlencoded",
+              "Authorization" => "Basic #{basic_auth}" })
+            if auth_code != nil
+              TOKEN_REQUEST_PARAMS.replace "grant_type=authorization_code&response_type=token&redirect_uri=urn%3Aietf%3Awg%3Aoauth%3A2.0%3Aoob&code="
+              TOKEN_REQUEST_PARAMS << auth_code
+            end
+            response = http_call( :method => :post, :uri => token_uri, :body => TOKEN_REQUEST_PARAMS, :header => token_headers )
+            MultiJson.load(response.body, :symbolize_keys => true)
+          end
+      end
+      attr_writer :token_hash
+
+      # Get access token
+      def token(auth_code=nil)
+        token_hash(auth_code)[:access_token]
+      end
+
+      # Get access token type
+      def token_type
+        token_hash[:token_type] || "Bearer"
+      end
+
+      # token setter
+      def token=(new_token)
+        @token_hash = { :access_token => new_token, :token_type => "Bearer" }
+      end
+
+      # Check token expired or not
+      def validate_token_hash
+        if @token_request_at and
+            @token_hash and @token_hash[:expires_in] and
+            (Time.now - @token_request_at) > @token_hash[:expires_in].to_i
+          @token_hash = nil
+        end
+      end
+
+      # Override the API call to handle Token Expire
+      def api_call(payload)
+        backup_payload  = payload.dup
+        begin
+          response = super(payload)
+        rescue UnauthorizedAccess => error
+          if @token_hash and config.client_id
+            # Reset cached token and Retry api request
+            @token_hash = nil
+            response = super(backup_payload)
+          else
+            raise error
+          end
+        end
+        response
+      end
+
+      # Validate HTTP response
+      def handle_response(response)
+        super
+      rescue BadRequest => error
+        # Catch BadRequest to get validation error message from the response.
+        error.response
+      end
+
+      # Format request payload
+      # === Argument
+      # * payload( uri, action, params, header)
+      # === Generate
+      # * payload( uri, body, header )
+      def format_request(payload)
+        # Request URI
+        payload[:uri].path = url_join(payload[:uri].path, payload[:action])
+        # HTTP Header
+        credential_properties = credential(payload[:uri].to_s).properties
+        header = map_header_value(NVP_AUTH_HEADER, credential_properties)
+        payload[:header]  = header.merge("Authorization" => "#{token_type} #{token}").
+          merge(DEFAULT_HTTP_HEADER).merge(payload[:header])
+        # Post Data
+        payload[:body]    = MultiJson.dump(payload[:params])
+        payload
+      end
+
+      # Format response payload
+      # === Argument
+      # * payload( response )
+      # === Generate
+      # * payload( data )
+      def format_response(payload)
+        response = payload[:response]
+        payload[:data] =
+          if response.code >= "200" and response.code <= "299"
+            response.body && response.content_type == "application/json" ? MultiJson.load(response.body) : {}
+          elsif response.content_type == "application/json"
+            { "error" => MultiJson.load(response.body) }
+          else
+            { "error" => { "name" => response.code, "message" => response.message,
+              "developer_msg" => response } }
+          end
+        payload
+      end
+
+      # Log PayPal-Request-Id header
+      def log_http_call(payload)
+        if payload[:header] and payload[:header]["PayPal-Request-Id"]
+          logger.info "PayPal-Request-Id: #{payload[:header]["PayPal-Request-Id"]}"
+        end
+        super
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+
+module PayPal::SDK::Core
+
+  # Contains methods to format credentials for HTTP protocol.
+  # == Example
+  #  include Authentication
+  #  credential(url)
+  #  base_credential
+  #  third_party_credential(url)
+  #
+  #  add_certificate(http)
+  module Authentication
+
+    include Configuration
+
+    # Get credential object
+    # === Argument
+    # * <tt>url</tt> -- API request url
+    def credential(url)
+      third_party_credential(url) || base_credential
+    end
+
+    # Get base credential
+    def base_credential
+      @base_credential ||=
+        if config.cert_path
+          Credential::Certificate.new(config)
+        else
+          Credential::Signature.new(config)
+        end
+    end
+
+    # Get base credential type
+    def base_credential_type
+      config.cert_path ? :certificate : :three_token
+    end
+
+    # Get third party credential
+    def third_party_credential(url)
+      if config.token and config.token_secret
+        Credential::ThirdParty::Token.new(base_credential, config, url)
+      elsif config.subject
+        Credential::ThirdParty::Subject.new(base_credential, config)
+      end
+    end
+
+    # Clear cached variables on changing the configuration.
+    def set_config(*args)
+      @base_credential = nil
+      super
+    end
+
+    # Configure ssl certificate to HTTP object
+    # === Argument
+    # * <tt>http</tt> -- Net::HTTP object
+    def add_certificate(http)
+      if base_credential.is_a? Credential::Certificate
+        http.cert = base_credential.cert
+        http.key  = base_credential.key
+      else
+        http.cert = nil
+        http.key  = nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,249 @@
+require 'erb'
+require 'yaml'
+
+module PayPal::SDK::Core
+
+  # Include Configuration module to access configuration from any object
+  # == Examples
+  #   # Include in any class
+  #   include Configuration
+  #
+  #   # Access config object and attributes
+  #   config
+  #   config.username
+  #
+  #   # Change configuration
+  #   set_config(:development)
+  module Configuration
+
+    # To get default Config object.
+    def config
+      @config ||= Config.config
+    end
+
+    # To change the configuration to given environment or configuration
+    # === Arguments
+    # * <tt>env</tt> -- Environment
+    # * <tt>override_configurations</tt> (Optional) -- To override the default configuration.
+    # === Examples
+    #   obj.set_config(api.config)
+    #   obj.set_config(:http_timeout => 30)
+    #   obj.set_config(:development)
+    #   obj.set_config(:development, :http_timeout => 30)
+    def set_config(env, override_configurations = {})
+      @config =
+        case env
+        when Config
+          env
+        when Hash
+          begin
+            config.dup.merge!(env)
+          rescue Errno::ENOENT => error
+            Config.new(env)
+          end
+        else
+          Config.config(env, override_configurations)
+        end
+    end
+
+    alias_method :config=, :set_config
+  end
+
+  # Config class is used to hold the configurations.
+  # == Examples
+  #   # To load configurations from file
+  #   Config.load('config/paypal.yml', 'development')
+  #
+  #   # Get configuration
+  #   Config.config   # load default configuration
+  #   Config.config(:development) # load development configuration
+  #   Config.config(:development, :app_id => "XYZ") # Override configuration
+  #
+  #   # Read configuration attributes
+  #   config = Config.config
+  #   config.username
+  #   config.endpoint
+  class Config
+
+    include Logging
+    include Exceptions
+
+    attr_accessor :username, :password, :signature, :app_id, :cert_path,
+        :token, :token_secret, :subject,
+        :http_timeout, :http_proxy,
+        :device_ipaddress, :sandbox_email_address,
+        :mode, :endpoint, :merchant_endpoint, :platform_endpoint, :ipn_endpoint,
+        :rest_endpoint, :rest_token_endpoint, :client_id, :client_secret,
+        :openid_endpoint, :openid_redirect_uri, :openid_client_id, :openid_client_secret,
+        :verbose_logging
+
+    alias_method :end_point=, :endpoint=
+    alias_method :end_point, :endpoint
+    alias_method :platform_end_point=, :platform_endpoint=
+    alias_method :platform_end_point, :platform_endpoint
+    alias_method :merchant_end_point=, :merchant_endpoint=
+    alias_method :merchant_end_point, :merchant_endpoint
+    alias_method :ipn_end_point=, :ipn_endpoint=
+    alias_method :ipn_end_point, :ipn_endpoint
+    alias_method :rest_end_point, :rest_endpoint
+    alias_method :rest_end_point=, :rest_endpoint=
+    alias_method :rest_token_end_point, :rest_token_endpoint
+    alias_method :rest_token_end_point=, :rest_token_endpoint=
+
+    # Create Config object
+    # === Options(Hash)
+    # * <tt>username</tt>   -- Username
+    # * <tt>password</tt>   -- Password
+    # * <tt>signature</tt> (Optional if certificate present) -- Signature
+    # * <tt>app_id</tt>     -- Application ID
+    # * <tt>cert_path</tt> (Optional if signature present)  -- Certificate file path
+    def initialize(options)
+      merge!(options)
+    end
+
+    def logfile=(filename)
+      logger.warn '`logfile=` is deprecated, Please use `PayPal::SDK::Core::Config.logger = Logger.new(STDERR)`'
+    end
+
+    def redirect_url=(redirect_url)
+      logger.warn '`redirect_url=` is deprecated.'
+    end
+
+    def dev_central_url=(dev_central_url)
+      logger.warn '`dev_central_url=` is deprecated.'
+    end
+
+    def ssl_options
+      @ssl_options ||= {}.freeze
+    end
+
+    def ssl_options=(options)
+      options = Hash[options.map{|key, value| [key.to_sym, value] }]
+      @ssl_options = ssl_options.merge(options).freeze
+    end
+
+    def ca_file=(ca_file)
+      logger.warn '`ca_file=` is deprecated, Please configure `ca_file=` under `ssl_options`'
+      self.ssl_options = { :ca_file => ca_file }
+    end
+
+    def http_verify_mode=(verify_mode)
+      logger.warn '`http_verify_mode=` is deprecated, Please configure `verify_mode=` under `ssl_options`'
+      self.ssl_options = { :verify_mode => verify_mode }
+    end
+
+    # Override configurations
+    def merge!(options)
+      options.each do |key, value|
+        send("#{key}=", value)
+      end
+      self
+    end
+
+    # Validate required configuration
+    def required!(*names)
+      names = names.select{|name| send(name).nil? }
+      raise MissingConfig.new("Required configuration(#{names.join(", ")})") if names.any?
+    end
+
+    class << self
+
+      @@config_cache = {}
+
+      # Load configurations from file
+      # === Arguments
+      # * <tt>file_name</tt>             -- Configuration file path
+      # * <tt>default_environment</tt> (Optional)    -- default environment configuration to load
+      # === Example
+      #   Config.load('config/paypal.yml', 'development')
+      def load(file_name, default_env = default_environment)
+        @@config_cache        = {}
+        @@configurations      = read_configurations(file_name)
+        @@default_environment = default_env
+        config
+      end
+
+      # Get default environment name
+      def default_environment
+        @@default_environment ||= ENV['PAYPAL_ENV'] || ENV['RACK_ENV'] || ENV['RAILS_ENV'] || "development"
+      end
+
+      # Set default environment
+      def default_environment=(env)
+        @@default_environment = env.to_s
+      end
+
+      def configure(options = {}, &block)
+        begin
+          self.config.merge!(options)
+        rescue Errno::ENOENT
+          self.configurations = { default_environment => options }
+        end
+        block.call(self.config) if block
+        self.config
+      end
+      alias_method :set_config, :configure
+
+      # Create or Load Config object based on given environment and configurations.
+      # === Attributes
+      # * <tt>env</tt> (Optional) -- Environment name
+      # * <tt>override_configuration</tt> (Optional) -- Override the configuration given in file.
+      # === Example
+      #   Config.config
+      #   Config.config(:development)
+      #   Config.config(:development, { :app_id => "XYZ" })
+      def config(env = default_environment, override_configuration = {})
+        if env.is_a? Hash
+          override_configuration = env
+          env = default_environment
+        end
+        if override_configuration.nil? or override_configuration.empty?
+          default_config(env)
+        else
+          default_config(env).dup.merge!(override_configuration)
+        end
+      end
+
+      def default_config(env = nil)
+        env = (env || default_environment).to_s
+        if configurations[env]
+          @@config_cache[env] ||= new(configurations[env])
+        else
+          raise Exceptions::MissingConfig.new("Configuration[#{env}] NotFound")
+        end
+      end
+
+      # Set logger
+      def logger=(logger)
+        Logging.logger = logger
+      end
+
+      # Get logger
+      def logger
+        Logging.logger
+      end
+
+      # Get raw configurations in Hash format.
+      def configurations
+        @@configurations ||= read_configurations
+      end
+
+      # Set configuration
+      def configurations=(configs)
+        @@config_cache   = {}
+        @@configurations = configs && Hash[configs.map{|k,v| [k.to_s, v] }]
+      end
+
+      private
+      # Read configurations from the given file name
+      # === Arguments
+      # * <tt>file_name</tt> (Optional) -- Configuration file path
+      def read_configurations(file_name = "config/paypal.yml")
+        erb = ERB.new(File.read(file_name))
+        erb.filename = file_name
+        YAML.load(erb.result)
+      end
+
+    end
+  end
+end