elucid-adaptive_pay 0.2.1

data/lib/adaptive_pay/cancel_preapproval_request.rb

@@ -0,0 +1,16 @@
+module AdaptivePay
+  class CancelPreapprovalRequest < Request
+
+    def self.response_type
+      :cancel_preapproval
+    end
+
+    def self.endpoint
+      "CancelPreapproval"
+    end
+
+    attribute "requestEnvelope.errorLanguage", :default => "en_US"
+    attribute "preapprovalKey"
+
+  end
+end

data/lib/adaptive_pay/interface.rb

@@ -0,0 +1,93 @@
+require "erb"
+
+module AdaptivePay
+  class Interface
+
+    def self.requests
+      @requests ||= []
+    end
+
+    cattr_accessor :test_response
+    attr_accessor :test_response
+
+    attr_accessor :base_url, :base_page_url, :environment, :username, :password, :signature, :application_id, :retain_requests_for_test
+
+    def self.test_interface(response = nil)
+      iface = new false
+      iface.retain_requests_for_test = true
+      iface.test_response = response
+      iface
+    end
+
+    # Initialize a new interface object, takes an optional rails_env parameter
+    # 
+    # The rails_env parameter decides which configuration to load can be:
+    #   nil -> use current Rails.env section in config/adaptive_pay.yml
+    #   false -> dont load config from config/adaptive_pay.yml
+    #   string/symbol -> use that section from config/adaptive_pay.yml
+    def initialize(rails_env=nil)
+      load(rails_env||Rails.env) unless rails_env == false
+    end
+
+    def load(rails_env)
+      config = YAML.load(ERB.new(File.read(File.join(Rails.root, "config/adaptive_pay.yml"))).result)[rails_env.to_s]
+      if config["retain_requests_for_test"] == true
+        @retain_requests_for_test = true
+      end
+
+      set_environment config.delete("environment")
+      config.each do |k, v|
+        send "#{k}=", v
+      end
+    end
+
+    # Explicitly select a paypal environment to connect to
+    # environment parameter can be :production, :sandbox, :beta_sandbox
+    def set_environment(environment)
+      @environment = environment.to_sym
+      @base_url = {
+        :production => "https://svcs.paypal.com/AdaptivePayments/",
+        :sandbox => "https://svcs.sandbox.paypal.com/AdaptivePayments/",
+        :beta_sandbox => "https://svcs.beta-sandbox.paypal.com/AdaptivePayments/"
+      }[@environment]
+      @base_page_url = {
+        :production => "https://www.paypal.com",
+        :sandbox => "https://www.sandbox.paypal.com",
+        :beta_sandbox => "https://www.beta-sandbox.paypal.com"
+      }[@environment]
+    end
+
+    def retain_requests_for_test?
+      !!@retain_requests_for_test
+    end
+
+    # send a preapproved payment request to paypal
+    def request_preapproval(&block)
+      request = PreapprovalRequest.new
+      yield request
+      perform request
+    end
+
+    def request_payment(&block)
+      request = PaymentRequest.new
+      yield request
+      perform request
+    end
+
+    def request_refund(&block)
+      request = RefundRequest.new
+      yield request
+      perform request
+    end
+
+    def perform(request)
+      if retain_requests_for_test?
+        self.class.requests << request
+        test_response || self.class.test_response
+      else
+        request.perform self
+      end
+    end
+
+  end
+end

data/lib/adaptive_pay/parser.rb

@@ -0,0 +1,43 @@
+module AdaptivePay
+  module Parser
+    # parse PayPal NVP message into nested Hash/Array structure
+    # * treats '.' in key as nesting level
+    # * treats \d+ key suffix as list index
+    # e.g.
+    # "namespace.listitem(0).key=value0&namespace.listitem(1).key=value1"
+    #   parses to
+    # {"namespace" => {"listitem" => [{"key" => "value0"}, {"key" => "value1"}]}
+    def self.parse(body)
+      params = {}
+      body.split('&').each do |kvp|
+        key, value = kvp.split(/=/, 2)
+
+        # keys may be nested e.g. responseEnvelope.ack
+        keys = key.split('.')
+        value = URI.unescape(value)
+
+        # simple (non-nested, non-indexed) key
+        if keys.size == 1
+          params[keys.first] = value
+        else
+          keys, last_key = keys[0..-2], keys.last
+          keys.inject(params) do |a,e|
+            # indexed key e.g. refundInfo(0)
+            if m = e.match(/^(.*)\((\d+)\)$/)
+              key = m[1]
+              index = m[2].to_i
+              a[key] ||= []
+              a[key][index] ||= {}
+              a[key][index]
+            # non-indexed key
+            else
+              a[e] ||= {}
+              a[e]
+            end
+          end[last_key] = value
+        end
+      end
+      params
+    end
+  end
+end

