ianfleeton-paypal-express 0.8.2

data/lib/paypal/express/response.rb

@@ -0,0 +1,35 @@
+module Paypal
+  module Express
+    class Response < NVP::Response
+      attr_accessor :pay_on_paypal, :mobile
+
+      def initialize(response, options = {})
+        super response
+        @pay_on_paypal = options[:pay_on_paypal]
+        @mobile        = options[:mobile]
+      end
+
+      def redirect_uri
+        endpoint = URI.parse Paypal.endpoint
+        endpoint.query = query(:with_cmd).to_query
+        endpoint.to_s
+      end
+
+      def popup_uri
+        endpoint = URI.parse Paypal.popup_endpoint
+        endpoint.query = query.to_query
+        endpoint.to_s
+      end
+
+      private
+
+      def query(with_cmd = false)
+        _query_ = {:token => self.token}
+        _query_.merge!(:cmd => '_express-checkout')        if with_cmd
+        _query_.merge!(:cmd => '_express-checkout-mobile') if mobile
+        _query_.merge!(:useraction => 'commit')            if pay_on_paypal
+        _query_
+      end
+    end
+  end
+end

data/lib/paypal/ipn.rb

@@ -0,0 +1,23 @@
+module Paypal
+  module IPN
+    def self.endpoint
+      _endpoint_ = URI.parse Paypal.endpoint
+      _endpoint_.query = {
+        :cmd => '_notify-validate'
+      }.to_query
+      _endpoint_.to_s
+    end
+
+    def self.verify!(raw_post)
+      response = RestClient.post(
+        endpoint, raw_post
+      )
+      case response.body
+      when 'VERIFIED'
+        true
+      else
+        raise Exception::APIError.new(response.body)
+      end
+    end
+  end
+end

data/lib/paypal/nvp/request.rb

@@ -0,0 +1,66 @@
+module Paypal
+  module NVP
+    class Request < Base
+      attr_required :username, :password, :signature
+      attr_optional :subject
+      attr_accessor :version
+
+      ENDPOINT = {
+        :production => 'https://api-3t.paypal.com/nvp',
+        :sandbox => 'https://api-3t.sandbox.paypal.com/nvp'
+      }
+
+      def self.endpoint
+        if Paypal.sandbox?
+          ENDPOINT[:sandbox]
+        else
+          ENDPOINT[:production]
+        end
+      end
+
+      def initialize(attributes = {})
+        @version = Paypal.api_version
+        super
+        self.subject ||= ''
+      end
+
+      def common_params
+        {
+          :USER => self.username,
+          :PWD => self.password,
+          :SIGNATURE => self.signature,
+          :SUBJECT => self.subject,
+          :VERSION => self.version,
+          version: self.version
+        }
+      end
+
+      def request(method, params = {})
+        handle_response do
+          post(method, params)
+        end
+      end
+
+      private
+
+      def post(method, params)
+        RestClient.post(self.class.endpoint, common_params.merge(params).merge(:METHOD => method))
+      end
+
+      def handle_response
+        response = yield
+        response = CGI.parse(response).inject({}) do |res, (k, v)|
+          res.merge!(k.to_sym => v.first)
+        end
+        case response[:ACK]
+        when 'Success', 'SuccessWithWarning'
+          response
+        else
+          raise Exception::APIError.new(response)
+        end
+      rescue RestClient::Exception => e
+        raise Exception::HttpError.new(e.http_code, e.message, e.http_body)
+      end
+    end
+  end
+end

data/lib/paypal/nvp/response.rb

