paypal_api 0.3.0

data/lib/paypal_api/support/request.rb

@@ -0,0 +1,125 @@
+module Paypal
+	class Request
+
+		cattr_accessor :environment, :user, :pwd, :signature, :version
+
+		PAYPAL_VERSION = "84.0"
+		@@paypal_info = nil
+		@@paypal_endpoint = nil
+
+		# class instance variables (unique per subclass, not unique per instance)
+		# used for dynamically created request classes
+		@required = []
+		@sequential = []
+
+		attr_accessor :payload, :error_message
+
+		def initialize(payload = {})
+			config
+
+			@payload = payload
+			@payload.each do |k,v|
+				self.send("#{k}=", v)
+			end
+		end
+
+		def valid?
+			begin
+				params_fulfilled?
+				validate!
+				return true
+			rescue
+				@error_message = $!.message
+				return false
+			end
+		end
+
+		def self.required_keys
+			@required
+		end
+
+		def self.sequential_keys
+			@sequential
+		end
+
+		def paypal_endpoint_with_defaults
+			return "#{@@paypal_endpoint}?PWD=#{@@paypal_info["password"] || self.class.pwd}" +
+				"&USER=#{@@paypal_info["username"] || self.class.user}" +
+				"&SIGNATURE=#{@@paypal_info["signature"] || self.class.signature}" +
+				"&VERSION=#{self.class.version || PAYPAL_VERSION}"
+		end
+
+		def sequentials_string
+			self.class.sequential_keys.map{|k| self.send(k).to_query_string }.join
+		end
+
+		def request_string
+			(@payload.keys | self.class.required_keys).inject(paypal_endpoint_with_defaults + sequentials_string) do |acc, key|
+				# if key signature is hash or optional...
+				"#{acc}&#{to_key(key)}=#{escape_uri_component(self.send(key))}"
+			end
+		end
+
+		# separated out so as not to stub Kernel.open in tests
+		def make_request
+			response = open(request_string)
+			return Paypal::Response.new(response)
+		end
+
+		def make(&block)
+			params_fulfilled?
+			validate!
+
+			begin
+				response = make_request
+
+				if block
+					yield response
+				else
+					return response
+				end
+			rescue OpenURI::HTTPError => error
+				status_code = error.io.status[0]
+				# Rails.logger.info "[ERROR][Paypal] #{error.message } : #{error.backtrace} " if @@rails
+				raise $!
+			# rescue Timeout::Error => time_out_error
+			# 	Rails.logger.info "[ERROR][Timeout Error] #{time_out_error.message} : #{time_out_error.backtrace}" if @@rails
+			# 	raise $!
+			rescue => err
+				# Rails.logger.info "[ERROR][Something went wrong] #{err.message} : #{err.backtrace}" if @@rails
+				raise $!
+			end
+		end
+
+		protected
+
+			include Paypal::Formatters
+
+			# override for custom request validation
+			def validate!
+				return true
+			end
+
+			def config
+
+				@@paypal_info = {}
+
+				@@paypal_info = get_info if Module.const_defined?("Rails")
+
+				@@paypal_endpoint = (@@paypal_info["environment"] == "production" || Paypal::Request.environment == "production") ? "https://api-3t.paypal.com/nvp" : "https://api-3t.sandbox.paypal.com/nvp"
+
+			end
+
+			def get_info
+				YAML.load(::ERB.new(File.new(Rails.root.join("config", "paypal.yml")).read).result)[Rails.env]
+			end
+
+			def params_fulfilled?
+				self.class.required_keys.each do |method|
+					raise Paypal::InvalidRequest, "missing required field: #{method}" if self.send(method).nil?
+				end
+
+				# TODO: check if sequential has been fulfilled
+			end
+	end
+end

data/lib/paypal_api/support/response.rb

