pay 2.2.0 → 2.4.0

data/lib/pay/paddle/subscription.rb

@@ -0,0 +1,70 @@
+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
+        store_accessor :data, :paddle_paused_from
+      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: Time.zone.parse(subscription.next_payment[:date]))
+        end
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Pay::Paddle::Error, e
+      end
+
+      def paddle_cancel_now!
+        PaddlePay::Subscription::User.cancel(processor_id)
+        update(status: :canceled, ends_at: Time.zone.now)
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Pay::Paddle::Error, e
+      end
+
+      def paddle_on_grace_period?
+        canceled? && Time.zone.now < ends_at || paused? && Time.zone.now < paddle_paused_from
+      end
+
+      def paddle_paused?
+        paddle_paused_from.present?
+      end
+
+      def paddle_pause
+        attributes = {pause: true}
+        response = PaddlePay::Subscription::User.update(processor_id, attributes)
+        update(paddle_paused_from: Time.zone.parse(response[:next_payment][:date]))
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Pay::Paddle::Error, e
+      end
+
+      def paddle_resume
+        attributes = {pause: false}
+        PaddlePay::Subscription::User.update(processor_id, attributes)
+        update(status: :active, paddle_paused_from: nil)
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Pay::Paddle::Error, e
+      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 Pay::Paddle::Error, e
+      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

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

@@ -0,0 +1,18 @@
+module Pay
+  module Paddle
+    module Webhooks
+      class SubscriptionCancelled
+        def initialize(data)
+          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: data["subscription_id"])
+
+          # We couldn't find the subscription for some reason, maybe it's from another service
+          return if subscription.nil?
+
+          # User canceled subscriptions have an ends_at
+          # Automatically canceled subscriptions need this value set
+          subscription.update!(ends_at: Time.zone.parse(data["cancellation_effective_date"])) if subscription.ends_at.blank? && data["cancellation_effective_date"].present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Pay
+  module Paddle
+    module Webhooks
+      class SubscriptionCreated
+        def initialize(data)
+          # We may already have the subscription in the database, so we can update that record
+          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: data["subscription_id"])
+
+          # Create the subscription in the database if we don't have it already
+          if subscription.nil?
+
+            # The customer could already be in the database
+            owner = Pay.find_billable(processor: :paddle, processor_id: data["user_id"])
+
+            if owner.nil?
+              owner = owner_by_passtrough(data["passthrough"], data["subscription_plan_id"])
+              owner&.update!(processor: "paddle", processor_id: data["user_id"])
+            end
+
+            if owner.nil?
+              Rails.logger.error("[Pay] Unable to find Pay::Billable with owner: '#{data["passthrough"]}'. Searched these models: #{Pay.billable_models.join(", ")}")
+              return
+            end
+
+            subscription = Pay.subscription_model.new(owner: owner, name: Pay.default_product_name, processor: "paddle", processor_id: data["subscription_id"], status: :active)
+          end
+
+          subscription.quantity = data["quantity"]
+          subscription.processor_plan = data["subscription_plan_id"]
+          subscription.paddle_update_url = data["update_url"]
+          subscription.paddle_cancel_url = data["cancel_url"]
+          subscription.trial_ends_at = Time.zone.parse(data["next_bill_date"]) if data["status"] == "trialing"
+
+          # If user was on trial, their subscription ends at the end of the trial
+          subscription.ends_at = if ["paused", "deleted"].include?(data["status"]) && subscription.on_trial?
+            subscription.trial_ends_at
+
+          # User wasn't on trial, so subscription ends at period end
+          elsif ["paused", "deleted"].include?(data["status"])
+            Time.zone.parse(data["next_bill_date"])
+
+            # Subscription isn't marked to cancel at period end
+          end
+
+          subscription.save!
+        end
+
+        private
+
+        def owner_by_passtrough(passthrough, product_id)
+          passthrough_json = JSON.parse(passthrough)
+          GlobalID::Locator.locate_signed(passthrough_json["owner_sgid"])
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Pay
+  module Paddle
+    module Webhooks
+      class SubscriptionPaymentRefunded
+        def initialize(data)
+          charge = Pay.charge_model.find_by(processor: :paddle, processor_id: data["subscription_payment_id"])
+          return unless charge.present?
+
+          charge.update(amount_refunded: Integer(data["gross_refund"].to_f * 100))
+          notify_user(charge.owner, charge)
+        end
+
+        def notify_user(billable, charge)
+          if Pay.send_emails
+            Pay::UserMailer.with(billable: billable, charge: charge).refund.deliver_later
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Pay
+  module Paddle
+    module Webhooks
+      class SubscriptionPaymentSucceeded
+        def initialize(data)
+          billable = Pay.find_billable(processor: :paddle, processor_id: data["user_id"])
+          return unless billable.present?
+          return if billable.charges.where(processor_id: data["subscription_payment_id"]).any?
+
+          charge = create_charge(billable, data)
+          notify_user(billable, charge)
+        end
+
+        def create_charge(user, data)
+          charge = user.charges.find_or_initialize_by(
+            processor: :paddle,
+            processor_id: data["subscription_payment_id"]
+          )
+
+          params = {
+            amount: Integer(data["sale_gross"].to_f * 100),
+            card_type: data["payment_method"],
+            paddle_receipt_url: data["receipt_url"],
+            created_at: Time.zone.parse(data["event_time"])
+          }
+
+          payment_information = user.paddle_payment_information(data["subscription_id"])
+
+          charge.update(params.merge(payment_information))
+          user.update(payment_information)
+
+          charge
+        end
+
+        def notify_user(billable, charge)
+          if Pay.send_emails && charge.respond_to?(:receipt)
+            Pay::UserMailer.with(billable: billable, charge: charge).receipt.deliver_later
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Pay
+  module Paddle
+    module Webhooks
+      class SubscriptionUpdated
+        def initialize(data)
+          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: data["subscription_id"])
+
+          return if subscription.nil?
+
+          case data["status"]
+          when "deleted"
+            subscription.status = "canceled"
+            subscription.ends_at = Time.zone.parse(data["next_bill_date"]) || Time.zone.now if subscription.ends_at.blank?
+          when "trialing"
+            subscription.status = "trialing"
+            subscription.trial_ends_at = Time.zone.parse(data["next_bill_date"])
+          when "active"
+            subscription.status = "active"
+            subscription.paddle_paused_from = Time.zone.parse(data["paused_from"]) if data["paused_from"].present?
+          else
+            subscription.status = data["status"]
+          end
+
+          subscription.quantity = data["new_quantity"]
+          subscription.processor_plan = data["subscription_plan_id"]
+          subscription.paddle_update_url = data["update_url"]
+          subscription.paddle_cancel_url = data["cancel_url"]
+
+          # If user was on trial, their subscription ends at the end of the trial
+          subscription.ends_at = subscription.trial_ends_at if subscription.on_trial?
+
+          subscription.save!
+        end
+      end
+    end
+  end
+end

