pay 2.3.1 → 2.5.0

data/lib/pay/braintree/webhooks/subscription_expired.rb

@@ -0,0 +1,19 @@
+# A subscription reaches the specified number of billing cycles and expires.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionExpired
+        def call(event)
+          subscription = event.subscription
+          return if subscription.nil?
+
+          pay_subscription = Pay.subscription_model.find_by(processor: :braintree, processor_id: subscription.id)
+          return unless pay_subscription.present?
+
+          pay_subscription.update!(ends_at: Time.current, status: :canceled)
+        end
+      end
+    end
+  end
+end

data/lib/pay/braintree/webhooks/subscription_trial_ended.rb

@@ -0,0 +1,19 @@
+# A subscription's trial period ends.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionTrialEnded
+        def call(event)
+          subscription = event.subscription
+          return if subscription.nil?
+
+          pay_subscription = Pay.subscription_model.find_by(processor: :braintree, processor_id: subscription.id)
+          return unless pay_subscription.present?
+
+          pay_subscription.update(trial_ends_at: Time.zone.now)
+        end
+      end
+    end
+  end
+end

data/lib/pay/braintree/webhooks/subscription_went_active.rb

@@ -0,0 +1,19 @@
+# A subscription's first authorized transaction is created, or a successful transaction moves a subscription from the Past Due status to the Active status. Subscriptions with trial periods will not trigger this notification when they move from the trial period into the first billing cycle.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionWentActive
+        def call(event)
+          subscription = event.subscription
+          return if subscription.nil?
+
+          pay_subscription = Pay.subscription_model.find_by(processor: :braintree, processor_id: subscription.id)
+          return unless pay_subscription.present?
+
+          pay_subscription.update!(status: :active)
+        end
+      end
+    end
+  end
+end

data/lib/pay/braintree/webhooks/subscription_went_past_due.rb

@@ -0,0 +1,19 @@
+# A subscription has moved from the Active status to the Past Due status. This will only be triggered when the initial transaction in a billing cycle is declined. Once the status moves to past due, it will not be triggered again in that billing cycle.
+
+module Pay
+  module Braintree
+    module Webhooks
+      class SubscriptionWentPastDue
+        def call(event)
+          subscription = event.subscription
+          return if subscription.nil?
+
+          pay_subscription = Pay.subscription_model.find_by(processor: :braintree, processor_id: subscription.id)
+          return unless pay_subscription.present?
+
+          pay_subscription.update!(status: :past_due)
+        end
+      end
+    end
+  end
+end

data/lib/pay/engine.rb

@@ -8,7 +8,6 @@ end
 
 begin
   require "stripe"
-  require "stripe_event"
 rescue LoadError
 end
 

data/lib/pay/errors.rb

@@ -0,0 +1,73 @@
+module Pay
+  class Error < StandardError
+    attr_reader :result
+
+    def initialize(result = nil)
+      @result = result
+    end
+  end
+
+  class PaymentError < StandardError
+    attr_reader :payment
+
+    def initialize(payment)
+      @payment = payment
+    end
+  end
+
+  class ActionRequired < PaymentError
+    def message
+      I18n.t("errors.action_required")
+    end
+  end
+
+  class InvalidPaymentMethod < PaymentError
+    def message
+      I18n.t("errors.invalid_payment")
+    end
+  end
+
+  module Braintree
+    class Error < Error
+      def message
+        result.message
+      end
+    end
+
+    class AuthorizationError < Braintree::Error
+      def message
+        I18n.t("errors.braintree.authorization")
+      end
+    end
+  end
+
+  module Stripe
+    class Error < Error
+      def message
+        I18n.t("errors.stripe.#{result.code}", default: result.message)
+      end
+    end
+  end
+
+  module Paddle
+    class Error < Error
+      def message
+        I18n.t("errors.paddle.#{result.code}", default: result.message)
+      end
+    end
+  end
+
+  class BraintreeError < Braintree::Error
+    def message
+      ActiveSupport::Deprecation.warn("Pay::BraintreeError is deprecated. Instead, use `Pay::Braintree::Error`.")
+      super
+    end
+  end
+
+  class BraintreeAuthorizationError < BraintreeError
+    def message
+      ActiveSupport::Deprecation.warn("Pay::BraintreeAuthorizationError is deprecated. Instead, use `Pay::Braintree::AuthorizationError`.")
+      I18n.t("errors.braintree.authorization")
+    end
+  end
+end

