paypal-sdk-core 0.1.0

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in paypal-sdk-core.gemspec
+gemspec
+
+gem 'rake', :require => false
+
+group :test do
+  gem 'rspec'
+  gem 'simplecov', :require => false
+end

data/README.md

@@ -0,0 +1,16 @@
+# Paypal::Sdk::Core
+
+Core library for PayPal ruby SDKs.
+
+SDKs:
+
+* [paypal-sdk-adaptivepayments](https://github.com/paypal/adaptivepayments-sdk-ruby)
+* [paypal-sdk-adaptiveaccounts](https://github.com/paypal/adaptiveaccounts-sdk-ruby)
+* [paypal-sdk-invoice](https://github.com/paypal/invoice-sdk-ruby)
+* [paypal-sdk-permissions](https://github.com/paypal/permissions-sdk-ruby)
+* [paypal-sdk-merchant](https://github.com/paypal/merchant-sdk-ruby)
+* [paypal-sdk-buttonmanager](https://github.com/paypal/buttonmanager-sdk-ruby)
+
+
+Note: Don't use this library directly
+

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+task :default => :spec

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::Core::Config.load("config/paypal.yml", Rails.env)
+PayPal::SDK::Core::Config.logger = Rails.logger

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

@@ -0,0 +1,32 @@
+test: &default
+  username: jb-us-seller_api1.paypal.com
+  password: WX4WTU3S8MY44S7F
+  signature: AFcWxV21C7fd0v3bYYYRCpSSRl31A7yDhhsPUU2XhtMoZXsWHFxu-RWy
+  app_id: APP-80W284485P519543T
+  http_timeout: 30
+  mode: sandbox
+  sandbox_email_address: Platform.sdk.seller@gmail.com
+
+development:
+  <<: *default
+
+production:
+  <<: *default
+  mode: live
+
+# with_certificate:
+#   <<: *default
+#   username: platfo_1255170694_biz_api1.gmail.com
+#   password: 2DPPKUPKB7DQLXNR
+#   signature:
+#   cert_path: "config/cert_key.pem"
+#   app_id: APP-80W284485P519543T
+#
+# with_oauth_token:
+#   <<: *default
+#   token: ESTy2hio5WJQo1iixkH29I53RJxaS0Gvno1A6.YQXZgktxbY4I2Tdg
+#   token_secret: ZKPhUYuwJwYsfWdzorozWO2U9pI
+#
+# with_proxy:
+#   <<: *default
+#   http_proxy: http://proxy-ipaddress:3129/

data/lib/paypal-sdk-core.rb

@@ -0,0 +1,40 @@
+require "paypal-sdk/core/version"
+require "paypal-sdk/core/config"
+require "paypal-sdk/core/logging"
+
+module PayPal
+  module SDK
+    module Core
+
+      autoload :Authentication, "paypal-sdk/core/authentication"
+
+      module API
+        autoload :Base,     "paypal-sdk/core/api/base"
+        autoload :Merchant, "paypal-sdk/core/api/merchant"
+        autoload :Platform, "paypal-sdk/core/api/platform"
+
+        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"
+        end
+      end
+
+      module Util
+        autoload :OauthSignature, "paypal-sdk/core/util/oauth_signature"
+      end
+
+      module Credential
+        autoload :Base,         "paypal-sdk/core/credential/base"
+        autoload :Certificate,  "paypal-sdk/core/credential/certificate"
+        autoload :Signature,    "paypal-sdk/core/credential/signature"
+
+        module ThirdParty
+          autoload :Token,    "paypal-sdk/core/credential/third_party/token"
+          autoload :Subject,  "paypal-sdk/core/credential/third_party/subject"
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+require 'net/http'
+
+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 Configuration
+      include Logging
+      include Authentication
+
+      attr_accessor :http, :uri, :service_name
+
+      DEFAULT_END_POINTS = {
+        :sandbox => {
+          :platform => { # NVP EndPoint
+            :three_token  => "https://svcs.sandbox.paypal.com/",
+            :certificate  => "https://svcs.sandbox.paypal.com/"
+          },
+          :merchant => { # SOAP EndPoint
+            :three_token  => "https://api-3t.sandbox.paypal.com/2.0",
+            :certificate  => "https://api.sandbox.paypal.com/2.0"
+          }
+        },
+        :live => {
+          :platform => { # NVP EndPoint
+            :three_token  => "https://svcs.paypal.com/",
+            :certificate  => "https://svcs.paypal.com/"
+          },
+          :merchant => { # SOAP EndPoint
+            :three_token  => "https://api-3t.paypal.com/2.0",
+            :certificate  => "https://api.paypal.com/2.0"
+          }
+        }
+      }
+      DEFAULT_HTTP_HEADER = {}
+
+      # 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
+
+      # Override set_config method to create http connection on changing the configuration.
+      def set_config(*args)
+        super
+        create_http_connection
+      end
+
+      # Create HTTP connection based on given service name or configured end point
+      def create_http_connection
+        service_path = "#{service_endpoint}/#{service_name}"
+        @uri  = URI.parse(service_path)
+        if config.http_proxy
+          proxy = URI.parse(config.http_proxy)
+          @http = Net::HTTP.new(@uri.host, @uri.port, proxy.host, proxy.port, proxy.user, proxy.password)
+        else
+          @http = Net::HTTP.new(@uri.host, @uri.port)
+        end
+        @uri.path = @uri.path.gsub(/\/+/, "/")
+        configure_http_connection
+      end
+
+      # Configure HTTP connection based on configuration.
+      def configure_http_connection
+        http.use_ssl  = true
+        http.ca_file  = config.ca_file if config.ca_file
+        if config.http_timeout
+          http.open_timeout = config.http_timeout
+          http.read_timeout = config.http_timeout
+        end
+        add_certificate(http)
+      end
+
+      # Get configured API mode( sandbox or live)
+      def api_mode
+        api_modes   = DEFAULT_END_POINTS.keys
+        config_mode = ( config.mode || api_modes.first ).to_sym
+        api_modes.include?(config_mode) ? config_mode : api_modes.first
+      end
+
+      # Get default endpoint for the given service name
+      # === Argument
+      # * <tt>name</tt> -- Service name ( platform or merchant)
+      # === Returns
+      # Return service end point based on the configured API mode.
+      def default_end_point(name)
+        default_end_point = DEFAULT_END_POINTS[api_mode][name]
+        if default_end_point
+          config.cert_path ? default_end_point[:certificate] : default_end_point[:three_token]
+        end
+      end
+
+      # Get service end point
+      def service_endpoint
+        config.end_point ? default_end_point(config.end_point.to_sym) : config.end_point
+      end
+
+      # Default Http header
+      def default_http_header
+        DEFAULT_HTTP_HEADER
+      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 request(action, params = {}, initheader = {})
+        uri, content, header = format_request(action, params)
+        initheader    = default_http_header.merge(header).merge(initheader)
+        initheader.delete_if{|key, val| val.nil? }
+        start_time    = Time.now
+        response      = @http.post(uri.path, content, initheader)
+        format_response(action, response)
+      rescue Net::HTTPBadGateway, Errno::ECONNRESET, Errno::ECONNABORTED, SocketError => error
+        format_error(error, error.message)
+      ensure
+        log_event("Request: #{action}", start_time)
+      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(action, params)
+        [ @uri, params, {} ]
+      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(action, response)
+        response
+      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
+    end
+  end
+end

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

@@ -0,0 +1,236 @@
+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 => true }
+        ContentKey  = :value
+
+        include SimpleTypes
+
+        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
+                parent_members = superclass.instance_variable_get("@members")
+                parent_members ? parent_members.dup : {}
+              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
+            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 ? {} : 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)
+          if options.is_a? Hash
+            options.each do |key, value|
+              begin
+                send("#{key}=", value)
+              rescue TypeError, ArgumentError => error
+                raise TypeError, "#{error.message}(#{value.inspect}) for #{self.class.name}.#{key} member"
+              end
+            end
+          elsif members[ContentKey]
+            self.value = options
+          else
+            raise ArgumentError, "invalid data(#{options.inspect}) for #{self.class.name} class"
+          end
+          self.instance_eval(&block) if block
+        end
+
+        # Create Array with default value.
+        class ArrayWithDefault < ::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 merge!(array)
+            if array.is_a? Array
+              array.each_with_index do |object, index|
+                self[index] = 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
+              self[0] = array
+            end
+            self
+          end
+        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 ? {} : nil )
+          data_type_array = ArrayWithDefault.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    = {}
+          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
+            key = "#{member_option[:namespace]}:#{key}" if member_option[:namespace] and options[:namespace]
+            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