@@ -0,0 +1,237 @@
+module Paypal
+  module NVP
+    class Response < Base
+      cattr_reader :attribute_mapping
+      @@attribute_mapping = {
+        :ACK => :ack,
+        :BUILD => :build,
+        :BILLINGAGREEMENTACCEPTEDSTATUS => :billing_agreement_accepted_status,
+        :CHECKOUTSTATUS => :checkout_status,
+        :CORRELATIONID => :correlation_id,
+        :COUNTRYCODE => :country_code,
+        :CURRENCYCODE => :currency_code,
+        :DESC => :description,
+        :NOTIFYURL => :notify_url,
+        :TIMESTAMP => :timestamp,
+        :TOKEN => :token,
+        :VERSION => :version,
+        # Some of the attributes below are duplicates of what
+        # exists in the payment response, but paypal doesn't
+        # prefix these with PAYMENTREQUEST when issuing a
+        # GetTransactionDetails response.
+        :RECEIVEREMAIL => :receiver_email,
+        :RECEIVERID => :receiver_id,
+        :SUBJECT => :subject,
+        :TRANSACTIONID => :transaction_id,
+        :TRANSACTIONTYPE => :transaction_type,
+        :PAYMENTTYPE => :payment_type,
+        :ORDERTIME => :order_time,
+        :PAYMENTSTATUS => :payment_status,
+        :PENDINGREASON => :pending_reason,
+        :REASONCODE => :reason_code,
+        :PROTECTIONELIGIBILITY => :protection_eligibility,
+        :PROTECTIONELIGIBILITYTYPE => :protection_eligibility_type,
+        :ADDRESSOWNER => :address_owner,
+        :ADDRESSSTATUS => :address_status,
+        :INVNUM => :invoice_number,
+        :CUSTOM => :custom
+      }
+      attr_accessor *@@attribute_mapping.values
+      attr_accessor :shipping_options_is_default, :success_page_redirect_requested, :insurance_option_selected
+      attr_accessor :amount, :description, :ship_to, :bill_to, :payer, :recurring, :billing_agreement, :refund
+      attr_accessor :payment_responses, :payment_info, :items
+      alias_method :colleration_id, :correlation_id # NOTE: I made a typo :p
+
+      def initialize(attributes = {})
+        attrs = attributes.dup
+        @@attribute_mapping.each do |key, value|
+          self.send "#{value}=", attrs.delete(key)
+        end
+        @shipping_options_is_default = attrs.delete(:SHIPPINGOPTIONISDEFAULT) == 'true'
+        @success_page_redirect_requested = attrs.delete(:SUCCESSPAGEREDIRECTREQUESTED) == 'true'
+        @insurance_option_selected = attrs.delete(:INSURANCEOPTIONSELECTED) == 'true'
+        @amount = Payment::Common::Amount.new(
+          :total => attrs.delete(:AMT),
+          :item => attrs.delete(:ITEMAMT),
+          :handing => attrs.delete(:HANDLINGAMT),
+          :insurance => attrs.delete(:INSURANCEAMT),
+          :ship_disc => attrs.delete(:SHIPDISCAMT),
+          :shipping => attrs.delete(:SHIPPINGAMT),
+          :tax => attrs.delete(:TAXAMT),
+          :fee => attrs.delete(:FEEAMT)
+        )
+        @ship_to = Payment::Response::Address.new(
+          :owner => attrs.delete(:SHIPADDRESSOWNER),
+          :status => attrs.delete(:SHIPADDRESSSTATUS),
+          :name => attrs.delete(:SHIPTONAME),
+          :zip => attrs.delete(:SHIPTOZIP),
+          :street => attrs.delete(:SHIPTOSTREET),
+          :street2 => attrs.delete(:SHIPTOSTREET2),
+          :city => attrs.delete(:SHIPTOCITY),
+          :state => attrs.delete(:SHIPTOSTATE),
+          :country_code => attrs.delete(:SHIPTOCOUNTRYCODE),
+          :country_name => attrs.delete(:SHIPTOCOUNTRYNAME),
+        )
+        @bill_to = Payment::Response::Address.new(
+          :owner => attrs.delete(:ADDRESSID),
+          :status => attrs.delete(:ADDRESSSTATUS),
+          :name => attrs.delete(:BILLINGNAME),
+          :zip => attrs.delete(:ZIP),
+          :street => attrs.delete(:STREET),
+          :street2 => attrs.delete(:STREET2),
+          :city => attrs.delete(:CITY),
+          :state => attrs.delete(:STATE),
+          :country_code => attrs.delete(:COUNTRY)
+        )
+        if attrs[:PAYERID]
+          @payer = Payment::Response::Payer.new(
+            :identifier => attrs.delete(:PAYERID),
+            :status => attrs.delete(:PAYERSTATUS),
+            :first_name => attrs.delete(:FIRSTNAME),
+            :last_name => attrs.delete(:LASTNAME),
+            :email => attrs.delete(:EMAIL),
+            :company => attrs.delete(:BUSINESS),
+            :phone_number => attrs.delete(:PHONENUM)
+          )
+        end
+        if attrs[:PROFILEID]
+          @recurring = Payment::Recurring.new(
+            :identifier => attrs.delete(:PROFILEID),
+            # NOTE:
+            #  CreateRecurringPaymentsProfile returns PROFILESTATUS
+            #  GetRecurringPaymentsProfileDetails returns STATUS
+            :description => @description,
+            :status => attrs.delete(:STATUS) || attrs.delete(:PROFILESTATUS),
+            :start_date => attrs.delete(:PROFILESTARTDATE),
+            :name => attrs.delete(:SUBSCRIBERNAME),
+            :reference => attrs.delete(:PROFILEREFERENCE),
+            :auto_bill => attrs.delete(:AUTOBILLOUTAMT),
+            :max_fails => attrs.delete(:MAXFAILEDPAYMENTS),
+            :aggregate_amount => attrs.delete(:AGGREGATEAMT),
+            :aggregate_optional_amount => attrs.delete(:AGGREGATEOPTIONALAMT),
+            :final_payment_date => attrs.delete(:FINALPAYMENTDUEDATE)
+          )
+          if attrs[:BILLINGPERIOD]
+            @recurring.billing = Payment::Recurring::Billing.new(
+              :amount => @amount,
+              :currency_code => @currency_code,
+              :period => attrs.delete(:BILLINGPERIOD),
+              :frequency => attrs.delete(:BILLINGFREQUENCY),
+              :total_cycles => attrs.delete(:TOTALBILLINGCYCLES),
+              :trial => {
+                :period => attrs.delete(:TRIALBILLINGPERIOD),
+                :frequency => attrs.delete(:TRIALBILLINGFREQUENCY),
+                :total_cycles => attrs.delete(:TRIALTOTALBILLINGCYCLES),
+                :currency_code => attrs.delete(:TRIALCURRENCYCODE),
+                :amount => attrs.delete(:TRIALAMT),
+                :tax_amount => attrs.delete(:TRIALTAXAMT),
+                :shipping_amount => attrs.delete(:TRIALSHIPPINGAMT),
+                :paid => attrs.delete(:TRIALAMTPAID)
+              }
+            )
+          end
+          if attrs[:REGULARAMT]
+            @recurring.regular_billing = Payment::Recurring::Billing.new(
+              :amount => attrs.delete(:REGULARAMT),
+              :shipping_amount => attrs.delete(:REGULARSHIPPINGAMT),
+              :tax_amount => attrs.delete(:REGULARTAXAMT),
+              :currency_code => attrs.delete(:REGULARCURRENCYCODE),
+              :period => attrs.delete(:REGULARBILLINGPERIOD),
+              :frequency => attrs.delete(:REGULARBILLINGFREQUENCY),
+              :total_cycles => attrs.delete(:REGULARTOTALBILLINGCYCLES),
+              :paid => attrs.delete(:REGULARAMTPAID)
+            )
+            @recurring.summary = Payment::Recurring::Summary.new(
+              :next_billing_date => attrs.delete(:NEXTBILLINGDATE),
+              :cycles_completed => attrs.delete(:NUMCYCLESCOMPLETED),
+              :cycles_remaining => attrs.delete(:NUMCYCLESREMAINING),
+              :outstanding_balance => attrs.delete(:OUTSTANDINGBALANCE),
+              :failed_count => attrs.delete(:FAILEDPAYMENTCOUNT),
+              :last_payment_date => attrs.delete(:LASTPAYMENTDATE),
+              :last_payment_amount => attrs.delete(:LASTPAYMENTAMT)
+            )
+          end
+        end
+        if attrs[:BILLINGAGREEMENTID]
+          @billing_agreement = Payment::Response::Reference.new(
+            :identifier => attrs.delete(:BILLINGAGREEMENTID),
+            :description => attrs.delete(:BILLINGAGREEMENTDESCRIPTION),
+            status: attrs.delete(:BILLINGAGREEMENTSTATUS),
+            payee_email: attrs.delete(:PAYEEEMAIL),
+            payee_id: attrs.delete(:PAYEEID)
+          )
+          billing_agreement_info = Payment::Response::Info.attribute_mapping.keys.inject({}) do |billing_agreement_info, key|
+            billing_agreement_info.merge! key => attrs.delete(key)
+          end
+          @billing_agreement.info = Payment::Response::Info.new billing_agreement_info
+          @billing_agreement.info.amount = @amount
+        end
+        if attrs[:REFUNDTRANSACTIONID]
+          @refund = Payment::Response::Refund.new(
+            :refund_status => attrs.delete(:REFUNDSTATUS),
+            :transaction_id => attrs.delete(:REFUNDTRANSACTIONID),
+            :amount => {
+              :total => attrs.delete(:TOTALREFUNDEDAMOUNT),
+              :fee => attrs.delete(:FEEREFUNDAMT),
+              :gross => attrs.delete(:GROSSREFUNDAMT),
+              :net => attrs.delete(:NETREFUNDAMT)
+            }
+          )
+        end
+
+        # payment_responses
+        payment_responses = []
+        attrs.keys.each do |_attr_|
+          prefix, index, key = case _attr_.to_s
+          when /^PAYMENTREQUEST/, /^PAYMENTREQUESTINFO/
+            _attr_.to_s.split('_')
+          when /^L_PAYMENTREQUEST/
+            _attr_.to_s.split('_')[1..-1]
+          end
+          if prefix
+            payment_responses[index.to_i] ||= {}
+            payment_responses[index.to_i][key.to_sym] = attrs.delete(_attr_)
+          end
+        end
+        @payment_responses = payment_responses.collect do |_attrs_|
+          Payment::Response.new _attrs_
+        end
+
+        # payment_info
+        payment_info = []
+        attrs.keys.each do |_attr_|
+          prefix, index, key = _attr_.to_s.split('_')
+          if prefix == 'PAYMENTINFO'
+            payment_info[index.to_i] ||= {}
+            payment_info[index.to_i][key.to_sym] = attrs.delete(_attr_)
+          end
+        end
+        @payment_info = payment_info.collect do |_attrs_|
+          Payment::Response::Info.new _attrs_
+        end
+
+        # payment_info
+        items = []
+        attrs.keys.each do |_attr_|
+          key, index = _attr_.to_s.scan(/^L_(.+?)(\d+)$/).flatten
+          if index
+            items[index.to_i] ||= {}
+            items[index.to_i][key.to_sym] = attrs.delete(_attr_)
+          end
+        end
+        @items = items.collect do |_attrs_|
+          Payment::Response::Item.new _attrs_
+        end
+
+        # remove duplicated parameters
+        attrs.delete(:SHIPTOCOUNTRY) # NOTE: Same with SHIPTOCOUNTRYCODE
+        attrs.delete(:SALESTAX) # Same as TAXAMT
+
+        # warn ignored attrs
+        attrs.each do |key, value|
+          Paypal.log "Ignored Parameter (#{self.class}): #{key}=#{value}", :warn
+        end
+      end
+    end
+  end
+end

