pay 2.2.1 → 2.4.2

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
@@ -14,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)
 
@@ -24,10 +30,10 @@ module Pay
 
           result.customer
         end
-      rescue ::Braintree::AuthorizationError => e
+      rescue ::Braintree::AuthorizationError
         raise BraintreeAuthorizationError
       rescue ::Braintree::BraintreeError => e
-        raise BraintreeError, e.message
+        raise Pay::Braintree::Error, e
       end
 
       # Handles Billable#charge
@@ -35,19 +41,19 @@ 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)
 
         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 => e
-        raise BraintreeAuthorizationError
+      rescue ::Braintree::AuthorizationError
+        raise Pay::Braintree::AuthorizationError
       rescue ::Braintree::BraintreeError => e
-        raise BraintreeError, e.message
+        raise Pay::Braintree::Error, e
       end
 
       # Handles Billable#subscribe
@@ -68,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 => e
-        raise BraintreeAuthorizationError
+      rescue ::Braintree::AuthorizationError
+        raise Pay::Braintree::AuthorizationError
       rescue ::Braintree::BraintreeError => e
-        raise BraintreeError, e.message
+        raise Pay::Braintree::Error, e
       end
 
       # Handles Billable#update_card
@@ -89,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 => e
-        raise BraintreeAuthorizationError
+      rescue ::Braintree::AuthorizationError
+        raise Pay::Braintree::AuthorizationError
       rescue ::Braintree::BraintreeError => e
-        raise BraintreeError, e.message
+        raise Pay::Braintree::Error, e
       end
 
       def update_braintree_email!
@@ -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,14 +3,18 @@ module Pay
     module Charge
       extend ActiveSupport::Concern
 
+      included do
+        scope :braintree, -> { where(processor: :braintree) }
+      end
+
       def braintree?
         processor == "braintree"
       end
 
       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)
@@ -18,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

@@ -1,9 +1,7 @@
 module Pay
   module Braintree
     module Subscription
-      def braintree?
-        processor == "braintree"
-      end
+      extend ActiveSupport::Concern
 
       def braintree_cancel
         subscription = processor_subscription
@@ -18,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
 
@@ -51,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)
@@ -90,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
@@ -168,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/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/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.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,95 @@
+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: Time.zone.parse(response[:payment_date])
+        )
+        charge
+      rescue ::PaddlePay::PaddlePayError => e
+        raise Pay::Paddle::Error, e
+      end
+
+      def create_paddle_subscription(name, plan, options = {})
+        # pass
+      end
+
+      def update_paddle_card(token)
+        sync_payment_information_from_paddle
+      end
+
+      def update_paddle_email!
+        # pass
+      end
+
+      def paddle_trial_end_date(subscription)
+        return unless subscription.state == "trialing"
+        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 Pay::Paddle::Error, e
+      end
+
+      def paddle_invoice!(options = {})
+        # pass
+      end
+
+      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