paypal-sdk-rest-pmrb 1.8.0

data/lib/generators/paypal/sdk/USAGE

@@ -0,0 +1,3 @@
+To copy a PayPal SDK default configuration and initializer to your Rails App.
+
+  rails g paypal-sdk:install

data/lib/generators/paypal/sdk/install_generator.rb

@@ -0,0 +1,17 @@
+module Paypal
+  module Sdk
+    module Generators
+      class InstallGenerator < Rails::Generators::Base
+        source_root File.expand_path('../templates', __FILE__)
+
+        def copy_config_file
+          copy_file "paypal.yml", "config/paypal.yml"
+        end
+
+        def copy_initializer_file
+          copy_file "paypal.rb",  "config/initializers/paypal.rb"
+        end
+      end
+    end
+  end
+end

data/lib/generators/paypal/sdk/templates/paypal.rb

@@ -0,0 +1,2 @@
+PayPal::SDK.load("config/paypal.yml", Rails.env)
+PayPal::SDK.logger = Rails.logger

data/lib/generators/paypal/sdk/templates/paypal.yml

@@ -0,0 +1,29 @@
+test: &default
+
+  # Credentials for REST APIs
+  client_id: EBWKjlELKMYqRNQ6sYvFo64FtaRLRR5BdHEESmha49TM
+  client_secret: EO422dn3gQLgDbuwqTjzrFgFtaRLRR5BdHEESmha49TM
+
+  # Mode can be 'live' or 'sandbox'
+  mode: sandbox
+
+  # Credentials for Classic APIs
+  app_id: APP-80W284485P519543T
+  username: jb-us-seller_api1.paypal.com
+  password: WX4WTU3S8MY44S7F
+  signature: AFcWxV21C7fd0v3bYYYRCpSSRl31A7yDhhsPUU2XhtMoZXsWHFxu-RWy
+  # # With Certificate
+  # cert_path: "config/cert_key.pem"
+  sandbox_email_address: Platform.sdk.seller@gmail.com
+
+  # # IP Address
+  # ip_address: 127.0.0.1
+  # # HTTP Proxy
+  # http_proxy: http://proxy-ipaddress:3129/
+
+development:
+  <<: *default
+
+production:
+  <<: *default
+  mode: live

data/lib/paypal-sdk-core.rb

@@ -0,0 +1,38 @@
+module PayPal
+  module SDK
+    module Core
+
+      autoload :VERSION,        "paypal-sdk/rest/version"
+      autoload :Config,         "paypal-sdk/core/config"
+      autoload :Configuration,  "paypal-sdk/core/config"
+      autoload :Logging,        "paypal-sdk/core/logging"
+      autoload :Authentication, "paypal-sdk/core/authentication"
+      autoload :Exceptions,     "paypal-sdk/core/exceptions"
+      autoload :OpenIDConnect,  "paypal-sdk/core/openid_connect"
+      autoload :API,            "paypal-sdk/core/api"
+      autoload :Util,           "paypal-sdk/core/util"
+      autoload :Credential,     "paypal-sdk/core/credential"
+
+    end
+
+    autoload :OpenIDConnect,    "paypal-sdk/core/openid_connect"
+
+    class << self
+      def configure(options = {}, &block)
+        Core::Config.configure(options, &block)
+      end
+
+      def load(*args)
+        Core::Config.load(*args)
+      end
+
+      def logger
+        Core::Config.logger
+      end
+
+      def logger=(log)
+        Core::Config.logger = log
+      end
+    end
+  end
+end

data/lib/paypal-sdk-rest.rb

@@ -0,0 +1,2 @@
+require "paypal-sdk/rest"
+

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