data/lib/adaptive_pay/payment_request.rb

@@ -0,0 +1,48 @@
+module AdaptivePay
+  class PaymentRequest < AbstractPaymentRequest
+
+    def self.response_type
+      :payment
+    end
+
+    def self.endpoint
+      "Pay"
+    end
+
+    attr_reader :recipients
+
+    attribute "actionType", :default => "PAY"
+    attribute "preapprovalKey"
+    attribute "pin"
+    attribute "feesPayer"
+    attribute "logDefaultShippingAddress"
+    attribute "reverseAllParallelPaymentsOnError"
+    attribute "trackingId"
+
+    def initialize(&block)
+      @recipients = []
+      super
+    end
+
+    def add_recipient(recipient_options)
+      if recipient_options.is_a?(AdaptivePay::Recipient)
+        @recipients << recipient_options
+      else
+        @recipients << AdaptivePay::Recipient.new(recipient_options)
+      end
+    end
+
+    protected
+      def extra_attributes
+        result = {}
+        recipients.each_with_index do |r, i|
+          result["receiverList.receiver(#{i}).email"] = r.email
+          result["receiverList.receiver(#{i}).amount"] = sprintf "%.2f", r.amount
+          result["receiverList.receiver(#{i}).primary"] = r.primary?
+          result["receiverList.receiver(#{i}).invoiceId"] = r.invoice_id if r.invoice_id
+        end
+        super.merge(result)
+      end
+
+  end
+end

data/lib/adaptive_pay/preapproval_request.rb

@@ -0,0 +1,24 @@
+module AdaptivePay
+  class PreapprovalRequest < AbstractPaymentRequest
+
+    def self.response_type
+      :preapproval
+    end
+
+    def self.endpoint
+      "Preapproval"
+    end
+
+    attribute "dateOfMonth"
+    attribute "dayOfWeek"
+    attribute "endingDate", :format => :date
+    attribute "startingDate", :format => :date
+    attribute "maxAmountPerPayment"
+    attribute "maxNumberOfPayments"
+    attribute "maxNumberOfPaymentsPerPeriod"
+    attribute "maxTotalAmountOfAllPayments"
+    attribute "paymentPeriod"
+    attribute "pinType"
+
+  end
+end

data/lib/adaptive_pay/recipient.rb

@@ -0,0 +1,17 @@
+module AdaptivePay
+  class Recipient
+
+    attr_accessor :email, :amount, :primary, :invoice_id
+
+    def initialize(options={})
+      options.each do |k, v|
+        send "#{k}=", v
+      end
+    end
+
+    def primary?
+      !!@primary
+    end
+
+  end
+end

data/lib/adaptive_pay/refund_request.rb

@@ -0,0 +1,46 @@
+module AdaptivePay
+  class RefundRequest < Request
+
+    def self.response_type
+      :refund
+    end
+
+    def self.endpoint
+      "Refund"
+    end
+
+    attr_reader :recipients
+
+    attribute "requestEnvelope.errorLanguage", :default => "en_US"
+    attribute "currencyCode"
+    attribute "payKey"
+    attribute "trackingId"
+    attribute "transactionId"
+    attribute "ipnNotificationUrl"
+
+    def initialize(&block)
+      @recipients = []
+      super
+    end
+
+    def add_recipient(recipient_options)
+      if recipient_options.is_a?(AdaptivePay::Recipient)
+        @recipients << recipient_options
+      else
+        @recipients << AdaptivePay::Recipient.new(recipient_options)
+      end
+    end
+
+    protected
+      def extra_attributes
+        result = {}
+        recipients.each_with_index do |r, i|
+          result["receiverList.receiver(#{i}).email"] = r.email
+          result["receiverList.receiver(#{i}).amount"] = sprintf "%.2f", r.amount
+          result["receiverList.receiver(#{i}).primary"] = r.primary?
+        end
+        super.merge(result)
+      end
+
+  end
+end

data/lib/adaptive_pay/request.rb