@@ -0,0 +1,77 @@
+module Paypal
+	class Response
+
+		attr_accessor :raw_response, :parsed_response, :error_code
+
+		def initialize(stringio)
+			@raw_response = stringio.class == StringIO ? stringio.read : stringio
+			@parsed_response = CGI.parse(@raw_response)
+
+			@success = @parsed_response["ACK"] == ["Success"]
+
+			unless @success
+				@error_message = @parsed_response["L_LONGMESSAGE0"][0]
+				@error_code = @parsed_response["L_ERRORCODE0"][0]
+			end
+		end
+
+		def [](key)
+			if key.class == Symbol
+				@parsed_response[symbol_to_key(key)][0]
+			else
+				@parsed_response[key][0]
+			end
+		end
+
+		def success?
+			return @success
+		end
+
+		def method_missing?(key)
+			return @parsed_response[symbol_to_key(key)]
+		end
+
+		def error_input
+			@@error_codes[@error_code]
+		end
+
+		def error_field
+			@@error_codes[@error_code] ? @@human_readable[@@error_codes[@error_code]] : nil
+		end
+
+		def error_message
+			@error_message + "[#{@error_code}]"
+		end
+
+		private
+
+			def symbol_to_key(symbol)
+				return symbol.to_s.gsub(/[^0-9a-z]/i, "").upcase
+			end
+	end
+end
+
+class Paypal::Response
+	@@error_codes = {
+		'10527' => :acct,
+		'10525' => :amt,
+		'10508' => :exp_date,
+		'10504' => :cvv2,
+		'10502' => :acct,
+		'10501' => :reference_id,
+		'10509' => :ip_address,
+		'10510' => :acct,
+		'10519' => :acct,
+		'10521' => :acct,
+		'10526' => :currency_code
+	}
+
+	@@human_readable = {
+		:acct => "credit card number",
+		:amt => "charge amount",
+		:exp_date => "expiration date",
+		:cvv2 => "security code",
+		:reference_id => "billing agreement",
+		:currency_code => "currency code"
+	}
+end

data/lib/paypal_api/version.rb

@@ -0,0 +1,3 @@
+module Paypal
+  VERSION = "0.3.0"
+end

data/lib/paypal_api.rb

@@ -0,0 +1,21 @@
+require "cgi"
+require "open-uri"
+require 'active_support/core_ext/class/attribute_accessors'
+
+module Paypal
+	class InvalidRequest < StandardError; end
+
+	class InvalidParameter < StandardError; end
+
+	class PaypalApiError < StandardError; end
+end
+
+$:.push File.expand_path("../../lib", __FILE__)
+
+require "paypal_api/version"
+require "paypal_api/apis/api"
+require "paypal_api/support/parameter"
+require "paypal_api/support/response"
+require "paypal_api/support/request"
+require "paypal_api/apis/payments_pro"
+require "paypal_api/apis/mass_pay"

data/paypal_api.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "paypal_api/version"
+
+Gem::Specification.new do |s|
+  s.name        = "paypal_api"
+  s.version     = Paypal::VERSION
+  s.authors     = ["Matt Handler"]
+  s.email       = ["matt.handler@gmail.com"]
+  s.homepage    = "https://github.com/matthandlersux/paypal_api"
+  s.summary     = %q{an interface to paypals api}
+  s.description = %q{alpha - currently covers part of payments pro and all of mass pay}
+
+  s.rubyforge_project = "paypal_api"
+
+  s.files         = `git ls-files`.split("\n") + ["init.rb"]
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activesupport", "3.2.1"
+
+  s.add_development_dependency "rspec", "~> 2.6"
+  s.add_development_dependency "rspec-mocks", "~> 2.6"
+  s.add_development_dependency "rake", "0.8.7"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'paypal_api' # and any other gems you need
+
+RSpec.configure do |config|
+  # some (optional) config here
+  # config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run_excluding :slow_paypal => true
+end

data/spec/support/parameter_spec.rb

