pay 2.3.0 → 2.4.4

data/lib/pay/billable.rb

@@ -36,7 +36,7 @@ module Pay
 
     def customer
       check_for_processor
-      raise Pay::Error, "Email is required to create a customer" if email.nil?
+      raise Pay::Error, I18n.t("errors.email_required") if email.nil?
 
       customer = send("#{processor}_customer")
       update_card(card_token) if card_token.present?
@@ -52,7 +52,7 @@ module Pay
       send("create_#{processor}_charge", amount_in_cents, options)
     end
 
-    def subscribe(name: "default", plan: "default", **options)
+    def subscribe(name: Pay.default_product_name, plan: Pay.default_plan_name, **options)
       check_for_processor
       send("create_#{processor}_subscription", name, plan, options)
     end
@@ -63,7 +63,7 @@ module Pay
       send("update_#{processor}_card", token)
     end
 
-    def on_trial?(name: "default", plan: nil)
+    def on_trial?(name: Pay.default_product_name, plan: nil)
       return true if default_generic_trial?(name, plan)
 
       sub = subscription(name: name)
@@ -81,7 +81,7 @@ module Pay
       send("#{processor}_subscription", subscription_id, options)
     end
 
-    def subscribed?(name: "default", processor_plan: nil)
+    def subscribed?(name: Pay.default_product_name, processor_plan: nil)
       subscription = subscription(name: name)
 
       return false if subscription.nil?
@@ -90,13 +90,13 @@ module Pay
       subscription.active? && subscription.processor_plan == processor_plan
     end
 
-    def on_trial_or_subscribed?(name: "default", processor_plan: nil)
+    def on_trial_or_subscribed?(name: Pay.default_product_name, processor_plan: nil)
       on_trial?(name: name, plan: processor_plan) ||
         subscribed?(name: name, processor_plan: processor_plan)
     end
 
-    def subscription(name: "default")
-      subscriptions.for_name(name).last
+    def subscription(name: Pay.default_product_name)
+      subscriptions.loaded? ? subscriptions.reverse.detect { |s| s.name == name } : subscriptions.for_name(name).last
     end
 
     def invoice!(options = {})
@@ -123,14 +123,14 @@ module Pay
       processor == "paddle"
     end
 
-    def has_incomplete_payment?(name: "default")
+    def has_incomplete_payment?(name: Pay.default_product_name)
       subscription(name: name)&.has_incomplete_payment?
     end
 
     private
 
     def check_for_processor
-      raise StandardError, "No payment processor selected. Make sure to set the #{self.class.name}'s `processor` attribute to either 'stripe' or 'braintree'." unless processor
+      raise StandardError, I18n.t("errors.no_processor", class_name: self.class.name) unless processor
     end
 
     # Used for creating a Pay::Subscription in the database

data/lib/pay/braintree/billable.rb

@@ -20,7 +20,7 @@ module Pay
             last_name: try(:last_name),
             payment_method_nonce: card_token
           )
-          raise BraintreeError.new(result), result.message unless result.success?
+          raise Pay::Braintree::Error, result unless result.success?
 
           update(processor: "braintree", processor_id: result.customer.id)
 
@@ -33,7 +33,7 @@ module Pay
       rescue ::Braintree::AuthorizationError
         raise BraintreeAuthorizationError
       rescue ::Braintree::BraintreeError => e
-        raise BraintreeError, e.message
+        raise Pay::Braintree::Error, e
       end
 
       # Handles Billable#charge
@@ -47,13 +47,13 @@ module Pay
         }.merge(options)
 
         result = gateway.transaction.sale(args)
-        raise BraintreeError.new(result), result.message unless result.success?
+        raise Pay::Braintree::Error, result unless result.success?
 
         save_braintree_transaction(result.transaction)
       rescue ::Braintree::AuthorizationError
-        raise BraintreeAuthorizationError
+        raise Pay::Braintree::AuthorizationError
       rescue ::Braintree::BraintreeError => e
-        raise BraintreeError, e.message
+        raise Pay::Braintree::Error, e
       end
 
       # Handles Billable#subscribe
