paypal-payment 0.1.2

data/lib/paypal/common.rb

@@ -0,0 +1,11 @@
+module PayPal
+  module Common
+  end
+end
+
+require "paypal/common/base"
+require "paypal/common/request"
+require "paypal/common/request_envelope"
+require "paypal/common/response"
+require "paypal/common/response_envelope"
+require "paypal/common/error_data"

data/lib/paypal/common/base.rb

@@ -0,0 +1,83 @@
+module PayPal::Common::Base
+  def initialize(attributes = {})
+    attributes.each do |name, value|
+      attr_name = underscore(name)
+      if respond_to?("set_#{attr_name}") and (value.is_a?(Hash) or value.is_a?(Array))
+        send("set_#{attr_name}", value)
+      elsif respond_to?("#{attr_name}=")
+        send("#{attr_name}=", value)
+      end
+    end
+    after_initialize
+  end
+
+  def after_initialize
+  end
+
+  def request
+    PayPal::Common::Request.new
+  end
+
+  def build_value(klass, value)
+    if value.is_a?(Hash)
+      klass.new(value)
+    elsif value.is_a?(Array)
+      value.map do |val|
+        val.is_a?(Hash) ? klass.new(val) : val
+      end
+    else
+      value
+    end
+  end
+
+  def build_datetime(value)
+    if value.respond_to?(:to_time)
+      value.to_time
+    else
+      Time.parse(value.to_s)
+    end
+  rescue
+  end
+
+  def hash_keys
+    {}
+  end
+
+  def to_hash(*args)
+    ivars = args.empty? ? instance_variables : instance_variables.select { |var| args.include?(var[1..-1].to_sym) }
+    Hash[
+      ivars.map do |var|
+        val = instance_variable_get(var)
+        if val.is_a?(Array)
+          val.map! { |a| a.respond_to?(:to_hash) ? a.to_hash : a }
+        elsif val.respond_to?(:iso8601)
+          val = val.iso8601
+        else
+          val = val.to_hash if val.respond_to?(:to_hash)
+        end
+        hash_key = hash_keys[var[1..-1].to_sym] || camelize(var[1..-1], false).to_sym
+        [hash_key, val]
+      end
+    ]
+  end
+
+  def to_json(*args)
+    MultiJson.dump(to_hash(*args))
+  end
+
+  def underscore(word)
+    word.to_s.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+  def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      lower_case_and_underscored_word.to_s[0] + camelize(lower_case_and_underscored_word.to_s)[1..-1]
+    end
+  end
+end

data/lib/paypal/common/error_data.rb

@@ -0,0 +1,15 @@
+module PayPal::Common
+  class ErrorData
+    include PayPal::Common::Base
+
+    attr_accessor :category
+    attr_accessor :domain
+    attr_accessor :error_id
+    attr_accessor :exception_id
+    attr_accessor :message
+    attr_accessor :parameter
+    attr_accessor :severity
+    attr_accessor :subdomain
+
+  end
+end

data/lib/paypal/common/request.rb

@@ -0,0 +1,45 @@
+module PayPal::Common
+  class Request < PayPal::Request
+
+    def api
+      PayPal::Api
+    end
+
+    def default_headers
+      super.merge(
+        {
+          'X-PAYPAL-SECURITY-USERID'      => api.username,
+          'X-PAYPAL-SECURITY-PASSWORD'    => api.password,
+          'X-PAYPAL-SECURITY-SIGNATURE'   => api.signature,
+          'X-PAYPAL-REQUEST-DATA-FORMAT'  => api.request_data_format,
+          'X-PAYPAL-RESPONSE-DATA-FORMAT' => api.response_data_format,
+          'X-PAYPAL-APPLICATION-ID'       => api.app_id
+        }
+      )
+    end
+
+    # Returns the actual api endpoint base on method
+    #
+    def method_endpoint(method)
+      api.api_endpoint
+    end
+
+    def prepare_json(json)
+      json[:requestEnvelope] = PayPal::Common::RequestEnvelope.new.to_hash unless json[:requestEnvelope]
+      json
+    end
+
+    def build_json(json)
+      json.is_a?(Hash) ? build_json(json) : json
+    end
+
+    def run(method, json = {})
+      self.uri = method_endpoint(method)
+      post(MultiJson.dump(prepare_json(json)), default_headers)
+    end
+
+    def build_action_type(value)
+      ACTION_TYPES.fetch(value.to_sym, value) if value
+    end
+  end
+end