data/lib/paypal/payment/common/amount.rb

@@ -0,0 +1,13 @@
+module Paypal
+  module Payment
+    module Common
+      class Amount < Base
+        attr_optional :total, :item, :fee, :handing, :insurance, :ship_disc, :shipping, :tax, :gross, :net
+
+        def numeric_attribute?(key)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/paypal/payment/recurring.rb

@@ -0,0 +1,43 @@
+module Paypal
+  module Payment
+    class Recurring < Base
+      attr_optional :start_date, :description, :identifier, :status, :name, :reference, :max_fails, :auto_bill, :aggregate_amount, :aggregate_optional_amount, :final_payment_date
+      attr_accessor :activation, :billing, :regular_billing, :summary
+
+      def initialize(attributes = {})
+        super
+        @activation = Activation.new attributes[:activation] if attributes[:activation]
+        @billing = Billing.new attributes[:billing] if attributes[:billing]
+        @regular_billing = Billing.new attributes[:regular_billing] if attributes[:regular_billing]
+        @summary = Summary.new attributes[:summary] if attributes[:summary]
+      end
+
+      def to_params
+        params = [
+          self.billing,
+          self.activation
+        ].compact.inject({}) do |params, attribute|
+          params.merge! attribute.to_params
+        end
+        if self.start_date.is_a?(Time)
+          self.start_date = self.start_date.to_s(:db)
+        end
+        params.merge!(
+          :DESC  => self.description,
+          :MAXFAILEDPAYMENTS => self.max_fails,
+          :AUTOBILLOUTAMT => self.auto_bill,
+          :PROFILESTARTDATE => self.start_date,
+          :SUBSCRIBERNAME => self.name,
+          :PROFILEREFERENCE => self.reference
+        )
+        params.delete_if do |k, v|
+          v.blank?
+        end
+      end
+
+      def numeric_attribute?(key)
+        super || [:max_fails, :failed_count].include?(key)
+      end
+    end
+  end
+end