data/lib/pay/paddle/billable.rb

@@ -23,11 +23,11 @@ module Pay
           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])
+          created_at: Time.zone.parse(response[:payment_date])
         )
         charge
       rescue ::PaddlePay::PaddlePayError => e
-        raise Error, e.message
+        raise Pay::Paddle::Error, e
       end
 
       def create_paddle_subscription(name, plan, options = {})
@@ -35,7 +35,7 @@ module Pay
       end
 
       def update_paddle_card(token)
-        # pass
+        sync_payment_information_from_paddle
       end
 
       def update_paddle_email!
@@ -44,14 +44,14 @@ module Pay
 
       def paddle_trial_end_date(subscription)
         return unless subscription.state == "trialing"
-        DateTime.parse(subscription.next_payment[:date]).end_of_day
+        Time.zone.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
+        raise Pay::Paddle::Error, e
       end
 
       def paddle_invoice!(options = {})
@@ -61,6 +61,35 @@ module Pay
       def paddle_upcoming_invoice
         # pass
       end
+
+      def sync_payment_information_from_paddle
+        payment_information = paddle_payment_information(subscription.processor_id)
+        update!(payment_information) unless payment_information.empty?
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Pay::Paddle::Error, e
+      end
+
+      def paddle_payment_information(subscription_id)
+        subscription_user = PaddlePay::Subscription::User.list({subscription_id: subscription_id}).try(:first)
+        payment_information = subscription_user ? subscription_user[:payment_information] : nil
+        return {} if payment_information.nil?
+
+        case payment_information[:payment_method]
+        when "card"
+          {
+            card_type: payment_information[:card_type],
+            card_last4: payment_information[:last_four_digits],
+            card_exp_month: payment_information[:expiry_date].split("/").first,
+            card_exp_year: payment_information[:expiry_date].split("/").last
+          }
+        when "paypal"
+          {
+            card_type: "PayPal"
+          }
+        else
+          {}
+        end
+      end
     end
   end
 end

data/lib/pay/paddle/charge.rb

@@ -19,7 +19,7 @@ module Pay
         charges = payments.select { |p| p[:id].to_s == processor_id }
         charges.try(:first)
       rescue ::PaddlePay::PaddlePayError => e
-        raise Error, e.message
+        raise Pay::Paddle::Error, e
       end
 
       def paddle_refund!(amount_to_refund)
@@ -32,7 +32,7 @@ module Pay
           raise Error, "Payment not found"
         end
       rescue ::PaddlePay::PaddlePayError => e
-        raise Error, e.message
+        raise Pay::Paddle::Error, e
       end
     end
   end

data/lib/pay/paddle/subscription.rb

@@ -4,14 +4,9 @@ module Pay
       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"
+        store_accessor :data, :paddle_paused_from
       end
 
       def paddle_cancel
@@ -20,31 +15,45 @@ module Pay
         if on_trial?
           update(status: :canceled, ends_at: trial_ends_at)
         else
-          update(status: :canceled, ends_at: DateTime.parse(subscription.next_payment[:date]))
+          update(status: :canceled, ends_at: Time.zone.parse(subscription.next_payment[:date]))
         end
       rescue ::PaddlePay::PaddlePayError => e
-        raise Error, e.message
+        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 Error, e.message
+        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(status: :paused, ends_at: DateTime.parse(response[:next_payment][:date]))
+        update(paddle_paused_from: Time.zone.parse(response[:next_payment][:date]))
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Pay::Paddle::Error, e
       end
 
       def paddle_resume
+        unless paused?
+          raise StandardError, "You can only resume paused subscriptions."
+        end
+
         attributes = {pause: false}
         PaddlePay::Subscription::User.update(processor_id, attributes)
-        update(status: :active, ends_at: nil)
+        update(status: :active, paddle_paused_from: nil)
       rescue ::PaddlePay::PaddlePayError => e
-        raise Error, e.message
+        raise Pay::Paddle::Error, e
       end
 
       def paddle_swap(plan)
