pay 2.2.2 → 2.3.0

data/lib/pay.rb

@@ -12,6 +12,9 @@ module Pay
   @@billable_class = "User"
   @@billable_table = @@billable_class.tableize
 
+  mattr_accessor :model_parent_class
+  @@model_parent_class = "ApplicationRecord"
+
   mattr_accessor :chargeable_class
   mattr_accessor :chargeable_table
   @@chargeable_class = "Pay::Charge"

data/lib/pay/billable.rb

@@ -19,6 +19,7 @@ module Pay
       include Pay::Billable::SyncEmail
       include Pay::Stripe::Billable if defined? ::Stripe
       include Pay::Braintree::Billable if defined? ::Braintree
+      include Pay::Paddle::Billable if defined? ::PaddlePay
 
       has_many :charges, class_name: Pay.chargeable_class, foreign_key: :owner_id, inverse_of: :owner, as: :owner
       has_many :subscriptions, class_name: Pay.subscription_class, foreign_key: :owner_id, inverse_of: :owner, as: :owner
@@ -118,6 +119,10 @@ module Pay
       braintree? && card_type == "PayPal"
     end
 
+    def paddle?
+      processor == "paddle"
+    end
+
     def has_incomplete_payment?(name: "default")
       subscription(name: name)&.has_incomplete_payment?
     end

data/lib/pay/braintree/billable.rb

@@ -1,6 +1,12 @@
 module Pay
   module Braintree
     module Billable
+      extend ActiveSupport::Concern
+
+      included do
+        scope :braintree, -> { where(processor: :braintree) }
+      end
+
       # Handles Billable#customer
       #
       # Returns Braintree::Customer
@@ -35,7 +41,7 @@ module Pay
       # Returns a Pay::Charge
       def create_braintree_charge(amount, options = {})
         args = {
-          amount: amount / 100.0,
+          amount: amount.to_i / 100.0,
           customer_id: customer.id,
           options: {submit_for_settlement: true}
         }.merge(options)
@@ -111,11 +117,11 @@ module Pay
       def braintree_trial_end_date(subscription)
         return unless subscription.trial_period
         # Braintree returns dates without time zones, so we'll assume they're UTC
-        Time.parse(subscription.first_billing_date).end_of_day
+        subscription.first_billing_date.end_of_day
       end
 
       def update_subscriptions_to_payment_method(token)
-        subscriptions.each do |subscription|
+        subscriptions.braintree.each do |subscription|
           if subscription.active?
             gateway.subscription.update(subscription.processor_id, {payment_method_token: token})
           end
@@ -175,7 +181,7 @@ module Pay
 
       def card_details_for_braintree_transaction(transaction)
         case transaction.payment_instrument_type
