paypal-sdk-rest 1.7.3 → 2.0.0.rc2

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

@@ -1,44 +0,0 @@
-module PayPal::SDK::Core
-  module API
-    module DataTypes
-      # Create Array with block.
-      # === Example
-      #   ary = ArrayWithBlock.new{|val| val.to_i }
-      #   ary.push("123") # [ 123 ]
-      #   ary.merge!(["1", "3"])  # [ 123, 1, 3 ]
-      class ArrayWithBlock < ::Array
-        def initialize(&block)
-          @block   = block
-          super()
-        end
-
-        def [](key)
-          super(key) || send(:"[]=", key, nil)
-        end
-
-        def []=(key, value)
-          super(key, @block ? @block.call(value) : value)
-        end
-
-        def push(value)
-          super(@block ? @block.call(value) : value)
-        end
-
-        def merge!(array)
-          if array.is_a? Array
-            array.each do |object|
-              push(object)
-            end
-          elsif array.is_a? Hash and array.keys.first.to_s =~ /^\d+$/
-            array.each do |key, object|
-              self[key.to_i] = object
-            end
-          else
-            push(array)
-          end
-          self
-        end
-      end
-    end
-  end
-end

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

@@ -1,225 +0,0 @@
-require 'date'
-
-module PayPal::SDK::Core
-  module API
-
-    module DataTypes
-
-      # Create attributes and restrict the object type.
-      # == Example
-      #   class ConvertCurrencyRequest < Core::API::DataTypes::Base
-      #     object_of :baseAmountList,        CurrencyList
-      #     object_of :convertToCurrencyList, CurrencyCodeList
-      #     object_of :countryCode,           String
-      #     object_of :conversionType,        String
-      #   end
-      class Base
-
-        HashOptions = { :attribute => true, :namespace => true, :symbol => false }
-        ContentKey  = :value
-
-        include SimpleTypes
-        include Logging
-
-        class << self
-
-          # Add attribute
-          # === Arguments
-          # * <tt>name</tt>  -- attribute name
-          # * <tt>options</tt> -- options
-          def add_attribute(name, options = {})
-            add_member(name, SimpleTypes::String, options.merge( :attribute => true ))
-          end
-
-          # Fields list for the DataTye
-          def members
-            @members ||=
-              begin
-                superclass.load_members if defined? superclass.load_members
-                parent_members = superclass.instance_variable_get("@members")
-                parent_members ? parent_members.dup : Util::OrderedHash.new
-              end
-          end
-
-          # Add Field to class variable hash and generate methods
-          # === Example
-          #   add_member(:errorMessage, String)  # Generate Code
-          #   # attr_reader   :errorMessage
-          #   # alias_method  :error_message,  :errorMessage
-          #   # alias_method  :error_message=, :errorMessage=
-          def add_member(member_name, klass, options = {})
-            member_name = member_name.to_sym
-            return if members[member_name]
-            members[member_name] = options.merge( :type => klass )
-            member_variable_name = "@#{member_name}"
-            define_method "#{member_name}=" do |value|
-              object = options[:array] ? convert_array(value, klass) : convert_object(value, klass)
-              instance_variable_set(member_variable_name, object)
-            end
-            default_value = ( options[:array] ? [] : ( klass < Base ? Util::OrderedHash.new : nil ) )
-            define_method member_name do |&block|
-              value = instance_variable_get(member_variable_name) || ( default_value && send("#{member_name}=", default_value) )
-              value.instance_eval(&block) if block
-              value
-            end
-            define_alias_methods(member_name, options)
-          end
-
-          # Define alias methods for getter and setter
-          def define_alias_methods(member_name, options)
-            snakecase_name = snakecase(member_name)
-            alias_method snakecase_name, member_name
-            alias_method "#{snakecase_name}=", "#{member_name}="
-            alias_method "#{options[:namespace]}:#{member_name}=", "#{member_name}=" if options[:namespace]
-            if options[:attribute]
-              alias_method "@#{member_name}=", "#{member_name}="
-              alias_method "@#{options[:namespace]}:#{member_name}=", "#{member_name}=" if options[:namespace]
-            end
-          end
-
-          # define method for given member and the class name
-          # === Example
-          #   object_of(:errorMessage, ErrorMessage) # Generate Code
-          #   # def errorMessage=(options)
-          #   #   @errorMessage = ErrorMessage.new(options)
-          #   # end
-          #   # add_member :errorMessage, ErrorMessage
-          def object_of(key, klass, options = {})
-            add_member(key, klass, options)
-          end
-
-          # define method for given member and the class name
-          # === Example
-          #   array_of(:errorMessage, ErrorMessage) # It Generate below code
-          #   # def errorMessage=(array)
-          #   #   @errorMessage = array.map{|options| ErrorMessage.new(options) }
-          #   # end
-          #   # add_member :errorMessage, ErrorMessage
-          def array_of(key, klass, options = {})
-            add_member(key, klass, options.merge(:array => true))
-          end
-
-          # Generate snakecase string.
-          # === Example
-          # snakecase("errorMessage")
-          # # error_message
-          def snakecase(string)
-            string.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').gsub(/([A-Z])([A-Z][a-z])/, '\1_\2').downcase
-          end
-
-        end
-
-        # Initialize options.
-        def initialize(options = {}, &block)
-          merge!(options, &block)
-        end
-
-        # Merge values
-        def merge!(options, &block)
-          if options.is_a? Hash
-            options.each do |key, value|
-              set(key, value)
-            end
-          elsif members[ContentKey]
-            set(ContentKey, options)
-          else
-            raise ArgumentError, "invalid data(#{options.inspect}) for #{self.class.name} class"
-          end
-          self.instance_eval(&block) if block
-          self
-        end
-
-        # Set value for given member
-        # === Arguments
-        # * <tt>key</tt> -- member name
-        # * <tt>value</tt> -- value for member
-        def set(key, value)
-          send("#{key}=", value)
-        rescue NoMethodError => error
-          # Uncomment to see missing fields
-          # logger.debug error.message
-        rescue TypeError, ArgumentError => error
-          raise TypeError, "#{error.message}(#{value.inspect}) for #{self.class.name}.#{key} member"
-        end
-
-        # Create array of objects.
-        # === Example
-        # covert_array([{ :amount => "55", :code => "USD"}], CurrencyType)
-        # covert_array({ "0" => { :amount => "55", :code => "USD"} }, CurrencyType)
-        # covert_array({ :amount => "55", :code => "USD"}, CurrencyType)
-        # # @return
-        # # [ <CurrencyType#object @amount="55" @code="USD" > ]
-        def convert_array(array, klass)
-          default_value = ( klass < Base ? Util::OrderedHash.new : nil )
-          data_type_array = ArrayWithBlock.new{|object| convert_object(object || default_value, klass) }
-          data_type_array.merge!(array)
-        end
-
-        # Create object based on given data.
-        # === Example
-        # covert_object({ :amount => "55", :code => "USD"}, CurrencyType )
-        # # @return
-        # # <CurrencyType#object @amount="55" @code="USD" >
-        def convert_object(object, klass)
-          object.is_a?(klass) ? object : ( ( object.nil? or object == "" ) ? nil : klass.new(object) )
-        end
-
-        # Alias instance method for the class method.
-        def members
-          self.class.members
-        end
-
-        # Get configured member names
-        def member_names
-          members.keys
-        end
-
-        # Create Hash based configured members
-        def to_hash(options = {})
-          options = HashOptions.merge(options)
-          hash    = Util::OrderedHash.new
-          member_names.each do |member|
-            value = value_to_hash(instance_variable_get("@#{member}"), options)
-            hash[hash_key(member, options)] = value unless skip_value?(value)
-          end
-          hash
-        end
-
-        # Skip nil, empty array and empty hash.
-        def skip_value?(value)
-          value.nil? || ( ( value.is_a?(Array) || value.is_a?(Hash) ) && value.empty? )
-        end
-
-        # Generate Hash key for given member name based on configuration
-        # === Example
-        # hash_key(:amount) # @return :"ebl:amount"
-        # hash_key(:type)   # @return :"@type"
-        def hash_key(key, options = {})
-          unless key == ContentKey
-            member_option = members[key]
-            key = member_option[:name] if member_option.include? :name
-            if !member_option[:attribute] and member_option[:namespace] and options[:namespace]
-              key = "#{member_option[:namespace]}:#{key}"
-            end
-            key = "@#{key}" if member_option[:attribute] and options[:attribute]
-          end
-          options[:symbol] ? key.to_sym : key.to_s
-        end
-
-        # Covert the object to hash based on class.
-        def value_to_hash(value, options = {})
-          case value
-          when Array
-            value = value.map{|object| value_to_hash(object, options) }
-            value.delete_if{|v| skip_value?(v) }
-            value
-          when Base
-            value.to_hash(options)
-          else
-            value
-          end
-        end
-      end
-    end
-  end
-end

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

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

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

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

@@ -1,177 +0,0 @@
-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, headers=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}" }).merge(headers)
-            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, headers={})
-        token_hash(auth_code, headers)[:access_token]
-      end
-
-      # Get access token type
-      def token_type(headers={})
-        token_hash(nil, headers)[: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(payload[:header])} #{token(nil, payload[:header])}").
-          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.body && response.body.strip == ""
-            {}
-          elsif 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" => flat_hash(MultiJson.load(response.body)) }
-          else
-            { "error" => { "name" => response.code, "message" => response.message,
-              "developer_msg" => response } }
-          end
-        payload
-      end
-
-      def flat_hash(h)
-        new_hash = {}
-        h.each_pair do |key, val|
-          if val.is_a?(Hash)
-            new_hash.merge!(flat_hash(val))
-          else
-            new_hash[key] = val
-          end
-        end
-        new_hash
-      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