data/lib/paypal/payment/recurring/activation.rb

@@ -0,0 +1,14 @@
+module Paypal
+  module Payment
+    class Recurring::Activation < Base
+      attr_optional :initial_amount, :failed_action
+
+      def to_params
+        {
+          :INITAMT => Util.formatted_amount(self.initial_amount),
+          :FAILEDINITAMTACTION => self.failed_action
+        }
+      end
+    end
+  end
+end

data/lib/paypal/payment/recurring/billing.rb

@@ -0,0 +1,39 @@
+module Paypal
+  module Payment
+    class Recurring::Billing < Base
+      attr_optional :period, :frequency, :paid, :currency_code, :total_cycles
+      attr_accessor :amount, :trial
+
+      def initialize(attributes = {})
+        @amount = if attributes[:amount].is_a?(Common::Amount)
+          attributes[:amount]
+        else
+          Common::Amount.new(
+            :total => attributes[:amount],
+            :tax => attributes[:tax_amount],
+            :shipping => attributes[:shipping_amount]
+          )
+        end
+        @trial = Recurring::Billing.new(attributes[:trial]) if attributes[:trial].present?
+        super
+      end
+
+      def to_params
+        trial_params = (trial.try(:to_params) || {}).inject({}) do |trial_params, (key, value)|
+          trial_params.merge(
+            :"TRIAL#{key}" => value
+          )
+        end
+        trial_params.merge(
+          :BILLINGPERIOD => self.period,
+          :BILLINGFREQUENCY => self.frequency,
+          :TOTALBILLINGCYCLES => self.total_cycles,
+          :AMT => Util.formatted_amount(self.amount.total),
+          :CURRENCYCODE => self.currency_code,
+          :SHIPPINGAMT => Util.formatted_amount(self.amount.shipping),
+          :TAXAMT => Util.formatted_amount(self.amount.tax)
+        )
+      end
+    end
+  end
+end