@@ -0,0 +1,124 @@
+require "net/http"
+require "net/https"
+require 'bigdecimal/util'
+
+module AdaptivePay
+  class Request
+
+    def self.response_type
+      :other
+    end
+
+    class_inheritable_accessor :attributes
+    self.attributes = []
+
+    def self.attribute(name, options={})
+      top_level_name = name.to_s.split(".").last.underscore
+      define_method top_level_name do
+        read_attribute name
+      end
+
+      define_method "#{top_level_name}=" do |value|
+        write_attribute name, value
+      end
+
+      self.attributes << options.merge(:name => name)
+    end
+
+    def self.attribute_names
+      self.attributes.map { |a| a[:name] }
+    end
+
+
+    def initialize(&block)
+      @attributes = {}
+      self.class.attributes.each do |k|
+        write_attribute k[:name], k[:default] if k[:default]
+      end
+      yield self if block_given?
+    end
+
+    def read_attribute(name)
+      @attributes[name]
+    end
+
+    def format_attribute(name)
+      attrib = self.class.attributes.find { |a| a[:name] == name }
+      case
+      when attrib.nil?
+        nil
+      when attrib[:format] == :date
+        @attributes[name].strftime("%Y-%m-%d")
+      else
+        @attributes[name]
+      end
+    end
+
+    def write_attribute(name, value)
+      @attributes[name] = value
+    end
+
+
+    def perform(interface)
+      uri = construct_uri(interface)
+      request = Net::HTTP::Post.new uri.request_uri
+      request.body = serialize
+      request.initialize_http_header(headers(interface))
+      http_response = build_http(uri).request request
+      Response.new interface, self.class.response_type, http_response
+    end
+
+    def serialize
+      result = []
+      all_attributes.each do |k, v|
+        # the optional second param to URI.escape defaults to URI::UNSAFE
+        # which doesn't match '&' as it is a valid URI character.
+        # however, '&' is not a valid character within NVP values.
+        escaped_v = URI.escape(v.to_s, /[^-_.!~*'()a-zA-Z\d;\/?:@+$#,\[\]]/n)
+        result << "#{k}=#{escaped_v}"
+      end
+      result.join("&")
+    end
+
+    protected
+      def construct_uri(interface)
+        if interface.base_url.ends_with?("/")
+          URI.parse("#{interface.base_url}#{self.class.endpoint}")
+        else
+          URI.parse("#{interface.base_url}/#{self.class.endpoint}")
+        end
+      end
+
+      def build_http(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.port == 443)
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+        http
+      end
+
+      def headers(interface)
+        {
+          "X-PAYPAL-SECURITY-USERID" => interface.username.to_s,
+          "X-PAYPAL-SECURITY-PASSWORD" => interface.password.to_s,
+          "X-PAYPAL-SECURITY-SIGNATURE" => interface.signature.to_s,
+          "X-PAYPAL-APPLICATION-ID" => interface.application_id.to_s,
+          "X-PAYPAL-REQUEST-DATA-FORMAT" => "NV",
+          "X-PAYPAL-RESPONSE-DATA-FORMAT" => "NV"
+        }
+      end
+
+      def all_attributes
+        result = {}
+        self.class.attribute_names.each do |name|
+          value = read_attribute(name)
+          result[name] = format_attribute(name) unless value.nil?
+        end
+        result.merge(extra_attributes)
+      end
+
+      def extra_attributes
+        {}
+      end
+
+  end
+end

data/lib/adaptive_pay/response.rb

@@ -0,0 +1,76 @@
+module AdaptivePay
+  class Response
+
+    attr_reader :raw
+
+    def initialize(interface, type, response)
+      @type = type
+      @base_page_url = interface.base_page_url
+      @attributes = {}
+      @raw = response.body
+      parse response
+    end
+
+    def success?
+      !!@success
+    end
+
+    def failure?
+      !@success
+    end
+
+
+    def created?
+      payment_exec_status == "CREATED"
+    end
+
+    def pending?
+      payment_exec_status == "PENDING"
+    end
+
+    def completed?
+      payment_exec_status == "COMPLETED"
+    end
+
+    def errors
+      read_attribute("error")
+    end
+
+
+    def payment_page_url
+      case @type
+      when :preapproval
+        "#{@base_page_url}/webscr?cmd=_ap-preapproval&preapprovalkey=#{URI.escape(preapproval_key)}"
+      when :payment
+        "#{@base_page_url}/webscr?cmd=_ap-payment&paykey=#{URI.escape(pay_key)}"
+      end
+    end
+
+    def read_attribute(name)
+      names = name.split('.')
+      names, last_name = names[0..-2], names.last
+      names.inject(@attributes) {|a,n| a[n] || {}}[last_name]
+    end
+
+    def method_missing(name, *args)
+      if @attributes.has_key?(name.to_s.camelize(:lower))
+        @attributes[name.to_s.camelize(:lower)]
+      else
+        super
+      end
+    end
+
+    protected
+      def parse(response)
+        unless response.code.to_s == "200"
+          @success = false
+          return
+        end
+
+        @attributes = Parser.parse(response.body)
+
+        @success = %w{Success SuccessWithWarning}.include?(read_attribute("responseEnvelope.ack"))
+      end
+
+  end
+end