@@ -0,0 +1,189 @@
+require "spec_helper"
+
+describe Paypal::Api::Parameter do
+	before do
+		@api = Paypal::Api
+	end
+
+	describe Paypal::Api::Enum do
+		it "should only allow enumerated input" do
+			param = @api::Enum.new("first", "second", "third")
+
+			param.parse("first").should eq("first")
+			param.parse("second").should eq("second")
+			param.parse("third").should eq("third")
+
+			expect {
+				param.parse("anything else")
+			}.to raise_exception(Paypal::InvalidParameter)
+		end
+
+		describe "hash enumerations" do
+			before(:each) do
+				@param = @api::Enum.new({:thing => "OK", :that => "TEO"})
+			end
+
+			it "should allow symbols to have formatted values as output" do
+				@param.parse(:thing).should eq("OK")
+				@param.parse(:that).should eq("TEO")
+			end
+
+			it "should not respond to symbols that aren't in the hash" do
+				expect {
+					@param.parse("anything_else")
+				}.to raise_exception(Paypal::InvalidParameter)
+			end
+
+			it "should know it's a hash enumeration" do
+				@param.instance_variable_get("@hash_enum").should be_true
+			end
+		end
+
+		it "should coerce symbols to strings" do
+			param = @api::Enum.new("First", "Second", "ThirdThing")
+
+			param.parse(:first).should eq("First")
+			param.parse(:second).should eq("Second")
+			param.parse(:third_thing).should eq("ThirdThing")
+
+			expect {
+				param.parse(:anything_else)
+			}.to raise_exception(Paypal::InvalidParameter)
+		end
+	end
+
+	describe Paypal::Api::Coerce do
+		it "should allow a well formed coercion" do
+			param = @api::Coerce.new( lambda { |val| return [1, "1", true].include?(val) ? 1 : 0 } )
+
+			param.parse(1).should eq(1)
+			param.parse("1").should eq(1)
+			param.parse(true).should eq(1)
+
+			param.parse(23).should eq(0)
+			param.parse("adfa").should eq(0)
+		end
+	end
+
+	describe Paypal::Api::Sequential do
+		before do
+			class Test < @api
+				set_request_signature :tester, {
+					:sequential => @api::Sequential.new({:l_string => String, :l_fixnum => Fixnum, :l_set_category => Optional.new(String)})
+				}
+			end
+
+			@request = Test.tester
+			@request.sequential.push({:l_string => "sasdf", :l_fixnum => 23, :l_set_category => "asdfasdf"})
+
+
+			expect {
+				@request.sequential.push({:l_string => "sass"})
+			}.to raise_exception Paypal::InvalidParameter
+
+			expect {
+				@request.sequential.push({:l_string => "sass", :l_fixnum => "string"})
+			}.to raise_exception Paypal::InvalidParameter
+		end
+
+		it "should allow nestedly defined params" do
+			@request.sequentials_string.should include("sasdf")
+			@request.sequentials_string.should include("23")
+		end
+
+		it "should allow optional params" do
+			@request.sequential.push({:l_string => "alf", :l_fixnum => 22})
+			@request.sequentials_string.should_not include("L_SETCATEGORY1")
+		end
+
+		it "should number the items" do
+			@request.sequential.push({:l_string => "alf", :l_fixnum => 22})
+			@request.sequentials_string.should include("L_FIXNUM1")
+			@request.sequentials_string.should include("L_SETCATEGORY0")
+		end
+
+		it "should keep the first underscore" do
+			param = @api::Sequential.new({:l_test => String})
+			param.to_key(:l_test, 0).should eq("L_TEST0")
+			param.to_key(:l_set_category, 1).should eq("L_SETCATEGORY1")
+		end
+
+		it "should allow a list length limit to be set" do
+			expect {
+				param = @api::Sequential.new({:l_test => String}, 2)
+			}.to_not raise_exception
+		end
+
+		it "should raise an InvalidParameter exception when more than the limit is pushed" do
+			param = @api::Sequential.new({:test => String}, 2)
+			param.push(:test => "ok")
+			param.push(:test => "asdf")
+
+			expect {
+				param.push(:test => "asdfasdf")
+			}.to raise_exception(Paypal::InvalidParameter)
+		end
+
+		describe "when a to_key proc is provided" do
+			it "should use the proc to output keys" do
+				@lambda = lambda {|key, i|
+					"someThing#{i}.#{key}"
+				}
+				param = @api::Sequential.new({:test => String}, 2, @lambda)
+				param.push(:test => "ok")
+				param.push(:test => "asdf")
+
+				param.to_query_string.should eq("&someThing0.test=ok&someThing1.test=asdf")
+			end
+		end
+	end
+
+	describe Paypal::Api::Hash do
+
+	end
+
+	describe Paypal::Api::Optional do
+
+		it "should allow optional enum" do
+			param = @api::Optional.new(@api::Enum.new("test", "tamp"))
+
+			expect {
+				param.parse("tisk")
+			}.to raise_exception(Paypal::InvalidParameter)
+
+			param.parse("test").should eq("test")
+		end
+
+		it "should allow optional regexp" do
+			param = @api::Optional.new(/test/)
+
+			expect {
+				param.parse("tisk")
+			}.to raise_exception(Paypal::InvalidParameter)
+
+			param.parse("test").should eq("test")
+			param.parse(" sdf a test").should eq("test")
+		end
+
+		it "should allow optional class specifiers" do
+			param = @api::Optional.new(String)
+
+			expect {
+				param.parse(2)
+			}.to raise_exception(Paypal::InvalidParameter)
+
+			param.parse("test").should eq("test")
+			param.parse(" sdf a test").should eq(" sdf a test")
+		end
+
+		it "should allow a hash specifier"
+
+		describe "when hash specifier provided" do
+			it "should still be allowed to have optional within"
+
+			it "should validate required fields"
+
+			it "should dot the fields together somehow?"
+		end
+	end
+end

data/spec/support/request_spec.rb