@@ -74,13 +74,13 @@ module Pay
         )
 
         result = gateway.subscription.create(subscription_options)
-        raise BraintreeError.new(result), result.message unless result.success?
+        raise Pay::Braintree::Error, result unless result.success?
 
         create_subscription(result.subscription, "braintree", name, plan, status: :active)
       rescue ::Braintree::AuthorizationError
-        raise BraintreeAuthorizationError
+        raise Pay::Braintree::AuthorizationError
       rescue ::Braintree::BraintreeError => e
-        raise BraintreeError, e.message
+        raise Pay::Braintree::Error, e
       end
 
       # Handles Billable#update_card
@@ -95,15 +95,15 @@ module Pay
             verify_card: true
           }
         )
-        raise BraintreeError.new(result), result.message unless result.success?
+        raise Pay::Braintree::Error, result unless result.success?
 
         update_braintree_card_on_file result.payment_method
         update_subscriptions_to_payment_method(result.payment_method.token)
         true
       rescue ::Braintree::AuthorizationError
-        raise BraintreeAuthorizationError
+        raise Pay::Braintree::AuthorizationError
       rescue ::Braintree::BraintreeError => e
-        raise BraintreeError, e.message
+        raise Pay::Braintree::Error, e
       end
 
       def update_braintree_email!

data/lib/pay/braintree/charge.rb

@@ -13,8 +13,8 @@ module Pay
 
       def braintree_charge
         Pay.braintree_gateway.transaction.find(processor_id)
-      rescue ::Braintree::BraintreeError => e
-        raise Error, e.message
+      rescue ::Braintree::Braintree::Error => e
+        raise Pay::Braintree::Error, e
       end
 
       def braintree_refund!(amount_to_refund)
@@ -22,7 +22,7 @@ module Pay
 
         update(amount_refunded: amount_to_refund)
       rescue ::Braintree::BraintreeError => e
-        raise Error, e.message
+        raise Pay::Braintree::Error, e
       end
     end
   end

data/lib/pay/braintree/subscription.rb

@@ -3,14 +3,6 @@ module Pay
     module Subscription
       extend ActiveSupport::Concern
 
-      included do
-        scope :braintree, -> { where(processor: :braintree) }
-      end
-
-      def braintree?
-        processor == "braintree"
-      end
-
       def braintree_cancel
         subscription = processor_subscription
 
@@ -24,17 +16,33 @@ module Pay
           update(status: :canceled, ends_at: subscription.billing_period_end_date.to_date)
         end
       rescue ::Braintree::BraintreeError => e
-        raise Error, e.message
+        raise Pay::Braintree::Error, e
       end
 
       def braintree_cancel_now!
         gateway.subscription.cancel(processor_subscription.id)
         update(status: :canceled, ends_at: Time.zone.now)
       rescue ::Braintree::BraintreeError => e
-        raise Error, e.message
+        raise Pay::Braintree::Error, e
+      end
+
+      def braintree_on_grace_period?
+        canceled? && Time.zone.now < ends_at
+      end
+
+      def braintree_paused?
+        false
+      end
+
+      def braintree_pause
+        raise NotImplementedError, "Braintree does not support pausing subscriptions"
       end
 
       def braintree_resume
+        unless on_grace_period?
+          raise StandardError, "You can only resume subscriptions within their grace period."
+        end
+
         if canceled? && on_trial?
           duration = trial_ends_at.to_date - Date.today
 
@@ -57,7 +65,7 @@ module Pay
 
         update(status: :active)
       rescue ::Braintree::BraintreeError => e
-        raise Error, e.message
+        raise Pay::Braintree::Error, e
       end
 
       def braintree_swap(plan)
@@ -96,7 +104,7 @@ module Pay
           raise Error, "Braintree failed to swap plans: #{result.message}"
         end
       rescue ::Braintree::BraintreeError => e
-        raise Error, e.message
+        raise Pay::Braintree::Error, e
       end
 
       private
@@ -174,7 +182,7 @@ module Pay
 
         cancel_now!
 
-        owner.subscribe(options.merge(name: name, plan: plan.id))
+        owner.subscribe(**options.merge(name: name, plan: plan.id))
       end
     end
   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