data/lib/paypal/common/request_envelope.rb

@@ -0,0 +1,13 @@
+module PayPal::Common
+  class RequestEnvelope
+    include PayPal::Common::Base
+
+    attr_accessor :error_language
+    attr_accessor :detail_level
+
+    def after_initialize
+      @error_language ||= 'en_US'
+      @detail_level ||= 'ReturnAll'
+    end
+  end
+end

data/lib/paypal/common/response.rb

@@ -0,0 +1,34 @@
+
+
+module PayPal::Common
+  module Response
+    include PayPal::Common::Base
+
+    attr_accessor :error
+    attr_accessor :response_envelope
+
+    def set_response_envelope(value)
+      self.response_envelope = ResponseEnvelope.new(value)
+    end
+
+    def errors
+      @error||[]
+    end
+
+    def set_error(value)
+      self.error = build_value(ErrorData, value)
+    end
+
+    def response_envelope
+      @response_envelope ||= ResponseEnvelope.new
+    end
+
+    def success?
+      self.response_envelope.success?
+    end
+
+    def valid?
+      (self.errors||[]).empty?
+    end
+  end
+end

data/lib/paypal/common/response_envelope.rb

@@ -0,0 +1,19 @@
+module PayPal::Common
+  class ResponseEnvelope
+    include PayPal::Common::Base
+
+    attr_accessor :timestamp
+    attr_accessor :ack
+    attr_accessor :build
+    attr_accessor :correlation_id
+
+    def success?
+      self.ack == 'Success'
+    end
+
+    def set_timestamp(value)
+      self.timestamp = Time.parse(value)
+    rescue
+    end
+  end
+end

data/lib/paypal/express_checkout.rb

@@ -0,0 +1,19 @@
+module PayPal
+  module ExpressCheckout
+  end
+end
+
+require "paypal/express_checkout/api"
+require "paypal/express_checkout/utils"
+require "paypal/express_checkout/fields"
+require "paypal/express_checkout/request"
+require "paypal/express_checkout/base"
+require "paypal/express_checkout/account"
+require "paypal/express_checkout/billing"
+require "paypal/express_checkout/payment"
+require "paypal/express_checkout/payment_item"
+require "paypal/express_checkout/fmf"
+require "paypal/express_checkout/shipping_option"
+require "paypal/express_checkout/checkout"
+require "paypal/express_checkout/recurring"
+require "paypal/express_checkout/response"

data/lib/paypal/express_checkout/account.rb

@@ -0,0 +1,16 @@
+module PayPal
+  module ExpressCheckout
+    class Account < PayPal::ExpressCheckout::Base
+      has_fields :account
+
+      def pal_details
+        run(:pal_details)
+      end
+
+      def balance
+        params = collect(:all_currencies)
+        run(:balance, params)
+      end
+    end
+  end
+end

data/lib/paypal/express_checkout/api.rb

@@ -0,0 +1,43 @@
+module PayPal
+  module ExpressCheckout
+    class Api
+
+      API_ENDPOINTS = {
+         :sandbox     => "https://api-3t.sandbox.paypal.com/nvp",
+         :production  => "https://api-3t.paypal.com/nvp"
+      }
+
+      class << self
+        def username
+          PayPal::Api.instance.username
+        end
+
+        def password
+          PayPal::Api.instance.password
+        end
+
+        def signature
+          PayPal::Api.instance.signature
+        end
+
+        def app_id
+          PayPal::Api.instance.app_id
+        end
+
+        def environment
+          PayPal::Api.environment
+        end
+
+        def api_endpoint
+          self::API_ENDPOINTS[environment]
+        end
+
+        # Return PayPal's API version.
+        #
+        def api_version
+          "93.0"
+        end
+      end
+    end
+  end
+end

data/lib/paypal/express_checkout/base.rb

@@ -0,0 +1,37 @@
+require "cgi"
+require "uri"
+require "ostruct"
+require "time"
+
+module PayPal
+  module ExpressCheckout
+    class Base
+      include PayPal::ExpressCheckout::Fields
+
+      def initialize(options = {})
+        options.each {|name, value| send("#{name}=", value)}
+      end
+
+      # Just a shortcut convenience.
+      #
+      def request # :nodoc:
+        @request ||= PayPal::ExpressCheckout::Request.new
+      end
+
+      def run(method, params = {}, headers = {})
+        request.run(self, method, params, headers)
+      end
+
+      private
+      # Collect specified attributes and build a hash out of it.
+      #
+      def collect(*args) # :nodoc:
+        args.inject({}) do |buffer, attr_name|
+          value = send(attr_name)
+          buffer[attr_name] = value if value
+          buffer
+        end
+      end
+    end
+  end
+end