-        when "credit_card", "samsung_pay_card", "masterpass_card", "samsung_pay_card", "visa_checkout_card"
+        when "credit_card", "samsung_pay_card", "masterpass_card", "visa_checkout_card"
           payment_method = transaction.send("#{transaction.payment_instrument_type}_details")
           {
             card_type: payment_method.card_type,

data/lib/pay/braintree/charge.rb

@@ -3,6 +3,10 @@ module Pay
     module Charge
       extend ActiveSupport::Concern
 
+      included do
+        scope :braintree, -> { where(processor: :braintree) }
+      end
+
       def braintree?
         processor == "braintree"
       end

data/lib/pay/braintree/subscription.rb

@@ -1,6 +1,12 @@
 module Pay
   module Braintree
     module Subscription
+      extend ActiveSupport::Concern
+
+      included do
+        scope :braintree, -> { where(processor: :braintree) }
+      end
+
       def braintree?
         processor == "braintree"
       end

data/lib/pay/engine.rb

@@ -11,6 +11,11 @@ begin
   require "stripe_event"
 rescue LoadError
 end
+
+begin
+  require "paddle_pay"
+rescue LoadError
+end
 # rubocop:enable Lint/HandleExceptions
 
 module Pay
@@ -21,6 +26,7 @@ module Pay
       # Include processor backends
       require "pay/stripe" if defined? ::Stripe
       require "pay/braintree" if defined? ::Braintree
+      require "pay/paddle" if defined? ::PaddlePay
 
       if Pay.automount_routes
         app.routes.append do
@@ -32,6 +38,7 @@ module Pay
     config.to_prepare do
       Pay::Stripe.setup if defined? ::Stripe
       Pay::Braintree.setup if defined? ::Braintree
+      Pay::Paddle.setup if defined? ::PaddlePay
 
       Pay.charge_model.include Pay::Receipts if defined? ::Receipts::Receipt
     end

data/lib/pay/paddle.rb

@@ -0,0 +1,38 @@
+require "pay/env"
+require "pay/paddle/billable"
+require "pay/paddle/charge"
+require "pay/paddle/subscription"
+require "pay/paddle/webhooks"
+
+module Pay
+  module Paddle
+    include Env
+
+    extend self
+
+    def setup
+      ::PaddlePay.config.vendor_id = vendor_id
+      ::PaddlePay.config.vendor_auth_code = vendor_auth_code
+
+      Pay.charge_model.include Pay::Paddle::Charge
+      Pay.subscription_model.include Pay::Paddle::Subscription
+      Pay.billable_models.each { |model| model.include Pay::Paddle::Billable }
+    end
+
+    def vendor_id
+      find_value_by_name(:paddle, :vendor_id)
+    end
+
+    def vendor_auth_code
+      find_value_by_name(:paddle, :vendor_auth_code)
+    end
+
+    def public_key_base64
+      find_value_by_name(:paddle, :public_key_base64)
+    end
+
+    def passthrough(owner:, **options)
+      options.merge(owner_sgid: owner.to_sgid.to_s).to_json
+    end
+  end
+end

data/lib/pay/paddle/billable.rb

@@ -0,0 +1,66 @@
+module Pay
+  module Paddle
+    module Billable
+      extend ActiveSupport::Concern
+
+      included do
+        scope :paddle, -> { where(processor: :paddle) }
+      end
+
+      def paddle_customer
+        # pass
+      end
+
+      def create_paddle_charge(amount, options = {})
+        return unless subscription.processor_id
+        raise Pay::Error, "A charge_name is required to create a one-time charge" if options[:charge_name].nil?
+        response = PaddlePay::Subscription::Charge.create(subscription.processor_id, amount.to_f / 100, options[:charge_name], options)
+        charge = charges.find_or_initialize_by(
+          processor: :paddle,
+          processor_id: response[:invoice_id]
+        )
+        charge.update(
+          amount: Integer(response[:amount].to_f * 100),
+          card_type: subscription.processor_subscription.payment_information[:payment_method],
+          paddle_receipt_url: response[:receipt_url],
+          created_at: DateTime.parse(response[:payment_date])
+        )
+        charge
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Error, e.message
+      end
+
+      def create_paddle_subscription(name, plan, options = {})
+        # pass
+      end
+
+      def update_paddle_card(token)
+        # pass
+      end
+
+      def update_paddle_email!
+        # pass
+      end
+
+      def paddle_trial_end_date(subscription)
+        return unless subscription.state == "trialing"
+        DateTime.parse(subscription.next_payment[:date]).end_of_day
+      end
+
+      def paddle_subscription(subscription_id, options = {})
+        hash = PaddlePay::Subscription::User.list({subscription_id: subscription_id}, options).try(:first)
+        OpenStruct.new(hash)
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Error, e.message
+      end
+
+      def paddle_invoice!(options = {})
+        # pass
+      end
+
+      def paddle_upcoming_invoice
+        # pass
+      end
+    end
+  end
+end

data/lib/pay/paddle/charge.rb

@@ -0,0 +1,39 @@
+module Pay
+  module Paddle
+    module Charge
+      extend ActiveSupport::Concern
+
+      included do
+        scope :paddle, -> { where(processor: :paddle) }
+
+        store_accessor :data, :paddle_receipt_url
+      end
+
+      def paddle?
+        processor == "paddle"
+      end
+
+      def paddle_charge
+        return unless owner.subscription
+        payments = PaddlePay::Subscription::Payment.list({subscription_id: owner.subscription.processor_id})
+        charges = payments.select { |p| p[:id].to_s == processor_id }
+        charges.try(:first)
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Error, e.message
+      end
+
+      def paddle_refund!(amount_to_refund)
+        return unless owner.subscription
+        payments = PaddlePay::Subscription::Payment.list({subscription_id: owner.subscription.processor_id, is_paid: 1})
+        if payments.count > 0
+          PaddlePay::Subscription::Payment.refund(payments.last[:id], {amount: amount_to_refund})
+          update(amount_refunded: amount_to_refund)
+        else
+          raise Error, "Payment not found"
+        end
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Error, e.message
+      end
+    end
+  end
+end

data/lib/pay/paddle/subscription.rb

@@ -0,0 +1,59 @@
+module Pay
+  module Paddle
+    module Subscription
+      extend ActiveSupport::Concern
+
+      included do
+        scope :paddle, -> { where(processor: :paddle) }
+
+        store_accessor :data, :paddle_update_url
+        store_accessor :data, :paddle_cancel_url
+      end
+
+      def paddle?
+        processor == "paddle"
+      end
+
+      def paddle_cancel
+        subscription = processor_subscription
+        PaddlePay::Subscription::User.cancel(processor_id)
+        if on_trial?
+          update(status: :canceled, ends_at: trial_ends_at)
+        else
+          update(status: :canceled, ends_at: DateTime.parse(subscription.next_payment[:date]))
+        end
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Error, e.message
+      end
+
+      def paddle_cancel_now!
+        PaddlePay::Subscription::User.cancel(processor_id)
+        update(status: :canceled, ends_at: Time.zone.now)
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Error, e.message
+      end
+
+      def paddle_pause
+        attributes = {pause: true}
+        response = PaddlePay::Subscription::User.update(processor_id, attributes)
+        update(status: :paused, ends_at: DateTime.parse(response[:next_payment][:date]))
+      end
+
+      def paddle_resume
+        attributes = {pause: false}
+        PaddlePay::Subscription::User.update(processor_id, attributes)
+        update(status: :active, ends_at: nil)
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Error, e.message
+      end
+
+      def paddle_swap(plan)
+        attributes = {plan_id: plan, prorate: prorate}
+        attributes[:quantity] = quantity if quantity?
+        PaddlePay::Subscription::User.update(processor_id, attributes)
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Error, e.message
+      end
+    end
+  end
+end

data/lib/pay/paddle/webhooks.rb

@@ -0,0 +1 @@
+Dir[File.join(__dir__, "webhooks", "**", "*.rb")].sort.each { |file| require file }

data/lib/pay/paddle/webhooks/signature_verifier.rb

@@ -0,0 +1,115 @@
+require "base64"
+require "json"
+require "openssl"
+
+module Pay
+  module Paddle
+    module Webhooks
+      class SignatureVerifier
+        def initialize(data)
+          @data = data
+          @public_key_base64 = Pay::Paddle.public_key_base64
+        end
+
+        def verify
+          data = @data
+          public_key = Base64.decode64(@public_key_base64) if @public_key_base64
+          return false unless data && data["p_signature"] && public_key
+
+          # 'data' represents all of the POST fields sent with the request.
+          # Get the p_signature parameter & base64 decode it.
+          signature = Base64.decode64(data["p_signature"])
+
+          # Remove the p_signature parameter
+          data.delete("p_signature")
+
+          # Ensure all the data fields are strings
+          data.each { |key, value| data[key] = String(value) }
+
+          # Sort the data
+          data_sorted = data.sort_by { |key, value| key }
+
+          # and serialize the fields
+          # serialization library is available here: https://github.com/jqr/php-serialize
+          data_serialized = serialize(data_sorted, true)
+
+          # verify the data
+          digest = OpenSSL::Digest.new("SHA1")
+          pub_key = OpenSSL::PKey::RSA.new(public_key)
+          pub_key.verify(digest, signature, data_serialized)
+        end
+
+        private
+
+        # https://github.com/jqr/php-serialize/blob/master/lib/php_serialize.rb
+        #
+        # Returns a string representing the argument in a form PHP.unserialize
+        # and PHP's unserialize() should both be able to load.
+        #
+        #   string = PHP.serialize(mixed var[, bool assoc])
+        #
+        # Array, Hash, Fixnum, Float, True/FalseClass, NilClass, String and Struct
+        # are supported; as are objects which support the to_assoc method, which
+        # returns an array of the form [['attr_name', 'value']..].  Anything else
+        # will raise a TypeError.
+        #
+        # If 'assoc' is specified, Array's who's first element is a two value
+        # array will be assumed to be an associative array, and will be serialized
+        # as a PHP associative array rather than a multidimensional array.
+        def serialize(var, assoc = false)
+          s = ""
+          case var
+            when Array
+              s << "a:#{var.size}:{"
+              if assoc && var.first.is_a?(Array) && (var.first.size == 2)
+                var.each do |k, v|
+                  s << serialize(k, assoc) << serialize(v, assoc)
+                end
+              else
+                var.each_with_index do |v, i|
+                  s << "i:#{i};#{serialize(v, assoc)}"
+                end
+              end
+              s << "}"
+            when Hash
+              s << "a:#{var.size}:{"
+              var.each do |k, v|
+                s << "#{serialize(k, assoc)}#{serialize(v, assoc)}"
+              end
+              s << "}"
+            when Struct
+              # encode as Object with same name
+              s << "O:#{var.class.to_s.bytesize}:\"#{var.class.to_s.downcase}\":#{var.members.length}:{"
+              var.members.each do |member|
+                s << "#{serialize(member, assoc)}#{serialize(var[member], assoc)}"
+              end
+              s << "}"
+            when String, Symbol
+              s << "s:#{var.to_s.bytesize}:\"#{var}\";"
+            when Integer
+              s << "i:#{var};"
+            when Float
+              s << "d:#{var};"
+            when NilClass
+              s << "N;"
+            when FalseClass, TrueClass
+              s << "b:#{var ? 1 : 0};"
+            else
+              if var.respond_to?(:to_assoc)
+                v = var.to_assoc
+                # encode as Object with same name
+                s << "O:#{var.class.to_s.bytesize}:\"#{var.class.to_s.downcase}\":#{v.length}:{"
+                v.each do |k, v|
+                  s << "#{serialize(k.to_s, assoc)}#{serialize(v, assoc)}"
+                end
+                s << "}"
+              else
+                raise TypeError, "Unable to serialize type #{var.class}"
+              end
+          end
+          s
+        end
+      end
+    end
+  end
+end