@@ -52,7 +61,7 @@ module Pay
         attributes[:quantity] = quantity if quantity?
         PaddlePay::Subscription::User.update(processor_id, attributes)
       rescue ::PaddlePay::PaddlePayError => e
-        raise Error, e.message
+        raise Pay::Paddle::Error, e
       end
     end
   end

data/lib/pay/paddle/webhooks.rb

@@ -1 +1,9 @@
 Dir[File.join(__dir__, "webhooks", "**", "*.rb")].sort.each { |file| require file }
+
+Pay::Webhooks.configure do |events|
+  events.subscribe "paddle.subscription_created", Pay::Paddle::Webhooks::SubscriptionCreated.new
+  events.subscribe "paddle.subscription_updated", Pay::Paddle::Webhooks::SubscriptionUpdated.new
+  events.subscribe "paddle.subscription_cancelled", Pay::Paddle::Webhooks::SubscriptionCancelled.new
+  events.subscribe "paddle.subscription_payment_succeeded", Pay::Paddle::Webhooks::SubscriptionPaymentSucceeded.new
+  events.subscribe "paddle.subscription_payment_refunded", Pay::Paddle::Webhooks::SubscriptionPaymentRefunded.new
+end

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

@@ -2,15 +2,15 @@ module Pay
   module Paddle
     module Webhooks
       class SubscriptionCancelled
-        def initialize(data)
-          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: data["subscription_id"])
+        def call(event)
+          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: event["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: DateTime.parse(data["cancellation_effective_date"])) if subscription.ends_at.blank? && data["cancellation_effective_date"].present?
+          subscription.update!(ends_at: Time.zone.parse(event["cancellation_effective_date"])) if subscription.ends_at.blank? && event["cancellation_effective_date"].present?
         end
       end
     end

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

@@ -2,42 +2,42 @@ module Pay
   module Paddle
     module Webhooks
       class SubscriptionCreated
-        def initialize(data)
+        def call(event)
           # 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"])
+          subscription = Pay.subscription_model.find_by(processor: :paddle, processor_id: event["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"])
+            owner = Pay.find_billable(processor: :paddle, processor_id: event["user_id"])
 
             if owner.nil?
-              owner = owner_by_passtrough(data["passthrough"], data["subscription_plan_id"])
-              owner&.update!(processor: "paddle", processor_id: data["user_id"])
+              owner = owner_by_passtrough(event["passthrough"], event["subscription_plan_id"])
+              owner&.update!(processor: "paddle", processor_id: event["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(", ")}")
+              Rails.logger.error("[Pay] Unable to find Pay::Billable with owner: '#{event["passthrough"]}'. Searched these models: #{Pay.billable_models.join(", ")}")
               return
             end
 
-            subscription = Pay.subscription_model.new(owner: owner, name: "default", processor: "paddle", processor_id: data["subscription_id"], status: :active)
+            subscription = Pay.subscription_model.new(owner: owner, name: Pay.default_product_name, processor: "paddle", processor_id: event["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"
+          subscription.quantity = event["quantity"]
+          subscription.processor_plan = event["subscription_plan_id"]
+          subscription.paddle_update_url = event["update_url"]
+          subscription.paddle_cancel_url = event["cancel_url"]
+          subscription.trial_ends_at = Time.zone.parse(event["next_bill_date"]) if event["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.ends_at = if ["paused", "deleted"].include?(event["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"])
+          elsif ["paused", "deleted"].include?(event["status"])
+            Time.zone.parse(event["next_bill_date"])
 
             # Subscription isn't marked to cancel at period end
           end

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

@@ -2,17 +2,17 @@ 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"])
+        def call(event)
+          charge = Pay.charge_model.find_by(processor: :paddle, processor_id: event["subscription_payment_id"])
           return unless charge.present?
 
-          charge.update(amount_refunded: Integer(data["gross_refund"].to_f * 100))
+          charge.update(amount_refunded: Integer(event["gross_refund"].to_f * 100))
           notify_user(charge.owner, charge)
         end
 
-        def notify_user(user, charge)
+        def notify_user(billable, charge)
           if Pay.send_emails
-            Pay::UserMailer.refund(user, charge).deliver_later
+            Pay::UserMailer.with(billable: billable, charge: charge).refund.deliver_later
           end
         end
       end