data/lib/paypal/express_checkout/billing.rb

@@ -0,0 +1,7 @@
+module PayPal
+  module ExpressCheckout
+    class Billing < PayPal::ExpressCheckout::Base
+      has_fields :billing
+    end
+  end
+end

data/lib/paypal/express_checkout/callback.rb

@@ -0,0 +1,17 @@
+module PayPal
+  module ExpressCheckout
+    class Callback < PayPal::ExpressCheckout::Base
+      has_fields :callback
+      has_many :shipping_options
+
+      def response
+        params = group_collect(
+          :callback,
+          :shipping_options
+        )
+
+        run(:callback_response, params)
+      end
+    end
+  end
+end

data/lib/paypal/express_checkout/checkout.rb

@@ -0,0 +1,144 @@
+module PayPal
+  module ExpressCheckout
+    class Checkout < PayPal::ExpressCheckout::Base
+      has_fields :checkout, :giro, :gift, :survey, :buyer, :tax, :shipping_option, :landing_page, :solution_type, :channel_type
+
+      has_many :shipping_options, :payments, :billings
+
+      # Request a checkout token.
+      #
+      #   ppr = PayPal::ExpressCheckout::Checkout.new({
+      #     :return_url         => "http://example.com/checkout/thank_you",
+      #     :cancel_url         => "http://example.com/checkout/canceled",
+      #     :ipn_url            => "http://example.com/paypal/ipn",
+      #     :description        => "Awesome - Monthly Subscription",
+      #     :amount             => "9.00",
+      #     :currency           => "USD"
+      #   })
+      #
+      #   response = ppr.request_token
+      #   response.checkout_url
+      #
+      def checkout
+        params = group_collect(
+          :checkout,
+          :giro,
+          :gift,
+          :survey,
+          :buyer,
+          :tax,
+          :landing_page, 
+          :solution_type, 
+          :channel_type,
+          :payments,
+          :shipping_options,
+          :billings
+        )
+
+        run(:checkout, params)
+      end
+
+      # Return checkout details.
+      #
+      #   ppr = PayPal::ExpressCheckout::Checkout.new({
+      #     :token => "EC-6LX60229XS426623E"
+      #   })
+      #   response = ppr.details
+      #
+      def details
+        run(:details, :token => token)
+      end
+
+      # Verify an address.
+      #   ppr = PayPal::ExpressCheckout::Checkout.new({
+      #     :email  => "user@example.com",
+      #     :street => "ABCEDFGH",
+      #     :zip    => "1234"
+      #   })
+      #   response = ppr.refund
+      #
+      def address_verify
+        params = collect(
+          :email,
+          :street,
+          :zip
+        )
+
+        run(:address_verify, params)
+      end
+
+      # Execute payment. DoExpressCheckoutPayment
+      def pay
+        params = group_collect(
+          :token,
+          :payer_id,
+          :return_fmf_details,
+          :payments,
+          :survey,
+          :shipping_option
+        )
+
+        run(:pay, params)
+      end
+
+      # Do authorization
+      #
+      def authorize
+        params = collect(
+          :transaction_id,
+          :amount,
+          :transaction_entity,
+          :currency,
+          :msg_sub_id
+        )
+
+        run(:authorize, params)
+      end
+
+      # Do authorization
+      #
+      def reauthorize
+        params = collect(
+          :transaction_id,
+          :amount,
+          :transaction_entity,
+          :currency,
+          :msg_sub_id
+        )
+
+        run(:reauthorize, params)
+      end
+
+      # Do capture
+      #
+      def capture
+        params = collect(
+          :authorization_id,
+          :amount,
+          :currency,
+          :complete_type,
+          :invoice_no,
+          :note,
+          :soft_descriptor,
+          :msg_sub_id,
+          :store_id,
+          :terminal_id
+        )
+
+        run(:capture, params)
+      end
+
+      # Do void
+      #
+      def void
+        params = collect(
+          :authorization_id,
+          :note,
+          :msg_sub_id
+        )
+
+        run(:void, params)
+      end
+    end
+  end
+end