data/lib/pay/receipts.rb

@@ -28,13 +28,13 @@ module Pay
 
     def line_items
       line_items = [
-        ["Date", created_at.to_s],
-        ["Account Billed", "#{owner.name} (#{owner.email})"],
-        ["Product", product],
-        ["Amount", ActionController::Base.helpers.number_to_currency(amount / 100.0)],
-        ["Charged to", charged_to]
+        [I18n.t("receipt.date"), created_at.to_s],
+        [I18n.t("receipt.account_billed"), "#{owner.name} (#{owner.email})"],
+        [I18n.t("receipt.product"), product],
+        [I18n.t("receipt.amount"), ActionController::Base.helpers.number_to_currency(amount / 100.0)],
+        [I18n.t("receipt.charged_to"), charged_to]
       ]
-      line_items << ["Additional Info", owner.extra_billing_info] if owner.extra_billing_info?
+      line_items << [I18n.t("receipt.additional_info"), owner.extra_billing_info] if owner.extra_billing_info?
       line_items
     end
   end

data/lib/pay/stripe.rb

@@ -12,7 +12,7 @@ module Pay
 
     def setup
       ::Stripe.api_key = private_key
-      ::Stripe.api_version = '2020-08-27'
+      ::Stripe.api_version = "2020-08-27"
       ::StripeEvent.signing_secret = signing_secret
 
       Pay.charge_model.include Pay::Stripe::Charge

data/lib/pay/stripe/billable.rb

@@ -1,6 +1,12 @@
 module Pay
   module Stripe
     module Billable
+      extend ActiveSupport::Concern
+
+      included do
+        scope :stripe, -> { where(processor: :stripe) }
+      end
+
       # Handles Billable#customer
       #
       # Returns Stripe::Customer
@@ -11,7 +17,7 @@ module Pay
           create_stripe_customer
         end
       rescue ::Stripe::StripeError => e
-        raise Error, e.message
+        raise Pay::Stripe::Error, e
       end
 
       def create_setup_intent
@@ -41,7 +47,7 @@ module Pay
         # Create a new charge object
         Stripe::Webhooks::ChargeSucceeded.new.create_charge(self, payment_intent.charges.first)
       rescue ::Stripe::StripeError => e
-        raise Error, e.message
+        raise Pay::Stripe::Error, e
       end
 
       # Handles Billable#subscribe
@@ -74,7 +80,7 @@ module Pay
 
         subscription
       rescue ::Stripe::StripeError => e
-        raise Error, e.message
+        raise Pay::Stripe::Error, e
       end
 
       # Handles Billable#update_card
@@ -91,13 +97,13 @@ module Pay
         update_stripe_card_on_file(payment_method.card)
         true
       rescue ::Stripe::StripeError => e
-        raise Error, e.message
+        raise Pay::Stripe::Error, e
       end
 
       def update_stripe_email!
         customer = stripe_customer
         customer.email = email
-        customer.description = customer_name
+        customer.name = customer_name
         customer.save
       end
 
@@ -137,7 +143,7 @@ module Pay
       private
 
       def create_stripe_customer
-        customer = ::Stripe::Customer.create(email: email, description: customer_name)
+        customer = ::Stripe::Customer.create(email: email, name: customer_name)
         update(processor: "stripe", processor_id: customer.id)
 
         # Update the user's card on file if a token was passed in