@@ -0,0 +1,20 @@
+module PayPal
+  module SDK
+    module Core
+      module API
+        autoload :Base,     "paypal-sdk/core/api/base"
+        autoload :Merchant, "paypal-sdk/core/api/merchant"
+        autoload :Platform, "paypal-sdk/core/api/platform"
+        autoload :REST,     "paypal-sdk/core/api/rest"
+        autoload :IPN,      "paypal-sdk/core/api/ipn"
+
+        module DataTypes
+          autoload :Base, "paypal-sdk/core/api/data_types/base"
+          autoload :Enum, "paypal-sdk/core/api/data_types/enum"
+          autoload :SimpleTypes,    "paypal-sdk/core/api/data_types/simple_types"
+          autoload :ArrayWithBlock, "paypal-sdk/core/api/data_types/array_with_block"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,169 @@
+require 'paypal-sdk/rest/version'
+
+module PayPal::SDK::Core
+
+  module API
+    # API class provide default functionality for accessing the API web services.
+    # == Example
+    #   api      = API::Base.new("AdaptivePayments")
+    #   response = api.request("GetPaymentOptions", "")
+    class Base
+
+      include Util::HTTPHelper
+
+      attr_accessor :http, :uri, :service_name
+
+      DEFAULT_API_MODE    = :sandbox
+      API_MODES           = [ :live, :sandbox ]
+
+      # Initialize API object
+      # === Argument
+      # * <tt>service_name</tt> -- (Optional) Service name
+      # * <tt>environment</tt>  -- (Optional) Configuration environment to load
+      # * <tt>options</tt> -- (Optional) Override configuration.
+      # === Example
+      #  new("AdaptivePayments")
+      #  new("AdaptivePayments", :development)
+      #  new(:wsdl_service)       # It load wsdl_service configuration
+      def initialize(service_name = "", environment = nil, options = {})
+        unless service_name.is_a? String
+          environment, options, service_name = service_name, environment || {}, ""
+        end
+        @service_name = service_name
+        set_config(environment, options)
+      end
+
+      def uri
+        @uri ||=
+          begin
+            uri = URI.parse("#{service_endpoint}/#{service_name}")
+            uri.path = uri.path.gsub(/\/+/, "/")
+            uri
+          end
+      end
+
+      def http
+        @http ||= create_http_connection(uri)
+      end
+
+      # Override set_config method to create http connection on changing the configuration.
+      def set_config(*args)
+        @http = @uri = nil
+        super
+      end
+
+      # Get configured API mode( sandbox or live)
+      def api_mode
+        if config.mode and API_MODES.include? config.mode.to_sym
+          config.mode.to_sym
+        else
+          DEFAULT_API_MODE
+        end
+      end
+
+      # Get service end point
+      def service_endpoint
+        config.endpoint
+      end
+
+      # Default Http header
+      def default_http_header
+        { "User-Agent" => self.class.user_agent }
+      end
+
+      # Generate HTTP request for given action and parameters
+      # === Arguments
+      # * <tt>http_method</tt> -- HTTP method(get/put/post/delete/patch)
+      # * <tt>action</tt> -- Action to perform
+      # * <tt>params</tt> -- (Optional) Parameters for the action
+      # * <tt>initheader</tt> -- (Optional) HTTP header
+      def api_call(payload)
+        payload[:header] = default_http_header.merge(payload[:header])
+        payload[:uri]   ||= uri.dup
+        payload[:http]  ||= http.dup
+        payload[:uri].query = encode_www_form(payload[:query]) if payload[:query] and payload[:query].any?
+        format_request(payload)
+        payload[:response] = http_call(payload)
+        format_response(payload)
+        payload[:data]
+      end
+
+      # Generate HTTP request for given action and parameters
+      # === Arguments
+      # * <tt>action</tt> -- Action to perform
+      # * <tt>params</tt> -- (Optional) Parameters for the action
+      # * <tt>initheader</tt> -- (Optional) HTTP header
+      def post(action, params = {}, header = {}, query = {})
+        action, params, header = "", action, params if action.is_a? Hash
+        api_call(:method => :post, :action => action, :query => query, :params => params, :header => header)
+      end
+      alias_method :request, :post
+
+      def get(action, params = {}, header = {})
+        action, params, header = "", action, params if action.is_a? Hash
+        api_call(:method => :get, :action => action, :query => params, :params => nil, :header => header)
+      end
+
+      def patch(action, params = {}, header = {})
+        action, params, header = "", action, params if action.is_a? Hash
+        api_call(:method => :patch, :action => action, :params => params, :header => header)
+      end
+
+      def put(action, params = {}, header = {})
+        action, params, header = "", action, params if action.is_a? Hash
+        api_call(:method => :put, :action => action, :params => params, :header => header)
+      end
+
+      def delete(action, params = {}, header = {})
+        action, params, header = "", action, params if action.is_a? Hash
+        api_call(:method => :delete, :action => action, :params => params, :header => header)
+      end
+
+      # Format Request data. It will be override by child class
+      # == Arguments
+      # * <tt>action</tt> -- Request action
+      # * <tt>params</tt> -- Request parameters
+      # == Return
+      # * <tt>path</tt>   -- Formated request uri object
+      # * <tt>params</tt> -- Formated request Parameters
+      # * <tt>header</tt> -- HTTP Header
+      def format_request(payload)
+        payload[:uri].path = url_join(payload[:uri].path, payload[:action])
+        payload[:body] = payload[:params].to_s
+        payload
+      end
+
+      # Format Response object. It will be override by child class
+      # == Argument
+      # * <tt>action</tt> -- Request action
+      # * <tt>response</tt> -- HTTP response object
+      def format_response(payload)
+        payload[:data] = payload[:response].body
+        payload
+      end
+
+      # Format Error object. It will be override by child class.
+      # == Arguments
+      # * <tt>exception</tt> -- Exception object.
+      # * <tt>message</tt> -- Readable error message.
+      def format_error(exception, message)
+        raise exception
+      end
+
+      class << self
+        def sdk_library_details
+          @library_details ||= "paypal-sdk-core #{PayPal::SDK::REST::VERSION}; ruby #{RUBY_VERSION}p#{RUBY_PATCHLEVEL}-#{RUBY_PLATFORM}"
+          begin
+            @library_details << ";#{OpenSSL::OPENSSL_LIBRARY_VERSION}"
+          rescue NameError
+            @library_details << ";OpenSSL #{OpenSSL::OPENSSL_VERSION}"
+          end
+        end
+
+        def user_agent
+          @user_agent ||= "PayPalSDK/rest-sdk-ruby #{PayPal::SDK::REST::VERSION} (#{sdk_library_details})"
+        end
+      end
+    end
+  end
+end

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

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

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