@@ -0,0 +1,143 @@
+require "spec_helper"
+
+describe Paypal::Request do
+
+	it "should create a well formed url" do
+		request = Paypal::Request.new
+
+		url = request.paypal_endpoint_with_defaults
+		URI.parse(url)
+	end
+
+	it "should allow you to set the environment" do
+		Paypal::Request.environment = "production"
+
+		Paypal::Request.new
+		Paypal::Request.class_variable_get("@@paypal_endpoint").should eq("https://api-3t.paypal.com/nvp")
+
+		Paypal::Request.environment = "development"
+
+		Paypal::Request.new
+		Paypal::Request.class_variable_get("@@paypal_endpoint").should eq("https://api-3t.sandbox.paypal.com/nvp")
+	end
+
+	it "should allow you to set the user pwd and signature" do
+		Paypal::Request.user = "asdf"
+		Paypal::Request.pwd = "zxcv"
+		Paypal::Request.signature = ";lkj"
+
+		request = Paypal::Request.new
+		request.request_string.should include("USER=asdf")
+		request.request_string.should include("PWD=zxcv")
+		request.request_string.should include("SIGNATURE=;lkj")
+	end
+
+	it "should allow you to set the version" do
+		Paypal::Request.version = "76.0"
+
+		request = Paypal::Request.new
+		request.request_string.should include("VERSION=76.0")
+	end
+
+	describe "should look for a config file if we're in rails" do
+
+		describe "for production" do
+			before do
+				Module.should_receive(:const_defined?).and_return(true)
+
+				Paypal::Request.any_instance.should_receive(:get_info).and_return({"environment" => "production" })
+			end
+
+			it "should use the real server" do
+				Paypal::Request.new
+				Paypal::Request.class_variable_get("@@paypal_endpoint").should eq("https://api-3t.paypal.com/nvp")
+			end
+		end
+
+		describe "for anything else" do
+			before do
+				Paypal::Request.any_instance.stub(:get_info).and_return({
+							"production" => { "environment" => "development" }
+						})
+			end
+
+			it "should use the sandbox server" do
+				Paypal::Request.new
+				Paypal::Request.class_variable_get("@@paypal_endpoint").should eq("https://api-3t.sandbox.paypal.com/nvp")
+			end
+		end
+	end
+
+	context "when making requests" do
+		before do
+			@api = Paypal::Api
+
+			class Test < @api
+				set_request_signature :tester, {
+					:test_field => "something",
+					:optional => @api::Optional.new(String),
+					:string => String,
+					:fixnum => Fixnum,
+					:default => @api::Default.new("tamp", Fixnum),
+					:enum => @api::Enum.new("One", "Two"),
+					:sequential => @api::Sequential.new({:l_string => String, :l_fixnum => Fixnum, :l_set_category => Optional.new(String)})
+				}
+			end
+
+			@request = Test.tester({
+				:string => "adsafasdf",
+				:fixnum => 23,
+				:enum => :one
+			})
+
+			@request.sequential.push({:l_string => "tamp", :l_fixnum => 2323})
+
+			@string = @request.request_string
+		end
+
+		it "should create a request string with params" do
+			@string.should include("TESTFIELD")
+			@string.should include("something")
+			@string.should include("adsafasdf")
+			@string.should_not include("OPTIONAL")
+			@string.should include("ENUM=One")
+		end
+
+		it "should add userpass and secret fields" do
+			@string.should include("PWD")
+			@string.should include("USER")
+			@string.should include("SIGNATURE")
+			@string.should include("VERSION")
+		end
+
+		it "should use a paypal endpoint" do
+			@string.should include(".paypal.com/nvp")
+		end
+
+		it "should have required keys set" do
+			@request.class.required_keys.should eq([:test_field, :string, :fixnum, :default, :enum])
+		end
+
+		it "should include sequential stuff in the request string" do
+			@string.should include("L_STRING0")
+			@string.should include("L_FIXNUM0")
+		end
+
+		it "should return a well formed url" do
+			parsed = nil
+			expect {
+				parsed = URI.parse(@string)
+			}.to_not raise_exception
+
+			parsed.query.should include("TESTFIELD")
+			parsed.query.should include("L_STRING0")
+
+			hash = nil
+			expect {
+				hash = CGI.parse parsed.query
+			}.to_not raise_exception
+
+			hash.keys.should include("L_STRING0")
+		end
+	end
+end

data/spec/support/response_spec.rb

@@ -0,0 +1,33 @@
+describe Paypal::Response do
+	it "should initialize with a stringio" do
+
+	end
+
+	describe "bracket access" do
+		it "should allow symbol access" do
+
+		end
+
+		it "should allow string access" do
+
+		end
+
+		it "should convert symbols to the right formatting" do
+
+		end
+	end
+
+	describe "method access" do
+		it "should succeed" do
+
+		end
+
+		it "should fail when the resulting key doesn't match" do
+
+		end
+
+		it "should convert symbols to the right formatting" do
+
+		end
+	end
+end